Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Règles de sélection dans la conversion de schémas DMS
<a name="sc-selection-rules"></a>

La conversion de schéma DMS convertit les schémas de base de données d'un moteur à un autre. Vous utilisez des *règles de sélection* pour contrôler les objets de base de données sur lesquels DMS Schema Conversion agit lors d'opérations telles que l'évaluation, la conversion et l'exportation. Une règle de sélection est un objet JSON que vous transmettez via le `SelectionRules` paramètre (ou `--selection-rules` dans la AWS CLI). Sans règle de sélection, une opération n'a aucune raison d'agir. Avec une règle, vous pouvez étendre l'opération à un seul objet, à un schéma complet, à une base de données complète (pour les sources Microsoft SQL Server et SAP ASE (Sybase ASE)) ou à un groupe d'objets correspondant à un modèle.

**Note**  
Lorsque vous utilisez la console AWS de gestion, DMS Schema Conversion construit automatiquement des règles de sélection en fonction de vos choix dans l'interface utilisateur du projet de migration. Il vous suffit d'écrire des règles de sélection directement lorsque vous utilisez l'API ou la AWS CLI de conversion de schéma DMS.

Vous utilisez la même forme de règle à la fois du côté source et du côté cible d'un projet de migration. Le `server-name` champ du localisateur d'objets indique si la règle cible le fournisseur de données source ou le fournisseur de données cible. Un projet de migration unique utilise généralement les deux types de règles : règles sources pour l'évaluation et la conversion ; règles cibles pour l'exportation SQL.

## Format des règles de sélection
<a name="dms-sc-selection-rule-format"></a>

Un document de règles de sélection est un objet JSON comportant un seul `rules` tableau. Chaque entrée du tableau correspond à une règle, et chaque règle doit contenir tous les champs suivants.


| Paramètre | Value | Description | 
| --- | --- | --- | 
| rule-type | selection | Valeur qui identifie le type de règle. Pour toutes les règles de sélection, définissez ce paramètre surselection. Paramètre obligatoire. | 
| rule-id | Une valeur numérique (entier). | Identifiant numérique unique pour la règle. Paramètre obligatoire. | 
| rule-name | Valeur alphanumérique. | Nom unique pour identifier la règle. Paramètre obligatoire. | 
| rule-action | explicit, include ou exclude | Valeur qui détermine la manière dont le localisateur d'objets est interprété. Consultez [Actions de règle](#dms-sc-selection-rule-actions). Paramètre obligatoire. | 
| object-locator | Objet JSON contenant des clés de localisation spécifiques au moteur. | Objet qui identifie les objets de base de données auxquels s'applique la règle. Consultez [Hiérarchie des localisateurs d'objets](#dms-sc-selection-rule-object-locator). Paramètre obligatoire. | 

L'exemple minimal suivant cible un schéma sur un serveur source.

```
{
  "rules": [
    {
      "rule-type": "selection",
      "rule-id": "1",
      "rule-name": "{{rule_name}}",
      "rule-action": "explicit",
      "object-locator": {
        "server-name": "{{source_server}}",
        "schema-name": "{{schema_name}}"
      }
    }
  ]
}
```

**Note**  
Lorsque vous utilisez la AWS CLI, vous pouvez transmettre les règles de sélection de la manière suivante. Il s'agit d'une fonctionnalité AWS CLI standard qui fonctionne avec n'importe quel paramètre de chaîne.  
En ligne : `--selection-rules '{"rules":[...]}'` (utilisez des guillemets simples pour éviter d'échapper aux guillemets doubles JSON)
Chemin relatif : `--selection-rules file://example-rules.json`
Trajectoire absolue : `--selection-rules file:///tmp/example-rules.json`

Toutes les valeurs des champs à l'intérieur `object-locator` doivent être des chaînes non vides. Une chaîne vide (par exemple,`"schema-name": ""`) est rejetée avec l'erreur.

**Note**  
La `database-name` clé est valide uniquement pour les sources Microsoft SQL Server et SAP ASE (Sybase ASE). L'envoi `database-name` d'un localisateur pour tout autre moteur source est rejeté en tant que clé non prise en charge.

## Écriture de règles
<a name="dms-sc-writing-rules"></a>

### Hiérarchie des localisateurs d'objets
<a name="dms-sc-selection-rule-object-locator"></a>

`object-locator`Identifie un ou plusieurs objets de base de données par le biais d'une hiérarchie de clés spécifiques au moteur. Chaque touche réduit la portée ; omettez une touche de niveau inférieur pour l'élargir. La hiérarchie dépend du moteur source :
+ **Microsoft SQL Server et SAP ASE (Sybase ASE)** : clé `server-name` ` → ` `database-name` ` → ` `schema-name` ` → ` au niveau de l'objet (par exemple,). `table-name` Ces moteurs disposent d'un `database-name` niveau supplémentaire entre le serveur et le schéma.
+ **Tous les autres moteurs** (Oracle, IBM Db2 pour et tous les moteurs cibles : PostgreSQL z/OS, Aurora PostgreSQL, MySQL, Aurora MySQL et IBM Db2 LUW) : clé au niveau de l'objet. `server-name` ` → ` `schema-name` ` → ` Ces moteurs n'ont aucun `database-name` niveau ; le schéma est le conteneur supérieur situé juste en dessous`server-name`.

L'exemple suivant sélectionne une table Microsoft SQL Server spécifique.

```
{
  "rules": [
    {
      "rule-type": "selection",
      "rule-id": "1",
      "rule-name": "{{rule_name}}",
      "rule-action": "explicit",
      "object-locator": {
        "server-name": "{{source_server}}",
        "database-name": "{{database_name}}",
        "schema-name": "{{schema_name}}",
        "table-name": "{{table_name}}"
      }
    }
  ]
}
```

Pour étendre le champ d'application à l'ensemble du schéma, omettez la clé au niveau des feuilles. La règle s'applique ensuite à tous les types d'objets adressables de ce schéma, y compris les tables, les vues, les procédures, les fonctions, les séquences et tout autre objet exposé par le moteur source.

```
{
  "rules": [
    {
      "rule-type": "selection",
      "rule-id": "1",
      "rule-name": "{{rule_name}}",
      "rule-action": "explicit",
      "object-locator": {
        "server-name": "{{source_server}}",
        "database-name": "{{database_name}}",
        "schema-name": "{{schema_name}}"
      }
    }
  ]
}
```

Les clés de localisation que vous pouvez utiliser dépendent du moteur source ou cible. Pour la référence clé complète par moteur, voir[Clés de localisation d'objets par base de données](#dms-sc-selection-rule-locator-keys).

### Règles source et règles cibles
<a name="dms-sc-selection-rule-source-vs-target"></a>

Aucun `rule-type` champ explicite ne désigne une règle comme « source » ou « cible ». Vous contrôlez entièrement la distinction par la `server-name` valeur indiquée dans `object-locator` : si elle `server-name` correspond à votre fournisseur de données **source**, la règle cible l'arbre de métadonnées source ; si elle correspond à votre fournisseur de données **cible**, la règle cible l'arbre de métadonnées cible.

Car `server-name` vous pouvez utiliser soit :
+ La valeur **du nom du serveur** configurée dans le fournisseur de données. Il s'agit généralement d'un nom d'hôte ou d'une adresse IP, mais il doit correspondre exactement à la valeur stockée dans le fournisseur de données. Il ne s'agit pas d'un nom DNS ou d'une adresse IP différent correspondant à la même machine.
+ L'**ID de ressource** du fournisseur de données : le dernier segment de son ARN (par exemple, si l'ARN est le cas`arn:aws:dms:us-east-1:111122223333:data-provider:EXAMPLEABCDEFGHIJKLMNOPQRS`, l'ID de ressource est`EXAMPLEABCDEFGHIJKLMNOPQRS`).

### Actions de règle
<a name="dms-sc-selection-rule-actions"></a>

Utilisez le `rule-action` champ pour spécifier comment DMS Schema Conversion interprète les valeurs contenues dans le localisateur d'objets. Vous ne pouvez utiliser des caractères génériques qu'avec `include` et. `exclude`


| Value | Comportement | Contexte d’utilisation | 
| --- | --- | --- | 
| `"include"` | Sélectionne tous les objets dont le nom correspond au modèle. Supporte `%` (toute séquence de zéro ou plusieurs caractères) et `_` (n'importe quel caractère unique) en tant que jokers. `[_]`À utiliser pour faire correspondre un trait de soulignement littéral et un `[%]` caractère de pourcentage littéral. | À utiliser pour associer un groupe d'objets ayant un modèle de dénomination commun. | 
| `"exclude"` | Supprime les objets de l'ensemble déjà sélectionné selon `include` les règles précédentes. Une `exclude` règle sans précédent n'`include`a aucun effet. | À utiliser pour distinguer les exceptions d'un cadre plus large`include`. | 
| `"explicit"` | Sélectionne exactement l'objet nommé. Chaque valeur de localisation, y compris `schema-name``database-name`, et toute clé de feuille telle que `table-name` ou`scalar-function-name`, sont mises en correspondance sous forme de chaîne littérale. Les caractères génériques tels que`%`, `_``[`, et n'`]`ont aucune signification particulière sous`explicit`. | À utiliser lorsque vous connaissez le nom exact de chaque objet sur lequel vous souhaitez agir. | 

**Note**  
Certaines opérations n'acceptent que les `"explicit"` règles et ne prennent pas en charge `"include"` ou`"exclude"`. Consultez la [référence AWS d'API](https://docs.aws.amazon.com/dms/latest/APIReference/API_Operations.html) pour l'opération spécifique afin de vérifier quelles actions de règle elle prend en charge.

## Référence du localisateur d'objets
<a name="dms-sc-locator-reference"></a>

### Clés de localisation d'objets par base de données
<a name="dms-sc-selection-rule-locator-keys"></a>

Les onglets suivants indiquent les clés de localisation pour chaque base de données prise en charge.

------
#### [ SQL Server ]


| Clé | Sélectionne | 
| --- | --- | 
| `server-name` | Le serveur. | 
| `database-name` | Une base de données sur le serveur. | 
| `schema-name` | Schéma au sein de la base de données. | 
| `table-name` | Une table par défaut, ou une vue lorsqu'elle est utilisée avec`"table-type": "view"`. | 
| `table-type` | `"table"`(par défaut) ou`"view"`. | 
| `procedure-name` | Une procédure stockée. | 
| `scalar-function-name` | Fonction à valeur scalaire. | 
| `table-valued-function-name` | Fonction à valeur tabulaire. | 
| `inline-function-name` | Une fonction en ligne. | 
| `aggregate-function-name` | Une fonction d'agrégation. | 
| `synonym-name` | Un synonyme. | 
| `sequence-name` | Une séquence. | 
| `type-name` | Un type. | 
| `table-type-name` | Type de table. | 
| `user-defined-type-name` | Type défini par l'utilisateur. | 
| `xml-schema-collection-name` | Collection de schémas XML. | 
| `category-name` | Une classe d'objets. À utiliser pour cibler une catégorie complète d'objets ; voir[Noms des catégories par moteur](#dms-sc-category-names). | 

------
#### [ Oracle ]


| Clé | Sélectionne | 
| --- | --- | 
| `server-name` | Le serveur. | 
| `schema-name` | Un schéma (utilisateur Oracle). | 
| `table-name` | Une table par défaut, ou une vue lorsqu'elle est utilisée avec`"table-type": "view"`. | 
| `table-type` | `"table"`(par défaut) ou`"view"`. | 
| `procedure-name` | Une procédure stockée. | 
| `function-name` | Une fonction . | 
| `package-name` | Un colis. | 
| `sequence-name` | Une séquence. | 
| `synonym-name` | Un synonyme. | 
| `type-name` | Type défini par l'utilisateur. | 
| `materialized-view-name` | Vue matérialisée. | 
| `category-name` | Une classe d'objets. À utiliser pour cibler une catégorie complète d'objets ; voir[Noms des catégories par moteur](#dms-sc-category-names). | 

------
#### [ SAP ASE (Sybase ASE) ]


| Clé | Sélectionne | 
| --- | --- | 
| `server-name` | Le serveur. | 
| `database-name` | Une base de données sur le serveur. | 
| `schema-name` | Schéma au sein de la base de données. | 
| `table-name` | Une table par défaut, ou une vue lorsqu'elle est utilisée avec`"table-type": "view"`. | 
| `table-type` | `"table"`(par défaut) ou`"view"`. | 
| `materialized-view-name` | Vue matérialisée. | 
| `procedure-name` | Une procédure stockée. | 
| `scalar-function-name` | Fonction à valeur scalaire. | 
| `table-valued-function-name` | Fonction à valeur tabulaire. | 
| `user-defined-type-name` | Type défini par l'utilisateur. | 
| `default-name` | Valeur par défaut définie par l'utilisateur. Accessible `Describe*` uniquement via. | 
| `category-name` | Une classe d'objets. À utiliser pour cibler une catégorie complète d'objets ; voir[Noms des catégories par moteur](#dms-sc-category-names). | 

------
#### [ PostgreSQL ]


| Clé | Sélectionne | 
| --- | --- | 
| `server-name` | Le serveur. | 
| `schema-name` | Un schéma. | 
| `table-name` | Un tableau ou une vue ; `table-type` à utiliser pour distinguer. | 
| `function-name` | Une fonction . | 
| `procedure-name` | Une procédure stockée. | 
| `sequence-name` | Une séquence. | 
| `materialized-view-name` | Vue matérialisée. | 
| `type-name` | Type défini par l'utilisateur. | 
| `domain-name` | Un domaine. | 
| `category-name` | Une classe d'objets. À utiliser pour cibler une catégorie complète d'objets ; voir[Noms des catégories par moteur](#dms-sc-category-names). | 

------
#### [ MySQL ]


| Clé | Sélectionne | 
| --- | --- | 
| `server-name` | Le serveur. | 
| `schema-name` | Un schéma. | 
| `table-name` | Un tableau ou une vue ; `table-type` à utiliser pour distinguer. | 
| `procedure-name` | Une procédure stockée. | 
| `function-name` | Une fonction . | 
| `event-name` | Un événement. | 
| `category-name` | Une classe d'objets. À utiliser pour cibler une catégorie complète d'objets ; voir[Noms des catégories par moteur](#dms-sc-category-names). | 

------
#### [ IBM Db2 for z/OS ]


| Clé | Sélectionne | 
| --- | --- | 
| `server-name` | Le serveur. | 
| `schema-name` | Un schéma. | 
| `table-name` | Table, vue ou table temporaire globale ; `table-type` à utiliser pour faire la distinction. | 
| `table-type` | `"table"`(par défaut) ou`"view"`. | 
| `procedure-name` | Procédure stockée ou procédure externe. | 
| `function-name` | Une fonction (fonction en ligne, scalaire, sourcée, table ou externe). | 
| `sequence-name` | Une séquence. | 
| `alias-name` | Un pseudonyme. Aucun modèle cible PostgreSQL ; à utiliser avec. `StartMetadataModelExportAsScript` `Origin: SOURCE` | 
| `mqtable-name` | Une table de requêtes matérialisée (MQT). Aucun modèle cible PostgreSQL. | 
| `type-name` | Type défini par l'utilisateur (type distinct ou type structuré). Aucun modèle cible PostgreSQL. | 
| `category-name` | Une classe d'objets. À utiliser pour cibler une catégorie complète d'objets ; voir[Noms des catégories par moteur](#dms-sc-category-names). | 

------
#### [ IBM Db2 LUW ]


| Clé | Sélectionne | 
| --- | --- | 
| `server-name` | Le serveur. | 
| `schema-name` | Un schéma. | 
| `table-name` | Un tableau ou une vue ; `table-type` à utiliser pour distinguer. | 
| `procedure-name` | Une procédure stockée. | 
| `function-name` | Une fonction (fonction scalaire, sourcée ou tabulaire). | 
| `sequence-name` | Une séquence. | 
| `module-name` | Un module. | 
| `category-name` | Une classe d'objets. À utiliser pour cibler une catégorie complète d'objets ; voir[Noms des catégories par moteur](#dms-sc-category-names). | 

------

## Noms des catégories par moteur
<a name="dms-sc-category-names"></a>

La `category-name` valeur d'une règle de sélection cible une classe d'objets entière plutôt que des objets individuels. Les noms de catégories sont spécifiques au moteur et distinguent les majuscules et minuscules. L'acceptation d'une opération `category-name` dépend de l'opération. Vérifiez la [référence d'AWS API](https://docs.aws.amazon.com/dms/latest/APIReference/API_Operations.html) de l'opération que vous utilisez. Les onglets ci-dessous couvrent à la fois les moteurs source et cible.

**Important**  
L'envoi d'un nom de catégorie d'un moteur à un projet configuré pour un autre moteur renvoie une erreur. 

------
#### [ SQL Server ]

Les noms de catégories suivants s'appliquent aux sources Microsoft SQL Server.


| Valeur `category-name` | Ce qu'il regroupe | 
| --- | --- | 
| `Tables` | Tables de base. | 
| `Views` | Vues. | 
| `Procedures` | Procédures stockées. | 
| `SQL scalar functions` |  T-SQL Fonctions scalaires. | 
| `SQL table-valued functions` | Multi-statement fonctions à valeur tabulaire. | 
| `SQL inline functions` | Fonctions intégrées à valeur tabulaire. | 
| `Aggregate functions` | User-defined fonctions d'agrégation. | 
| `Synonyms` | T-SQL synonymes. | 
| `Sequences` | Objets de séquence. | 
| `Types` | Collections de schémas XML et types de colonnes. | 
| `Table types` | Table-typed déclarations de paramètres. | 
| `User-Defined Types` | Types d'alias et de CLR définis par l'utilisateur. | 
| `XML Schema Collections` | Collections de schémas XML. | 

------
#### [ Oracle ]

Les noms de catégories suivants s'appliquent aux sources Oracle.


| Valeur `category-name` | Ce qu'il regroupe | 
| --- | --- | 
| `Tables` | Tableaux. | 
| `External Tables` | Tables externes. | 
| `Views` | Vues. | 
| `Packages` | PL/SQL spécifications et corps de l'emballage. | 
| `Procedures` | Procédures stockées. | 
| `Functions` | Toutes les fonctions utilisateur, y compris les fonctions scalaires et en pipeline. | 
| `User Defined Types` | Types d'objets. | 
| `Collection Types` | Types VARRAY et tables imbriquées. | 
| `Sequences` | Séquences. | 
| `Materialized Views` | Vues matérialisées. | 
| `Materialized View Logs` | Materialized-view journaux des modifications. | 
| `Synonyms` | Synonymes publics et privés. | 
| `Clusters` | Clusters d'index et de hachage. | 
| `Database Links` | Liens vers des bases de données. | 

------
#### [ SAP ASE (Sybase ASE) ]

Les noms de catégories suivants s'appliquent aux sources SAP ASE (Sybase ASE).


| Valeur `category-name` | Ce qu'il regroupe | 
| --- | --- | 
| `Tables` | Tables de base. | 
| `Views` | Vues. | 
| `Procedures` | Procédures stockées. | 
| `Scalar Functions` |  T-SQL Fonctions scalaires. | 
| `Table Valued Functions` | Table-valued fonctions. | 
| `Materialized Views` | Vues matérialisées. | 
| `User Defined Types` | Types d'alias définis par l'utilisateur. | 
| `Defaults` | Objets par défaut liés. Describe-only; ne peut pas être converti indépendamment. | 

------
#### [ PostgreSQL ]

Les noms de catégories suivants s'appliquent aux cibles PostgreSQL et Aurora PostgreSQL.


| Valeur `category-name` | Ce qu'il regroupe | 
| --- | --- | 
| `Tables` | Tables de base. | 
| `Views` | Vues. | 
| `Functions` | Fonctions. | 
| `Procedures` | Procédures stockées. | 
| `Sequences` | Séquences. | 
| `Materialized Views` | Vues matérialisées. | 
| `Types` | User-defined types. | 
| `Domains` | Domaines. | 

------
#### [ MySQL ]

Les noms de catégories suivants s'appliquent aux cibles MySQL et Aurora MySQL.


| Valeur `category-name` | Ce qu'il regroupe | 
| --- | --- | 
| `Tables` | Tables de base. | 
| `Views` | Vues. | 
| `Functions` | Fonctions. | 
| `Procedures` | Procédures stockées. | 
| `Events` | Évènements. | 

------
#### [ IBM Db2 for z/OS ]

Les noms de catégories suivants s'appliquent à IBM Db2 for z/OS sources.


| Valeur `category-name` | Clé de localisation | Ce qu'il regroupe | 
| --- | --- | --- | 
| `Tables` | `table-name` \+ `"table-type": "table"` | Tables de base. | 
| `Global Temporary Tables` | `table-name` \+ `"table-type": "table"` | Tables temporaires globales. Aucun modèle cible PostgreSQL. | 
| `Materialized Query Tables` | `mqtable-name` | Tables de requêtes matérialisées (MQT). Aucun modèle cible PostgreSQL. | 
| `Views` | `table-name` \+ `"table-type": "view"` | Vues. | 
| `Aliases` | `alias-name` | Alias. Aucun modèle cible PostgreSQL. | 
| `Procedures` | `procedure-name` | Procédures stockées. | 
| `Functions` | `function-name` | Tous les sous-types de fonctions : scalaire, table, en ligne, source. | 
| `Sequences` | `sequence-name` | Séquences. | 
| `User Defined Types` | `type-name` | Types distincts et types structurés. Aucun modèle cible PostgreSQL. | 
| `External Routines` | `function-name` / `procedure-name` | Fonctions et procédures externes. | 

------
#### [ IBM Db2 LUW ]

Les noms de catégories suivants s'appliquent aux cibles IBM Db2 LUW.


| Valeur `category-name` | Ce qu'il regroupe | 
| --- | --- | 
| `Tables` | Tables de base. | 
| `Views` | Vues. | 
| `Functions` | Fonctions (scalaire, source, table). | 
| `Procedures` | Procédures stockées. | 
| `Sequences` | Séquences. | 
| `Modules` | Des modules. | 

------

## Exemples de règles de sélection
<a name="dms-sc-selection-rule-examples"></a>

Les exemples suivants montrent comment écrire des règles de sélection pour des scénarios de migration courants. Chaque exemple utilise la valeur de `--selection-rules` paramètre que vous transmettriez aux opérations de l'API de conversion de schéma DMS telles que `StartMetadataModelConversion` ou`StartMetadataModelAssessment`.

### Sélectionnez une seule table (Microsoft SQL Server)
<a name="dms-sc-selection-rule-example-single-table"></a>

Sélectionnez une table spécifique pour la conversion à partir d'une source Microsoft SQL Server. Microsoft SQL Server nécessite `database-name` en plus de`schema-name`.

```
{
  "rules": [
    {
      "rule-type": "selection",
      "rule-id": "1",
      "rule-name": "{{rule_name}}",
      "rule-action": "explicit",
      "object-locator": {
        "server-name": "{{source_server}}",
        "database-name": "{{database_name}}",
        "schema-name": "{{schema_name}}",
        "table-name": "{{table_name}}"
      }
    }
  ]
}
```

### Sélectionnez un schéma complet (Oracle)
<a name="dms-sc-selection-rule-example-whole-schema"></a>

Sélectionnez tous les objets d'un schéma Oracle en omettant la clé au niveau de l'objet. Oracle n'a aucun `database-name` niveau ; le schéma est le conteneur supérieur situé en dessous`server-name`.

```
{
  "rules": [
    {
      "rule-type": "selection",
      "rule-id": "1",
      "rule-name": "{{rule_name}}",
      "rule-action": "explicit",
      "object-locator": {
        "server-name": "{{source_server}}",
        "schema-name": "{{schema_name}}"
      }
    }
  ]
}
```

### Sélectionnez une vue (Oracle)
<a name="dms-sc-selection-rule-example-view"></a>

Les vues Oracle sont traitées à l'`table-name`aide de`"table-type": "view"`. Il n'y a pas de `view-name` clé séparée.

```
{
  "rules": [
    {
      "rule-type": "selection",
      "rule-id": "1",
      "rule-name": "{{rule_name}}",
      "rule-action": "explicit",
      "object-locator": {
        "server-name": "{{source_server}}",
        "schema-name": "{{schema_name}}",
        "table-name": "{{view_name}}",
        "table-type": "view"
      }
    }
  ]
}
```

### Sélectionnez une procédure stockée (IBM Db2 pour z/OS)
<a name="dms-sc-selection-rule-example-procedure-db2"></a>

Sélectionnez une procédure stockée spécifique dans un IBM Db2 comme z/OS source. IBM Db2 pour les z/OS utilisations `procedure-name` et passe directement de `server-name` `schema-name` à sans `database-name` niveau.

```
{
  "rules": [
    {
      "rule-type": "selection",
      "rule-id": "1",
      "rule-name": "{{rule_name}}",
      "rule-action": "explicit",
      "object-locator": {
        "server-name": "{{source_server}}",
        "schema-name": "{{schema_name}}",
        "procedure-name": "{{procedure_name}}"
      }
    }
  ]
}
```

### Sélectionnez toutes les procédures d'un schéma (SAP ASE)
<a name="dms-sc-selection-rule-example-all-procedures"></a>

Sélectionnez toutes les procédures d'un schéma SAP ASE (Sybase ASE) en les utilisant `%` comme caractère générique pour. `procedure-name` SAP ASE (Sybase ASE) nécessite `database-name` entre `server-name` et`schema-name`.

```
{
  "rules": [
    {
      "rule-type": "selection",
      "rule-id": "1",
      "rule-name": "{{rule_name}}",
      "rule-action": "include",
      "object-locator": {
        "server-name": "{{source_server}}",
        "database-name": "{{database_name}}",
        "schema-name": "dbo",
        "procedure-name": "%"
      }
    }
  ]
}
```

### Sélection de tables par modèle générique (Microsoft SQL Server)
<a name="dms-sc-selection-rule-example-wildcard"></a>

`%`À utiliser pour faire correspondre plusieurs tables par préfixe. Cet exemple sélectionne toutes les tables dont le nom commence par`Fact_`.

```
{
  "rules": [
    {
      "rule-type": "selection",
      "rule-id": "1",
      "rule-name": "{{rule_name}}",
      "rule-action": "include",
      "object-locator": {
        "server-name": "{{source_server}}",
        "database-name": "{{database_name}}",
        "schema-name": "dbo",
        "table-name": "Fact_%"
      }
    }
  ]
}
```

### Inclure un schéma et exclure des objets par préfixe (Oracle)
<a name="dms-sc-selection-rule-example-include-exclude"></a>

Incluez tous les objets dans un schéma Oracle, puis excluez les tables dont le nom commence par`TMP_`. Les règles sont évaluées dans `rule-id` l'ordre ; `exclude` elles ont priorité lorsqu'elles correspondent.

```
{
  "rules": [
    {
      "rule-type": "selection",
      "rule-id": "1",
      "rule-name": "{{rule_name}}",
      "rule-action": "include",
      "object-locator": {
        "server-name": "{{source_server}}",
        "schema-name": "{{schema_name}}"
      }
    },
    {
      "rule-type": "selection",
      "rule-id": "2",
      "rule-name": "{{rule_name}}",
      "rule-action": "exclude",
      "object-locator": {
        "server-name": "{{source_server}}",
        "schema-name": "{{schema_name}}",
        "table-name": "TMP_%"
      }
    }
  ]
}
```

### Sélectionnez plusieurs procédures explicites (Microsoft SQL Server)
<a name="dms-sc-selection-rule-example-multi-explicit"></a>

Utilisez plusieurs `explicit` règles dans un même document pour sélectionner un ensemble spécifique de procédures par son nom.

```
{
  "rules": [
    {
      "rule-type": "selection",
      "rule-id": "1",
      "rule-name": "{{rule_name}}",
      "rule-action": "explicit",
      "object-locator": {
        "server-name": "{{source_server}}",
        "database-name": "{{database_name}}",
        "schema-name": "dbo",
        "procedure-name": "PROC_A"
      }
    },
    {
      "rule-type": "selection",
      "rule-id": "2",
      "rule-name": "{{rule_name}}",
      "rule-action": "explicit",
      "object-locator": {
        "server-name": "{{source_server}}",
        "database-name": "{{database_name}}",
        "schema-name": "dbo",
        "procedure-name": "PROC_B"
      }
    },
    {
      "rule-type": "selection",
      "rule-id": "3",
      "rule-name": "{{rule_name}}",
      "rule-action": "explicit",
      "object-locator": {
        "server-name": "{{source_server}}",
        "database-name": "{{database_name}}",
        "schema-name": "dbo",
        "procedure-name": "PROC_C"
      }
    }
  ]
}
```

### Inclure par préfixe, exclure par nom (Microsoft SQL Server)
<a name="dms-sc-selection-rule-example-include-exclude-proc"></a>

Utilisez une `include` règle correspondant à chaque procédure dont le nom commence par`PROC_`, puis une `exclude` règle à supprimer `PROC_TEST` de cet ensemble. Une `exclude` règle doit suivre une `include` règle ; une règle autonome n'`exclude`a aucun effet.

```
{
  "rules": [
    {
      "rule-type": "selection",
      "rule-id": "1",
      "rule-name": "{{rule_name}}",
      "rule-action": "include",
      "object-locator": {
        "server-name": "{{source_server}}",
        "database-name": "{{database_name}}",
        "schema-name": "dbo",
        "procedure-name": "PROC_%"
      }
    },
    {
      "rule-type": "selection",
      "rule-id": "2",
      "rule-name": "{{rule_name}}",
      "rule-action": "exclude",
      "object-locator": {
        "server-name": "{{source_server}}",
        "database-name": "{{database_name}}",
        "schema-name": "dbo",
        "procedure-name": "PROC_TEST"
      }
    }
  ]
}
```