Formato delle regole di selezione Regole di scrittura Riferimento al localizzatore di oggetti Nomi delle categorie per motore Esempi di regole di selezione

Regole di selezione in DMS Schema Conversion

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

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. 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. 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

Gerarchia dei localizzatori di oggetti

object-locatorIdentifica 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 livelloserver-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, vedereChiavi di localizzazione degli oggetti per database.

Regole di origine e regole di destinazione

Nessun rule-type campo esplicito contrassegna una regola come «origine» o «destinazione». Puoi controllare la distinzione interamente tramite il server-name valore inobject-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

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-namedatabase-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 per l'operazione specifica per confermare quali azioni della regola supporta.

Riferimento al localizzatore di oggetti

Chiavi di localizzazione degli oggetti per database

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; vedereNomi delle categorie per motore.

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; vedereNomi delle categorie per motore.

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; vedereNomi delle categorie per motore.

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; vedereNomi delle categorie per motore.

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; vedereNomi delle categorie per motore.

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; vedereNomi delle categorie per motore.

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; vedereNomi delle categorie per motore.

Nomi delle categorie per motore

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 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

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 oStartMetadataModelAssessment.

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

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 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 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": "%"
      }
    }
  ]
}

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

Includi tutti gli oggetti in uno schema Oracle, quindi escludi tutte le tabelle i cui nomi iniziano conTMP_. 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_%"
      }
    }
  ]
}

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

Usa una include regola per abbinare ogni procedura il cui nome inizia conPROC_, 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"
      }
    }
  ]
}

Convenzioni dei documenti

Modello di metadati

Regole di trasformazione