Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Auswahlregeln bei der DMS-Schemakonvertierung
<a name="sc-selection-rules"></a>

Die DMS-Schemakonvertierung konvertiert Datenbankschemas von einer Engine in eine andere. Mithilfe von *Auswahlregeln* steuern Sie, auf welche Datenbankobjekte DMS Schema Conversion bei Vorgängen wie Bewertung, Konvertierung und Export reagiert. Eine Auswahlregel ist ein JSON-Objekt, das Sie über den `SelectionRules` Parameter (oder `--selection-rules` in der AWS CLI) übergeben. Ohne eine Auswahlregel hat eine Operation nichts, worauf sie reagieren könnte. Mit einer Regel können Sie den Vorgang auf ein einzelnes Objekt, ein ganzes Schema, eine gesamte Datenbank (für Microsoft SQL Server- und SAP ASE- (Sybase ASE) -Quellen) oder eine Gruppe von Objekten beschränken, denen ein Muster entspricht.

**Anmerkung**  
Wenn Sie die AWS Management Console verwenden, erstellt DMS Schema Conversion automatisch Auswahlregeln auf der Grundlage Ihrer Einstellungen in der Benutzeroberfläche des Migrationsprojekts. Sie müssen Auswahlregeln nur direkt schreiben, wenn Sie die DMS-Schemakonvertierung API oder AWS CLI verwenden.

Sie verwenden dieselbe Regelform sowohl auf der Quell- als auch auf der Zielseite eines Migrationsprojekts. Das `server-name` Feld im Object Locator gibt an, ob die Regel auf den Quelldatenanbieter oder den Zieldatenanbieter abzielt. Ein einzelnes Migrationsprojekt verwendet üblicherweise beide Arten von Regeln: Quellregeln für die Bewertung und Konvertierung; Zielregeln für den SQL-Export.

## Format der Auswahlregeln
<a name="dms-sc-selection-rule-format"></a>

Ein Dokument mit Auswahlregeln ist ein JSON-Objekt mit einem einzigen `rules` Array. Jeder Eintrag im Array ist eine Regel, und jede Regel muss alle der folgenden Felder enthalten.


| Parameter | Wert | Description | 
| --- | --- | --- | 
| rule-type | selection | Ein Wert, der den Regeltyp identifiziert. Setzen Sie diesen Wert für alle Auswahlregeln aufselection. Erforderlicher Parameter. | 
| rule-id | Ein numerischer Wert (Ganzzahl). | Ein eindeutiger numerischer Bezeichner für die Regel. Erforderlicher Parameter. | 
| rule-name | Ein alphanumerischer Wert. | Ein eindeutiger Name zur Identifizierung der Regel. Erforderlicher Parameter. | 
| rule-action | explicit, include oder exclude | Ein Wert, der bestimmt, wie der Objektlocator interpretiert wird. Siehe [Regelaktionen](#dms-sc-selection-rule-actions). Erforderlicher Parameter. | 
| object-locator | Ein JSON-Objekt, das Engine-spezifische Locator-Schlüssel enthält. | Ein Objekt, das die Datenbankobjekte identifiziert, für die die Regel gilt. Siehe [Objekt-Locator-Hierarchie](#dms-sc-selection-rule-object-locator). Erforderlicher Parameter. | 

Das folgende Minimalbeispiel zielt auf ein Schema auf einem Quellserver ab.

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

**Anmerkung**  
Wenn Sie die AWS CLI verwenden, können Sie die Auswahlregeln auf folgende Weise übergeben. Dies ist eine AWS Standard-CLI-Funktion, die mit jedem Zeichenkettenparameter funktioniert.  
Inline: `--selection-rules '{"rules":[...]}'` (Verwenden Sie einfache Anführungszeichen, um zu vermeiden, dass die doppelten JSON-Anführungszeichen maskiert werden)
Relativer Pfad: `--selection-rules file://example-rules.json`
Absoluter Pfad: `--selection-rules file:///tmp/example-rules.json`

Alle darin enthaltenen Feldwerte `object-locator` dürfen keine leeren Zeichenketten sein. Eine leere Zeichenfolge (z. B.`"schema-name": ""`) wird mit dem Fehler zurückgewiesen.

**Anmerkung**  
Der `database-name` Schlüssel ist nur für Microsoft SQL Server- und SAP ASE- (Sybase ASE) -Quellen gültig. Das Senden `database-name` eines Locators für eine andere Quell-Engine wird als nicht unterstützter Schlüssel abgelehnt.

## Schreiben von Regeln
<a name="dms-sc-writing-rules"></a>

### Objekt-Locator-Hierarchie
<a name="dms-sc-selection-rule-object-locator"></a>

Der `object-locator` identifiziert ein oder mehrere Datenbankobjekte anhand einer Hierarchie von Engine-spezifischen Schlüsseln. Jeder Schlüssel schränkt den Bereich ein. Lassen Sie einen Schlüssel auf niedrigerer Ebene weg, um den Bereich zu erweitern. Die Hierarchie hängt von der Quell-Engine ab:
+ **Microsoft SQL Server und SAP ASE (Sybase ASE)** — Schlüssel `server-name` ` → ` `database-name` ` → ` `schema-name` ` → ` auf Objektebene (z. B.). `table-name` Diese Engines verfügen über eine zusätzliche `database-name` Ebene zwischen dem Server und dem Schema.
+ **Alle anderen Engines** (Oracle, IBM Db2 for z/OS und alle Ziel-Engines: PostgreSQL, Aurora PostgreSQL, MySQL, Aurora MySQL und IBM Db2 LUW) — Schlüssel auf Objektebene. `server-name` ` → ` `schema-name` ` → ` Diese Engines haben keine `database-name` Ebene; das Schema ist der oberste Container, der sich direkt darunter befindet. `server-name`

Im folgenden Beispiel wird eine bestimmte Microsoft SQL Server-Tabelle ausgewählt.

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

Um den Gültigkeitsbereich auf das gesamte Schema auszudehnen, lassen Sie den Schlüssel auf der Blattebene weg. Die Regel gilt dann für alle adressierbaren Objekttypen in diesem Schema, einschließlich Tabellen, Ansichten, Prozeduren, Funktionen, Sequenzen und aller anderen Objekte, die die Quell-Engine verfügbar macht.

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

Die Locator-Schlüssel, die Sie verwenden können, hängen von der Quell- oder Ziel-Engine ab. Die vollständige Schlüsselreferenz pro Engine finden Sie unter[Objektlocator-Schlüssel nach Datenbank](#dms-sc-selection-rule-locator-keys).

### Quellregeln und Zielregeln
<a name="dms-sc-selection-rule-source-vs-target"></a>

Kein explizites `rule-type` Feld kennzeichnet eine Regel als „Quelle“ oder „Ziel“. Sie steuern die Unterscheidung ausschließlich über den `server-name` Wert in`object-locator`: Wenn der Wert mit Ihrem **Quelldatenanbieter `server-name`** übereinstimmt, zielt die Regel auf den Quellmetadatenbaum ab. Wenn er mit Ihrem **Zieldatenanbieter** übereinstimmt, zielt die Regel auf den Ziel-Metadatenbaum ab.

Denn `server-name` Sie können entweder Folgendes verwenden:
+ Der im Datenprovider konfigurierte Wert für den **Servernamen**. In der Regel handelt es sich dabei um einen Hostnamen oder eine IP-Adresse, die jedoch exakt mit dem im Datenanbieter gespeicherten Wert übereinstimmen muss — es handelt sich nicht um einen anderen DNS-Namen oder eine andere IP-Adresse, die auf denselben Computer aufgelöst wird.
+ Die **Ressourcen-ID** des Datenproviders — das letzte Segment seines ARN (wenn der ARN beispielsweise ist`arn:aws:dms:us-east-1:111122223333:data-provider:EXAMPLEABCDEFGHIJKLMNOPQRS`, ist die Ressourcen-ID`EXAMPLEABCDEFGHIJKLMNOPQRS`).

### Regelaktionen
<a name="dms-sc-selection-rule-actions"></a>

Verwenden Sie das `rule-action` Feld, um anzugeben, wie die DMS-Schemakonvertierung die Werte im Objektlocator interpretiert. Sie können Platzhalter nur mit und verwenden. `include` `exclude`


| Wert | Behavior | Verwendung | 
| --- | --- | --- | 
| `"include"` | Wählt alle Objekte aus, deren Namen dem Muster entsprechen. Unterstützt `%` (jede Folge von null oder mehr Zeichen) und `_` (jedes einzelne Zeichen) als Platzhalter. Wird verwendet`[_]`, um einem wörtlichen Unterstrich und einem buchstäblichen `[%]` Prozentzeichen zu entsprechen. | Wird verwendet, um einer Gruppe von Objekten ein gemeinsames Benennungsmuster zuzuordnen. | 
| `"exclude"` | Entfernt Objekte aus dem Satz, der bereits nach den vorherigen `include` Regeln ausgewählt wurde. Eine `exclude` Regel ohne vorherige `include` hat keine Auswirkung. | Wird verwendet, um Ausnahmen aus einer umfassenderen `include` Regel herauszuschneiden. | 
| `"explicit"` | Wählt genau das benannte Objekt aus. Jeder Locator-Wert, einschließlich `schema-name``database-name`, und jeder Blatttaste wie `table-name` oder`scalar-function-name`, wird als Literalzeichenfolge abgeglichen. Platzhalterzeichen wie`%`, `_``[`, und `]` haben keine besondere Bedeutung unter. `explicit` | Verwenden Sie diese Option, wenn Sie den genauen Namen aller Objekte kennen, auf die Sie reagieren möchten. | 

**Anmerkung**  
Einige Operationen akzeptieren nur `"explicit"` Regeln und unterstützen `"include"` oder nicht`"exclude"`. Überprüfen Sie in der [AWS API-Referenz](https://docs.aws.amazon.com/dms/latest/APIReference/API_Operations.html) für den jeweiligen Vorgang, welche Regelaktionen er unterstützt.

## Referenz zum Objektfinder
<a name="dms-sc-locator-reference"></a>

### Objektlocator-Schlüssel nach Datenbank
<a name="dms-sc-selection-rule-locator-keys"></a>

Auf den folgenden Registerkarten werden die Locator-Schlüssel für jede unterstützte Datenbank angezeigt.

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


| Key (Schlüssel) | Wählt | 
| --- | --- | 
| `server-name` | Der Server. | 
| `database-name` | Eine Datenbank auf dem Server. | 
| `schema-name` | Ein Schema innerhalb der Datenbank. | 
| `table-name` | Standardmäßig eine Tabelle oder eine Ansicht, wenn sie mit verwendet wird`"table-type": "view"`. | 
| `table-type` | `"table"`(Standard) oder`"view"`. | 
| `procedure-name` | Eine gespeicherte Prozedur. | 
| `scalar-function-name` | Eine Funktion mit Skalarwerten. | 
| `table-valued-function-name` | Eine Tabellenwertfunktion. | 
| `inline-function-name` | Eine Inline-Funktion. | 
| `aggregate-function-name` | Eine Aggregatfunktion. | 
| `synonym-name` | Ein Synonym. | 
| `sequence-name` | Eine Sequenz. | 
| `type-name` | Ein Typ. | 
| `table-type-name` | Ein Tabellentyp. | 
| `user-defined-type-name` | Ein benutzerdefinierter Typ. | 
| `xml-schema-collection-name` | Eine XML-Schemasammlung. | 
| `category-name` | Eine Objektklasse. Wird verwendet, um auf eine ganze Kategorie von Objekten abzuzielen; siehe[Kategorienamen nach Engine](#dms-sc-category-names). | 

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


| Key (Schlüssel) | Wählt | 
| --- | --- | 
| `server-name` | Der Server. | 
| `schema-name` | Ein Schema (Oracle-Benutzer). | 
| `table-name` | Standardmäßig eine Tabelle oder eine Ansicht, wenn sie mit verwendet wird`"table-type": "view"`. | 
| `table-type` | `"table"`(Standard) oder`"view"`. | 
| `procedure-name` | Eine gespeicherte Prozedur. | 
| `function-name` | Eine -Funktion | 
| `package-name` | Ein Paket. | 
| `sequence-name` | Eine Sequenz. | 
| `synonym-name` | Ein Synonym. | 
| `type-name` | Ein benutzerdefinierter Typ. | 
| `materialized-view-name` | Eine materialisierte Ansicht. | 
| `category-name` | Eine Objektklasse. Wird verwendet, um auf eine ganze Kategorie von Objekten abzuzielen; siehe[Kategorienamen nach Engine](#dms-sc-category-names). | 

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


| Key (Schlüssel) | Wählt | 
| --- | --- | 
| `server-name` | Der Server. | 
| `database-name` | Eine Datenbank auf dem Server. | 
| `schema-name` | Ein Schema innerhalb der Datenbank. | 
| `table-name` | Standardmäßig eine Tabelle oder eine Ansicht, wenn sie mit verwendet wird`"table-type": "view"`. | 
| `table-type` | `"table"`(Standard) oder`"view"`. | 
| `materialized-view-name` | Eine materialisierte Ansicht. | 
| `procedure-name` | Eine gespeicherte Prozedur. | 
| `scalar-function-name` | Eine Funktion mit Skalarwerten. | 
| `table-valued-function-name` | Eine Tabellenwertfunktion. | 
| `user-defined-type-name` | Ein benutzerdefinierter Typ. | 
| `default-name` | Ein benutzerdefinierter Standard. Erreichbar `Describe*` nur über. | 
| `category-name` | Eine Objektklasse. Wird verwendet, um auf eine ganze Kategorie von Objekten abzuzielen; siehe[Kategorienamen nach Engine](#dms-sc-category-names). | 

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


| Key (Schlüssel) | Wählt | 
| --- | --- | 
| `server-name` | Der Server. | 
| `schema-name` | Ein Schema. | 
| `table-name` | Eine Tabelle oder eine Ansicht; wird `table-type` zur Unterscheidung verwendet. | 
| `function-name` | Eine -Funktion | 
| `procedure-name` | Eine gespeicherte Prozedur. | 
| `sequence-name` | Eine Sequenz. | 
| `materialized-view-name` | Eine materialisierte Ansicht. | 
| `type-name` | Ein benutzerdefinierter Typ. | 
| `domain-name` | Eine Domäne. | 
| `category-name` | Eine Objektklasse. Wird verwendet, um auf eine ganze Kategorie von Objekten abzuzielen; siehe[Kategorienamen nach Engine](#dms-sc-category-names). | 

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


| Key (Schlüssel) | Wählt | 
| --- | --- | 
| `server-name` | Der Server. | 
| `schema-name` | Ein Schema. | 
| `table-name` | Eine Tabelle oder eine Ansicht; wird `table-type` zur Unterscheidung verwendet. | 
| `procedure-name` | Eine gespeicherte Prozedur. | 
| `function-name` | Eine -Funktion | 
| `event-name` | Ein Ereignis. | 
| `category-name` | Eine Objektklasse. Wird verwendet, um auf eine ganze Kategorie von Objekten abzuzielen; siehe[Kategorienamen nach Engine](#dms-sc-category-names). | 

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


| Key (Schlüssel) | Wählt | 
| --- | --- | 
| `server-name` | Der Server. | 
| `schema-name` | Ein Schema. | 
| `table-name` | Eine Tabelle, Ansicht oder globale temporäre Tabelle; wird `table-type` zur Unterscheidung verwendet. | 
| `table-type` | `"table"`(Standard) oder`"view"`. | 
| `procedure-name` | Eine gespeicherte oder externe Prozedur. | 
| `function-name` | Eine Funktion (Inline-, Skalar-, Quellenfunktion, Tabellenfunktion oder externe Funktion). | 
| `sequence-name` | Eine Sequenz. | 
| `alias-name` | Ein Alias. Kein PostgreSQL-Zielmodell; verwenden Sie `StartMetadataModelExportAsScript` mit. `Origin: SOURCE` | 
| `mqtable-name` | Eine materialisierte Abfragetabelle (MQT). Kein PostgreSQL-Zielmodell. | 
| `type-name` | Ein benutzerdefinierter Typ (eindeutiger Typ oder strukturierter Typ). Kein PostgreSQL-Zielmodell. | 
| `category-name` | Eine Objektklasse. Wird verwendet, um auf eine ganze Kategorie von Objekten abzuzielen; siehe[Kategorienamen nach Engine](#dms-sc-category-names). | 

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


| Key (Schlüssel) | Wählt | 
| --- | --- | 
| `server-name` | Der Server. | 
| `schema-name` | Ein Schema. | 
| `table-name` | Eine Tabelle oder eine Ansicht; wird `table-type` zur Unterscheidung verwendet. | 
| `procedure-name` | Eine gespeicherte Prozedur. | 
| `function-name` | Eine Funktion (Skalar-, Quellen- oder Tabellenfunktion). | 
| `sequence-name` | Eine Sequenz. | 
| `module-name` | Ein Modul. | 
| `category-name` | Eine Objektklasse. Wird verwendet, um auf eine ganze Kategorie von Objekten abzuzielen; siehe[Kategorienamen nach Engine](#dms-sc-category-names). | 

------

## Kategorienamen nach Engine
<a name="dms-sc-category-names"></a>

Der `category-name` Wert in einer Auswahlregel bezieht sich auf eine gesamte Objektklasse und nicht auf einzelne Objekte. Kategorienamen sind maschinenspezifisch und es wird zwischen Groß- und Kleinschreibung unterschieden. Ob ein Vorgang akzeptiert wird, `category-name` hängt vom Vorgang ab. Überprüfen Sie die [AWS API-Referenz](https://docs.aws.amazon.com/dms/latest/APIReference/API_Operations.html) für den Vorgang, den Sie verwenden. Die folgenden Registerkarten decken sowohl Quell- als auch Ziel-Engines ab.

**Wichtig**  
Beim Senden eines Kategorienamens von einer Engine an ein Projekt, das für eine andere Engine konfiguriert ist, wird ein Fehler zurückgegeben. 

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

Die folgenden Kategorienamen gelten für Microsoft SQL Server-Quellen.


| `category-name` Wert | Was gruppiert es | 
| --- | --- | 
| `Tables` | Basistabellen. | 
| `Views` | Ansichten. | 
| `Procedures` | Gespeicherte Prozeduren. | 
| `SQL scalar functions` | Skalare T-SQL Funktionen. | 
| `SQL table-valued functions` | Multi-statement Funktionen mit Tabellenwerten. | 
| `SQL inline functions` | Inline-Funktionen mit Tabellenwerten. | 
| `Aggregate functions` | User-defined Aggregatfunktionen. | 
| `Synonyms` | T-SQL Synonyme. | 
| `Sequences` | Objekte sequenzieren. | 
| `Types` | XML-Schemasammlungen und Spaltentypen. | 
| `Table types` | Table-typed Parameterdeklarationen. | 
| `User-Defined Types` | Benutzerdefinierte Alias- und CLR-Typen. | 
| `XML Schema Collections` | XML-Schemasammlungen. | 

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

Die folgenden Kategorienamen gelten für Oracle-Quellen.


| `category-name` Wert | Was gruppiert es | 
| --- | --- | 
| `Tables` | Tische. | 
| `External Tables` | Externe Tabellen. | 
| `Views` | Ansichten. | 
| `Packages` | PL/SQL Paketspezifikationen und Karosserien. | 
| `Procedures` | Gespeicherte Prozeduren. | 
| `Functions` | Alle Benutzerfunktionen, einschließlich Skalar- und Pipeline-Funktionen. | 
| `User Defined Types` | Objekttypen. | 
| `Collection Types` | VARRAY- und verschachtelte Tabellentypen. | 
| `Sequences` | Sequenzen. | 
| `Materialized Views` | Materialisierte Ansichten. | 
| `Materialized View Logs` | Materialized-view Logs ändern. | 
| `Synonyms` | Öffentliche und private Synonyme. | 
| `Clusters` | Index- und Hash-Cluster. | 
| `Database Links` | Datenbank-Links. | 

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

Die folgenden Kategorienamen gelten für SAP ASE-Quellen (Sybase ASE).


| `category-name` Wert | Was gruppiert es | 
| --- | --- | 
| `Tables` | Basistabellen. | 
| `Views` | Ansichten. | 
| `Procedures` | Gespeicherte Prozeduren. | 
| `Scalar Functions` | Skalare T-SQL Funktionen. | 
| `Table Valued Functions` | Table-valued Funktionen. | 
| `Materialized Views` | Materialisierte Ansichten. | 
| `User Defined Types` | Alias benutzerdefinierte Typen. | 
| `Defaults` | Gebundene Standardobjekte. Describe-only; kann nicht unabhängig konvertiert werden. | 

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

Die folgenden Kategorienamen gelten für PostgreSQL- und Aurora PostgreSQL-Ziele.


| `category-name` Wert | Was gruppiert es | 
| --- | --- | 
| `Tables` | Basistabellen. | 
| `Views` | Ansichten. | 
| `Functions` | Funktionen. | 
| `Procedures` | Gespeicherte Prozeduren. | 
| `Sequences` | Sequenzen. | 
| `Materialized Views` | Materialisierte Ansichten. | 
| `Types` | User-defined Typen. | 
| `Domains` | Domänen. | 

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

Die folgenden Kategorienamen gelten für MySQL- und Aurora MySQL-Ziele.


| `category-name` Wert | Was gruppiert es | 
| --- | --- | 
| `Tables` | Basistabellen. | 
| `Views` | Ansichten. | 
| `Functions` | Funktionen. | 
| `Procedures` | Gespeicherte Prozeduren. | 
| `Events` | Ereignisse. | 

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

Die folgenden Kategorienamen gelten für IBM Db2 für z/OS Quellen.


| `category-name` Wert | Locator-Schlüssel | Was gruppiert es | 
| --- | --- | --- | 
| `Tables` | `table-name` \+ `"table-type": "table"` | Basistabellen. | 
| `Global Temporary Tables` | `table-name` \+ `"table-type": "table"` | Globale temporäre Tabellen. Kein PostgreSQL-Zielmodell. | 
| `Materialized Query Tables` | `mqtable-name` | Materialisierte Abfragetabellen (MQTs). Kein PostgreSQL-Zielmodell. | 
| `Views` | `table-name` \+ `"table-type": "view"` | Ansichten. | 
| `Aliases` | `alias-name` | Aliase. Kein PostgreSQL-Zielmodell. | 
| `Procedures` | `procedure-name` | Gespeicherte Prozeduren. | 
| `Functions` | `function-name` | Alle Funktionsuntertypen: Skalar, Tabelle, Inline, Sourced. | 
| `Sequences` | `sequence-name` | Sequenzen. | 
| `User Defined Types` | `type-name` | Verschiedene Typen und strukturierte Typen. Kein PostgreSQL-Zielmodell. | 
| `External Routines` | `function-name` / `procedure-name` | Externe Funktionen und externe Prozeduren. | 

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

Die folgenden Kategorienamen gelten für IBM Db2-LUW-Ziele.


| `category-name` Wert | Was gruppiert es | 
| --- | --- | 
| `Tables` | Basistabellen. | 
| `Views` | Ansichten. | 
| `Functions` | Funktionen (skalar, bezogen, Tabelle). | 
| `Procedures` | Gespeicherte Prozeduren. | 
| `Sequences` | Sequenzen. | 
| `Modules` | Module. | 

------

## Beispiele für Auswahlregeln.
<a name="dms-sc-selection-rule-examples"></a>

Die folgenden Beispiele zeigen, wie Auswahlregeln für gängige Migrationsszenarien geschrieben werden. In jedem Beispiel wird der `--selection-rules` Parameterwert verwendet, den Sie an API-Operationen für die DMS-Schemakonvertierung wie `StartMetadataModelConversion` oder `StartMetadataModelAssessment` übergeben würden.

### Wählen Sie eine einzelne Tabelle aus (Microsoft SQL Server)
<a name="dms-sc-selection-rule-example-single-table"></a>

Wählen Sie eine bestimmte Tabelle für die Konvertierung aus einer Microsoft SQL Server-Quelle aus. Microsoft SQL Server benötigt `database-name` zusätzlich zu`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}}"
      }
    }
  ]
}
```

### Wählen Sie ein ganzes Schema aus (Oracle)
<a name="dms-sc-selection-rule-example-whole-schema"></a>

Wählen Sie alle Objekte in einem Oracle-Schema aus, indem Sie den Schlüssel auf Objektebene weglassen. Oracle hat keine `database-name` Ebene; das Schema ist der oberste Container unter. `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}}"
      }
    }
  ]
}
```

### Wählen Sie eine Ansicht (Oracle)
<a name="dms-sc-selection-rule-example-view"></a>

Oracle-Ansichten werden `table-name` mit with adressiert`"table-type": "view"`. Es gibt keinen separaten `view-name` Schlüssel.

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

### Wählen Sie eine gespeicherte Prozedur aus (IBM Db2 for z/OS)
<a name="dms-sc-selection-rule-example-procedure-db2"></a>

Wählen Sie eine bestimmte gespeicherte Prozedur aus einem IBM Db2 als Quelle aus. z/OS IBM Db2 for z/OS verwendet `procedure-name` und wechselt ohne `database-name` Ebene direkt von `server-name` `schema-name` zu.

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

### Wählen Sie alle Prozeduren in einem Schema aus (SAP ASE)
<a name="dms-sc-selection-rule-example-all-procedures"></a>

Wählen Sie jede Prozedur in einem SAP ASE-Schema (Sybase ASE) aus, indem Sie sie `%` als Platzhalter für verwenden. `procedure-name` SAP ASE (Sybase ASE) erfordert `database-name` zwischen und. `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": "%"
      }
    }
  ]
}
```

### Tabellen nach Platzhaltermuster auswählen (Microsoft SQL Server)
<a name="dms-sc-selection-rule-example-wildcard"></a>

Wird verwendet`%`, um mehrere Tabellen anhand des Präfixes zuzuordnen. In diesem Beispiel werden alle Tabellen ausgewählt, deren Namen mit beginnen`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_%"
      }
    }
  ]
}
```

### Schließen Sie ein Schema ein und schließen Sie Objekte anhand eines Präfixes aus (Oracle)
<a name="dms-sc-selection-rule-example-include-exclude"></a>

Schließen Sie alle Objekte in ein Oracle-Schema ein und schließen Sie dann alle Tabellen aus, deren Namen mit beginnen`TMP_`. Regeln werden der Reihe nach `rule-id` ausgewertet; sie haben `exclude` Vorrang, wenn sie übereinstimmen.

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

### Wählen Sie mehrere explizite Prozeduren aus (Microsoft SQL Server)
<a name="dms-sc-selection-rule-example-multi-explicit"></a>

Verwenden Sie mehrere `explicit` Regeln in einem einzigen Dokument, um einen bestimmten Satz von Prozeduren anhand des Namens auszuwählen.

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

### Nach Präfix einschließen, nach Namen ausschließen (Microsoft SQL Server)
<a name="dms-sc-selection-rule-example-include-exclude-proc"></a>

Verwenden Sie eine `include` Regel, um jeder Prozedur zuzuordnen, deren Name mit 1 beginnt`PROC_`, und anschließend eine `exclude` Regel, die Sie `PROC_TEST` aus dieser Gruppe entfernen möchten. Eine `exclude` Regel muss einer `include` Regel folgen; eine eigenständige Regel `exclude` hat keine Wirkung.

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