Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Regole di selezione in DMS Schema Conversion
<a name="sc-selection-rules"></a>

DMS Schema Conversion converte gli schemi di database da un motore all'altro. *Le regole di selezione* vengono utilizzate per controllare su quali oggetti del database agisce DMS Schema Conversion durante operazioni quali valutazione, conversione ed esportazione. Una regola di selezione è un oggetto JSON che passi attraverso il `SelectionRules` parametro (o `--selection-rules` nella AWS CLI). Senza una regola di selezione, un'operazione non ha nulla su cui agire. Con una regola, è possibile definire l'ambito dell'operazione su un singolo oggetto, un intero schema, un intero database (per sorgenti Microsoft SQL Server e SAP ASE (Sybase ASE)) o un gruppo di oggetti abbinati da un pattern.

**Nota**  
Quando si utilizza la console di AWS gestione, DMS Schema Conversion costruisce automaticamente le regole di selezione in base alle scelte effettuate nell'interfaccia utente del progetto di migrazione. È necessario scrivere direttamente le regole di selezione solo quando si utilizza l'API o AWS la CLI di conversione dello schema DMS.

Utilizzi la stessa forma di regole sia sul lato di origine che su quello di destinazione di un progetto di migrazione. Il `server-name` campo nel localizzatore di oggetti specifica se la regola è destinata al provider di dati di origine o al fornitore di dati di destinazione. Un singolo progetto di migrazione utilizza in genere entrambi i tipi di regole: regole di origine per la valutazione e la conversione; regole di destinazione per l'esportazione SQL.

## Formato delle regole di selezione
<a name="dms-sc-selection-rule-format"></a>

Un documento di regole di selezione è un oggetto JSON con un singolo array. `rules` Ogni voce nell'array è una regola e ogni regola deve contenere tutti i campi seguenti.


| Parametro | Valore | Description | 
| --- | --- | --- | 
| rule-type | selection | Un valore che identifica il tipo di regola. Per tutte le regole di selezione, impostalo su. selection Parametro obbligatorio. | 
| rule-id | Un valore numerico (intero). | Un identificatore numerico univoco per la regola. Parametro obbligatorio. | 
| rule-name | Un valore alfanumerico. | Un nome univoco per identificare la regola. Parametro obbligatorio. | 
| rule-action | explicit, include o exclude | Un valore che determina come viene interpretato l'object locator. Per informazioni, consulta [Operazioni delle regole](#dms-sc-selection-rule-actions). Parametro obbligatorio. | 
| object-locator | Un oggetto JSON contenente chiavi di localizzazione specifiche del motore. | Un oggetto che identifica gli oggetti del database a cui si applica la regola. Per informazioni, consulta [Gerarchia dei localizzatori di oggetti](#dms-sc-selection-rule-object-locator). Parametro obbligatorio. | 

L'esempio minimo seguente si rivolge a uno schema su un server di origine.

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

**Nota**  
Quando si utilizza la AWS CLI, è possibile passare le regole di selezione nei seguenti modi. Questa è una funzionalità AWS CLI standard che funziona con qualsiasi parametro di stringa.  
In linea: `--selection-rules '{"rules":[...]}'` (usa le virgolette singole per evitare di sfuggire alle virgolette doppie JSON)
Percorso relativo: `--selection-rules file://example-rules.json`
Percorso assoluto: `--selection-rules file:///tmp/example-rules.json`

Tutti i valori dei campi all'interno `object-locator` devono essere stringhe non vuote. Una stringa vuota (ad esempio,`"schema-name": ""`) viene rifiutata con l'errore.

**Nota**  
La `database-name` chiave è valida solo per le fonti Microsoft SQL Server e SAP ASE (Sybase ASE). L'invio `database-name` di un localizzatore per qualsiasi altro motore di origine viene rifiutato in quanto chiave non supportata.

## Regole di scrittura
<a name="dms-sc-writing-rules"></a>

### Gerarchia dei localizzatori di oggetti
<a name="dms-sc-selection-rule-object-locator"></a>

`object-locator`Identifica uno o più oggetti del database tramite una gerarchia di chiavi specifiche del motore. Ogni chiave restringe l'ambito; ometti una chiave di livello inferiore per ampliare l'ambito. La gerarchia dipende dal motore di origine:
+ **Microsoft SQL Server e SAP ASE (Sybase ASE)**: chiave a `server-name` ` → ` `database-name` ` → ` `schema-name` ` → ` livello di oggetto (ad esempio,). `table-name` Questi motori hanno un `database-name` livello aggiuntivo tra il server e lo schema.
+ **Tutti gli altri motori** (Oracle, IBM Db2 for e tutti i motori di destinazione: PostgreSQL z/OS, Aurora PostgreSQL, MySQL, Aurora MySQL e IBM Db2 LUW): chiave a livello di oggetto. `server-name` ` → ` `schema-name` ` → ` Questi motori non hanno alcun livello`server-name`; lo schema è il contenitore superiore che si trova direttamente al di sotto. `database-name`

L'esempio seguente seleziona una tabella specifica di Microsoft SQL Server.

```
{
  "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}}"
      }
    }
  ]
}
```

Per estendere l'ambito all'intero schema, omettete la chiave a livello di foglia. La regola si applica quindi a tutti i tipi di oggetti indirizzabili in quello schema, incluse tabelle, viste, procedure, funzioni, sequenze e qualsiasi altro oggetto esposto dal motore di origine.

```
{
  "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}}"
      }
    }
  ]
}
```

Le chiavi di localizzazione che è possibile utilizzare dipendono dal motore di origine o di destinazione. Per il riferimento completo dei tasti per motore, vedere[Chiavi di localizzazione degli oggetti per database](#dms-sc-selection-rule-locator-keys).

### Regole di origine e regole di destinazione
<a name="dms-sc-selection-rule-source-vs-target"></a>

Nessun `rule-type` campo esplicito contrassegna una regola come «origine» o «destinazione». Puoi controllare la distinzione interamente tramite il `server-name` valore in`object-locator`: se `server-name` corrisponde al tuo provider di dati di **origine**, la regola ha come destinazione l'albero dei metadati di origine; se corrisponde al tuo provider di dati di **destinazione**, la regola ha come obiettivo l'albero di metadati di destinazione.

Perché `server-name` puoi usare entrambi:
+ Il valore **del nome del server** configurato nel provider di dati. Si tratta in genere di un nome host o di un indirizzo IP, ma deve corrispondere esattamente al valore memorizzato nel provider di dati, non a un nome DNS o IP diverso che si risolve nella stessa macchina.
+ L'**ID della risorsa** del fornitore di dati: l'ultimo segmento del relativo ARN (ad esempio, se l'ARN è`arn:aws:dms:us-east-1:111122223333:data-provider:EXAMPLEABCDEFGHIJKLMNOPQRS`, l'ID della risorsa è). `EXAMPLEABCDEFGHIJKLMNOPQRS`

### Operazioni delle regole
<a name="dms-sc-selection-rule-actions"></a>

Utilizzate il `rule-action` campo per specificare in che modo DMS Schema Conversion interpreta i valori all'interno del localizzatore di oggetti. È possibile utilizzare i caratteri jolly solo con e. `include` `exclude`


| Valore | Comportamento | Quando usare questa funzione | 
| --- | --- | --- | 
| `"include"` | Seleziona tutti gli oggetti i cui nomi corrispondono al modello. Supporta `%` (qualsiasi sequenza di zero o più caratteri) e `_` (qualsiasi carattere singolo) come jolly. Si usa `[_]` per abbinare un carattere di sottolineatura letterale e `[%]` per abbinare un carattere percentuale letterale. | Da utilizzare per abbinare un gruppo di oggetti con uno schema di denominazione condiviso. | 
| `"exclude"` | Rimuove gli oggetti dal set già selezionato in base alle regole precedenti. `include` Una `exclude` regola senza precedenti non `include` ha alcun effetto. | Usalo per ricavare eccezioni da un campo più ampio. `include` | 
| `"explicit"` | Seleziona esattamente l'oggetto denominato. Ogni valore del localizzatore, incluso `schema-name``database-name`, e qualsiasi chiave a foglia come `table-name` o`scalar-function-name`, viene abbinato come stringa letterale. I caratteri jolly come`%`, `_``[`, e non `]` hanno alcun significato speciale in. `explicit` | Utilizzateli quando conoscete il nome esatto di ogni oggetto su cui desiderate agire. | 

**Nota**  
Alcune operazioni accettano solo `"explicit"` regole e non supportano `"include"` o`"exclude"`. Controlla l'[AWS API Reference](https://docs.aws.amazon.com/dms/latest/APIReference/API_Operations.html) per l'operazione specifica per confermare quali azioni della regola supporta.

## Riferimento al localizzatore di oggetti
<a name="dms-sc-locator-reference"></a>

### Chiavi di localizzazione degli oggetti per database
<a name="dms-sc-selection-rule-locator-keys"></a>

Le seguenti schede mostrano le chiavi di localizzazione per ogni database supportato.

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


| Chiave | Seleziona | 
| --- | --- | 
| `server-name` | Il server. | 
| `database-name` | Un database sul server. | 
| `schema-name` | Uno schema all'interno del database. | 
| `table-name` | Una tabella per impostazione predefinita o una vista se utilizzata con`"table-type": "view"`. | 
| `table-type` | `"table"`(impostazione predefinita) o`"view"`. | 
| `procedure-name` | Una procedura memorizzata. | 
| `scalar-function-name` | Una funzione con valori scalari. | 
| `table-valued-function-name` | Una funzione con valori tabellari. | 
| `inline-function-name` | Una funzione in linea. | 
| `aggregate-function-name` | Una funzione aggregata. | 
| `synonym-name` | Un sinonimo. | 
| `sequence-name` | Una sequenza. | 
| `type-name` | Un tipo. | 
| `table-type-name` | Un tipo di tabella. | 
| `user-defined-type-name` | Un tipo definito dall'utente. | 
| `xml-schema-collection-name` | Una raccolta di schemi XML. | 
| `category-name` | Una classe di oggetti. Si usa per indirizzare un'intera categoria di oggetti; vedere[Nomi delle categorie per motore](#dms-sc-category-names). | 

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


| Chiave | Seleziona | 
| --- | --- | 
| `server-name` | Il server. | 
| `schema-name` | Uno schema (utente Oracle). | 
| `table-name` | Una tabella per impostazione predefinita o una vista se utilizzata con`"table-type": "view"`. | 
| `table-type` | `"table"`(impostazione predefinita) o`"view"`. | 
| `procedure-name` | Una procedura memorizzata. | 
| `function-name` | Una funzione . | 
| `package-name` | Un pacchetto. | 
| `sequence-name` | Una sequenza. | 
| `synonym-name` | Un sinonimo. | 
| `type-name` | Un tipo definito dall'utente. | 
| `materialized-view-name` | Una vista materializzata. | 
| `category-name` | Una classe di oggetti. Si usa per indirizzare un'intera categoria di oggetti; vedere[Nomi delle categorie per motore](#dms-sc-category-names). | 

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


| Chiave | Seleziona | 
| --- | --- | 
| `server-name` | Il server. | 
| `database-name` | Un database sul server. | 
| `schema-name` | Uno schema all'interno del database. | 
| `table-name` | Una tabella per impostazione predefinita o una vista se utilizzata con`"table-type": "view"`. | 
| `table-type` | `"table"`(impostazione predefinita) o`"view"`. | 
| `materialized-view-name` | Una vista materializzata. | 
| `procedure-name` | Una procedura memorizzata. | 
| `scalar-function-name` | Una funzione con valori scalari. | 
| `table-valued-function-name` | Una funzione con valori tabellari. | 
| `user-defined-type-name` | Un tipo definito dall'utente. | 
| `default-name` | Un valore predefinito definito dall'utente. Raggiungibile solo tramite`Describe*`. | 
| `category-name` | Una classe di oggetti. Si usa per indirizzare un'intera categoria di oggetti; vedere[Nomi delle categorie per motore](#dms-sc-category-names). | 

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


| Chiave | Seleziona | 
| --- | --- | 
| `server-name` | Il server. | 
| `schema-name` | Uno schema. | 
| `table-name` | Una tabella o una vista; `table-type` da usare per distinguere. | 
| `function-name` | Una funzione . | 
| `procedure-name` | Una procedura memorizzata. | 
| `sequence-name` | Una sequenza. | 
| `materialized-view-name` | Una vista materializzata. | 
| `type-name` | Un tipo definito dall'utente. | 
| `domain-name` | Un dominio. | 
| `category-name` | Una classe di oggetti. Si usa per indirizzare un'intera categoria di oggetti; vedere[Nomi delle categorie per motore](#dms-sc-category-names). | 

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


| Chiave | Seleziona | 
| --- | --- | 
| `server-name` | Il server. | 
| `schema-name` | Uno schema. | 
| `table-name` | Una tabella o una vista; `table-type` da usare per distinguere. | 
| `procedure-name` | Una procedura memorizzata. | 
| `function-name` | Una funzione . | 
| `event-name` | Un evento. | 
| `category-name` | Una classe di oggetti. Si usa per indirizzare un'intera categoria di oggetti; vedere[Nomi delle categorie per motore](#dms-sc-category-names). | 

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


| Chiave | Seleziona | 
| --- | --- | 
| `server-name` | Il server. | 
| `schema-name` | Uno schema. | 
| `table-name` | Una tabella, una vista o una tabella temporanea globale; da usare `table-type` per distinguere. | 
| `table-type` | `"table"`(impostazione predefinita) o`"view"`. | 
| `procedure-name` | Una procedura memorizzata o una procedura esterna. | 
| `function-name` | Una funzione (funzione in linea, scalare, di origine, di tabella o esterna). | 
| `sequence-name` | Una sequenza. | 
| `alias-name` | Un alias. Nessun modello di destinazione PostgreSQL; utilizzare con. `StartMetadataModelExportAsScript` `Origin: SOURCE` | 
| `mqtable-name` | Una tabella di interrogazioni materializzata (MQT). Nessun modello di destinazione PostgreSQL. | 
| `type-name` | Un tipo definito dall'utente (tipo distinto o tipo strutturato). Nessun modello di destinazione PostgreSQL. | 
| `category-name` | Una classe di oggetti. Si usa per indirizzare un'intera categoria di oggetti; vedere[Nomi delle categorie per motore](#dms-sc-category-names). | 

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


| Chiave | Seleziona | 
| --- | --- | 
| `server-name` | Il server. | 
| `schema-name` | Uno schema. | 
| `table-name` | Una tabella o una vista; `table-type` da usare per distinguere. | 
| `procedure-name` | Una procedura memorizzata. | 
| `function-name` | Una funzione (funzione scalare, di origine o di tabella). | 
| `sequence-name` | Una sequenza. | 
| `module-name` | Un modulo. | 
| `category-name` | Una classe di oggetti. Si usa per indirizzare un'intera categoria di oggetti; vedere[Nomi delle categorie per motore](#dms-sc-category-names). | 

------

## Nomi delle categorie per motore
<a name="dms-sc-category-names"></a>

Il `category-name` valore in una regola di selezione è destinato a un'intera classe di oggetti anziché a singoli oggetti. I nomi delle categorie sono specifici del motore e fanno distinzione tra maiuscole e minuscole. L'accettazione o meno di un'operazione `category-name` dipende dall'operazione: controlla il [riferimento AWS API](https://docs.aws.amazon.com/dms/latest/APIReference/API_Operations.html) per l'operazione che stai utilizzando. Le schede seguenti coprono sia i motori di origine che quelli di destinazione.

**Importante**  
L'invio del nome di una categoria da un motore a un progetto configurato per un motore diverso restituisce un errore. 

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

I seguenti nomi di categoria si applicano alle fonti di Microsoft SQL Server.


| `category-name` value | Cosa raggruppa | 
| --- | --- | 
| `Tables` | Tavoli base. | 
| `Views` | Visualizzazioni. | 
| `Procedures` | Procedure archiviate. | 
| `SQL scalar functions` |  T-SQL Funzioni scalari. | 
| `SQL table-valued functions` | Multi-statement funzioni con valori tabellari. | 
| `SQL inline functions` | Funzioni in linea con valori di tabella. | 
| `Aggregate functions` | User-defined funzioni aggregate. | 
| `Synonyms` | T-SQL sinonimi. | 
| `Sequences` | Oggetti in sequenza. | 
| `Types` | Raccolte di schemi XML e tipi di colonne. | 
| `Table types` | Table-typed dichiarazioni di parametri. | 
| `User-Defined Types` | Alias e tipi CLR definiti dall'utente. | 
| `XML Schema Collections` | Raccolte di schemi XML. | 

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

I seguenti nomi di categoria si applicano alle fonti Oracle.


| `category-name` value | Cosa raggruppa | 
| --- | --- | 
| `Tables` | Tavoli. | 
| `External Tables` | Tabelle esterne. | 
| `Views` | Visualizzazioni. | 
| `Packages` | PL/SQL specifiche e corpi dei pacchetti. | 
| `Procedures` | Procedure archiviate. | 
| `Functions` | Tutte le funzioni utente, incluse quelle scalari e pipelines. | 
| `User Defined Types` | Tipi di oggetti. | 
| `Collection Types` | VARRAY e tipi di tabelle annidate. | 
| `Sequences` | Sequenze. | 
| `Materialized Views` | Viste materializzate. | 
| `Materialized View Logs` | Materialized-view registri delle modifiche. | 
| `Synonyms` | Sinonimi pubblici e privati. | 
| `Clusters` | Cluster di indici e hash. | 
| `Database Links` | Collegamenti al database. | 

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

I seguenti nomi di categoria si applicano alle fonti SAP ASE (Sybase ASE).


| `category-name` value | Cosa raggruppa | 
| --- | --- | 
| `Tables` | Tavoli base. | 
| `Views` | Visualizzazioni. | 
| `Procedures` | Procedure archiviate. | 
| `Scalar Functions` |  T-SQL Funzioni scalari. | 
| `Table Valued Functions` | Table-valued funzioni. | 
| `Materialized Views` | Viste materializzate. | 
| `User Defined Types` | Alias per tipi definiti dall'utente. | 
| `Defaults` | Oggetti predefiniti associati. Describe-only; non possono essere convertiti indipendentemente. | 

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

I seguenti nomi di categoria si applicano ai target PostgreSQL e Aurora PostgreSQL.


| `category-name` value | Cosa raggruppa | 
| --- | --- | 
| `Tables` | Tavoli base. | 
| `Views` | Visualizzazioni. | 
| `Functions` | Funzioni. | 
| `Procedures` | Procedure archiviate. | 
| `Sequences` | Sequenze. | 
| `Materialized Views` | Viste materializzate. | 
| `Types` | User-defined tipi. | 
| `Domains` | Domini. | 

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

I seguenti nomi di categoria si applicano ai target MySQL e Aurora MySQL.


| `category-name` value | Cosa raggruppa | 
| --- | --- | 
| `Tables` | Tavoli base. | 
| `Views` | Visualizzazioni. | 
| `Functions` | Funzioni. | 
| `Procedures` | Procedure archiviate. | 
| `Events` | Eventi. | 

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

I seguenti nomi di categoria si applicano a IBM Db2 for z/OS sources.


| `category-name` value | Chiave del localizzatore | Cosa raggruppa | 
| --- | --- | --- | 
| `Tables` | `table-name` \+ `"table-type": "table"` | Tavoli base. | 
| `Global Temporary Tables` | `table-name` \+ `"table-type": "table"` | Tabelle temporanee globali. Nessun modello di destinazione PostgreSQL. | 
| `Materialized Query Tables` | `mqtable-name` | Tabelle di interrogazione materializzate (MQT). Nessun modello di destinazione PostgreSQL. | 
| `Views` | `table-name` \+ `"table-type": "view"` | Visualizzazioni. | 
| `Aliases` | `alias-name` | Alias. Nessun modello di destinazione PostgreSQL. | 
| `Procedures` | `procedure-name` | Procedure archiviate. | 
| `Functions` | `function-name` | Tutti i sottotipi di funzioni: scalar, table, inline, sourced. | 
| `Sequences` | `sequence-name` | Sequenze. | 
| `User Defined Types` | `type-name` | Tipi distinti e tipi strutturati. Nessun modello di destinazione PostgreSQL. | 
| `External Routines` | `function-name` / `procedure-name` | Funzioni esterne e procedure esterne. | 

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

I seguenti nomi di categoria si applicano ai target IBM Db2 LUW.


| `category-name` value | Cosa raggruppa | 
| --- | --- | 
| `Tables` | Tavoli base. | 
| `Views` | Visualizzazioni. | 
| `Functions` | Funzioni (scalari, di origine, tabella). | 
| `Procedures` | Procedure archiviate. | 
| `Sequences` | Sequenze. | 
| `Modules` | Moduli. | 

------

## Esempi di regole di selezione
<a name="dms-sc-selection-rule-examples"></a>

Gli esempi seguenti mostrano come scrivere regole di selezione per scenari di migrazione comuni. Ogni esempio utilizza il valore del `--selection-rules` parametro che passeresti alle operazioni dell'API DMS Schema Conversion come `StartMetadataModelConversion` o`StartMetadataModelAssessment`.

### Seleziona una singola tabella (Microsoft SQL Server)
<a name="dms-sc-selection-rule-example-single-table"></a>

Seleziona una tabella specifica per la conversione da un'origine Microsoft SQL Server. Microsoft SQL Server richiede `database-name` in aggiunta a`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}}"
      }
    }
  ]
}
```

### Seleziona un intero schema (Oracle)
<a name="dms-sc-selection-rule-example-whole-schema"></a>

Seleziona tutti gli oggetti in uno schema Oracle omettendo la chiave a livello di oggetto. Oracle non ha alcun `database-name` livello; lo schema è il contenitore superiore. `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}}"
      }
    }
  ]
}
```

### Seleziona una vista (Oracle)
<a name="dms-sc-selection-rule-example-view"></a>

Le viste Oracle vengono gestite utilizzando `table-name` con`"table-type": "view"`. Non esiste una `view-name` chiave separata.

```
{
  "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"
      }
    }
  ]
}
```

### Seleziona una procedura memorizzata (IBM Db2 for) z/OS
<a name="dms-sc-selection-rule-example-procedure-db2"></a>

Seleziona una procedura memorizzata specifica da un IBM Db2 come origine. z/OS IBM Db2 for z/OS utilizza `procedure-name` e passa direttamente da `server-name` a `schema-name` senza alcun livello. `database-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}}",
        "procedure-name": "{{procedure_name}}"
      }
    }
  ]
}
```

### Seleziona tutte le procedure in uno schema (SAP ASE)
<a name="dms-sc-selection-rule-example-all-procedures"></a>

Seleziona ogni procedura in uno schema SAP ASE (Sybase ASE) utilizzandola `%` come jolly per. `procedure-name` SAP ASE (Sybase ASE) richiede tra e. `database-name` `server-name` `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": "%"
      }
    }
  ]
}
```

### Selezione delle tabelle in base al modello di caratteri jolly (Microsoft SQL Server)
<a name="dms-sc-selection-rule-example-wildcard"></a>

`%`Da utilizzare per abbinare più tabelle in base al prefisso. Questo esempio seleziona tutte le tabelle i cui nomi iniziano con. `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_%"
      }
    }
  ]
}
```

### Include uno schema ed esclude gli oggetti per prefisso (Oracle)
<a name="dms-sc-selection-rule-example-include-exclude"></a>

Includi tutti gli oggetti in uno schema Oracle, quindi escludi tutte le tabelle i cui nomi iniziano con`TMP_`. Le regole vengono valutate in `rule-id` ordine e hanno la `exclude` precedenza quando corrispondono.

```
{
  "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_%"
      }
    }
  ]
}
```

### Seleziona più procedure esplicite (Microsoft SQL Server)
<a name="dms-sc-selection-rule-example-multi-explicit"></a>

Utilizza più `explicit` regole in un unico documento per selezionare un insieme specifico di procedure in base al nome.

```
{
  "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"
      }
    }
  ]
}
```

### Includi per prefisso, escludi per nome (Microsoft SQL Server)
<a name="dms-sc-selection-rule-example-include-exclude-proc"></a>

Usa una `include` regola per abbinare ogni procedura il cui nome inizia con`PROC_`, quindi una `exclude` regola per rimuoverla `PROC_TEST` da quel set. Una `exclude` regola deve seguire una `include` regola; una regola autonoma non `exclude` ha alcun effetto.

```
{
  "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"
      }
    }
  ]
}
```