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.
# Metadatenmodell in der DMS-Schemakonvertierung
Wenn Sie mit DMS Schema Conversion arbeiten, stellt der Service Ihre Datenbankschemas als hierarchischen Baum dar. Dieser Baum wird als *Metadatenbaum* bezeichnet und gilt sowohl für Quell- als auch für Zielschemas. Jedes Element im Baum, einschließlich des Stammelements („Server“), ist ein Metadatenmodell.
Der Metadatenbaum enthält zwei Arten von Elementen:
+ **Objekte** — Stellen tatsächliche Datenbankobjekte wie Tabellen, Funktionen, Ansichten, Sequenzen und Indizes dar. Sie können die SQL-Definition eines Objekts mithilfe der [DescribeMetadataModel](https://docs.aws.amazon.com/dms/latest/APIReference/API_DescribeMetadataModel.html)Anfrage abrufen.
+ **Kategorien** — Virtuelle Gruppierungscontainer wie „Schemas“, „Tabellen“, „Funktionen“ und „Indizes“. Kategorien organisieren Objekte im Baum für die Navigation, haben aber selbst keine SQL-Definitionen.
Der Metadatenbaum lädt Daten nur, wenn Sie sie anfordern. Dieser Ansatz wird als On-Demand-Laden (auch Lazy Loading genannt) bezeichnet, was bedeutet, dass die DMS-Schemakonvertierung Daten nur bei Bedarf aus Ihrer Datenbank abruft. Sie verwenden den Importvorgang, um Metadaten zu laden — entweder indem Sie ein bestimmtes Metadatenmodell aktualisieren oder einen gesamten Teilbaum auf einmal importieren. Bei Vorgängen wie Bewertung und Konvertierung wird der Metadatenbaum ebenfalls automatisch geladen.
## Wie funktioniert das Metadatenmodell
Das Metadatenmodell in DMS Schema Conversion folgt einem Lebenszyklus von Vorgängen. Operationen, die den Metadatenbaum ändern (wie Import und Konvertierung), sind asynchron. Sie starten eine Anforderung für diese Operationen, die im Hintergrund ausgeführt wird. Rufen Sie die entsprechende Describe-API auf, um den Status der Anfrage zu überprüfen. Operationen, die den Baum lesen (z. B. die Beschreibung untergeordneter Elemente oder Definitionen), sind synchron.
**Anmerkung**
Bei der DMS-Schemakonvertierung werden die Begriffe *Operation* und *Anforderung synonym* verwendet.
Der typische Arbeitsablauf umfasst die folgenden Schritte:
1. **Import** — Laden Sie Metadaten aus Ihrer Quell- oder Zieldatenbank in den Metadatenbaum. Sie können entweder das ursprüngliche Metadatenmodell laden oder ein vorhandenes Modell aus der Datenbank neu laden. Weitere Informationen finden Sie unter [Navigieren Sie im Baum](#sc-metadata-model-navigating). Die API-Referenz finden Sie unter [StartMetadataModelImport](https://docs.aws.amazon.com/dms/latest/APIReference/API_StartMetadataModelImport.html).
1. **Bewertung** — Analysieren Sie die ausgewählten Metadaten-Quellmodelle, um die Komplexität der Konvertierung und potenzielle Probleme zu ermitteln. Weitere Informationen finden Sie unter [Erstellung von Bewertungsberichten zur Datenbankmigration mit DMS Schema Conversion](assessment-reports.md).
1. **Konvertieren** — Konvertiert die ausgewählten Metadaten-Quellmodelle in ein zielkompatibles Format. Die konvertierten Definitionen werden als Teil des Ziel-Metadatenbaums gespeichert. Weitere Informationen finden Sie unter [Datenbankschemas in der DMS-Schemakonvertierung konvertieren: schrittweise Anleitung](schema-conversion-convert.md).
1. **Exportieren** — Speichern Sie Metadatendefinitionen. Sie können sowohl Quell- als auch Zielmetadaten als SQL-Skripts in Ihren Amazon S3 S3-Bucket exportieren. Für nicht virtuelle Ziele können Sie konvertierte Objekte auch direkt auf Ihre Zieldatenbank anwenden. Weitere Hinweise zu virtuellen Zielen finden Sie unter[Virtueller Datenanbieter](virtual-data-provider.md). Weitere Informationen zum Anwenden konvertierter Objekte finden Sie unter[Anwenden des konvertierten Codes](schema-conversion-save-apply.md#schema-conversion-apply).
Nachdem Sie die Metadaten-Quellmodelle bewertet oder konvertiert haben, können Sie einen Bewertungsbericht erstellen, um die Ergebnisse zu überprüfen. Weitere Informationen finden Sie unter [Erstellung von Bewertungsberichten zur Datenbankmigration mit DMS Schema Conversion](assessment-reports.md).
Für unterstützte Migrationspaare können Sie auch benutzerdefinierte Anweisungsmetadatenmodelle anhand von SQL-Definitionen mithilfe von [StartMetadataModelCreation](https://docs.aws.amazon.com/dms/latest/APIReference/API_StartMetadataModelCreation.html). Weitere Informationen finden Sie unter [Erstellen Sie Modelle für Kontoauszüge](#sc-metadata-model-creation).
## Navigieren Sie im Metadaten-Modellbaum
Sie können mithilfe der folgenden API-Anfragen im Metadatenbaum navigieren:
+ [DescribeMetadataModelChildren](https://docs.aws.amazon.com/dms/latest/APIReference/API_DescribeMetadataModelChildren.html)— Gibt die untergeordneten Elemente eines bestimmten Metadatenmodells zurück. Jedes untergeordnete Element enthält Auswahlregeln (Filter, die bestimmte Metadatenmodelle identifizieren), die Sie an den nächsten Aufruf übergeben können, um weitere Informationen zu erhalten.
+ [DescribeMetadataModel](https://docs.aws.amazon.com/dms/latest/APIReference/API_DescribeMetadataModel.html)— Gibt den Namen, den Typ und die SQL-Definition eines bestimmten Metadatenmodells zurück.
Beide Anfragen erfordern den `Origin` Parameter (`SOURCE`oder`TARGET`) und verwenden Auswahlregeln, um das Metadatenmodell zu identifizieren. Das Navigationsmuster ist sowohl für die Quell- als auch für die Zielstruktur identisch. Weitere Hinweise zum Format der Auswahlregeln finden Sie unter[Auswahlregeln bei der DMS-Schemakonvertierung](sc-selection-rules.md).
Wählen Sie Ihre bevorzugte Oberfläche, um Navigationsanweisungen anzuzeigen.
------
#### [ AWS Management Console ]
Nachdem Sie Ihr Projekt zur Schemakonvertierung geöffnet haben, können Sie sowohl Quell- als auch Ziel-Metadatenbäume durchsuchen. Weitere Informationen zum Öffnen eines Projekts finden Sie unter[Datenbankschemas in der DMS-Schemakonvertierung konvertieren: schrittweise Anleitung](schema-conversion-convert.md).
In der Konsole werden zwei Strukturbereiche angezeigt: die Quellstruktur auf der linken Seite und die Zielstruktur auf der rechten Seite. Jedes Fenster besteht aus einer Kopfzeile, in der die Datenbank-Engine angezeigt wird, einem Aktionsmenü und dem Metadatenbaum selbst.
Das Aktionsmenü ist kontextabhängig. Nicht für jedes Metadatenmodell sind alle Aktionen verfügbar. Quell- und Zielbäume haben unterschiedliche Aktionslisten.
Um die SQL-Definition und die Eigenschaften eines Metadatenmodells anzuzeigen, wählen Sie es in der Struktur aus. Im mittleren Bereich werden die Registerkarten „Quell-SQL“ und „Ziel-SQL“ mit der Definition sowie eine Registerkarte „Eigenschaften“ mit Metadatenattributen angezeigt. Je nach Metadatenmodelltyp können weitere Registerkarten angezeigt werden, z. B. Spalten für Tabellen und Ansichten oder Parameter für Routinen.
Um die untergeordneten Elemente eines Metadatenmodells zu erweitern, wählen Sie das Erweiterungssymbol (schwarzes Dreieck) neben dem Metadatenmodell aus. Wählen Sie entweder das Erweiterungssymbol oder den Namen des Metadatenmodells, um die untergeordneten Elemente automatisch zu laden.
Wenn Sie ein konvertiertes Quell-Metadatenmodell auswählen, wird das entsprechende Ziel-Metadatenmodell automatisch im Zielstrukturbereich ausgewählt.
Die folgende exemplarische Vorgehensweise zeigt, wie Sie den Metadatenbaum durchsuchen und eine Metadatenmodelldefinition anzeigen.
1. Wählen Sie im Strukturbereich das Erweiterungssymbol neben Ihrem Server aus, um die Kategorien der obersten Ebene anzuzeigen, z. B. **Datenbanken** oder **Schemas**, je nach Datenbank-Engine.
1. Erweitern Sie die Kategorien weiter, um zu dem Metadatenmodell zu gelangen, das Sie untersuchen möchten. Erweitern Sie beispielsweise **Datenbanken**, dann eine bestimmte Datenbank, dann **Schemas**, dann einen Schemanamen und dann eine Kategorie wie **Tabellen**, **Ansichten** oder **Prozeduren**. Einige Datenbank-Engines verfügen nicht über die **Datenbankebene**. Erweitern Sie in diesem Fall direkt **Schemas**.
1. Wählen Sie ein Metadatenmodell aus, um die zugehörige SQL-Definition im mittleren Bereich anzuzeigen. Auf der Registerkarte **Quell-SQL** wird die Quelldefinition angezeigt, und auf der Registerkarte **Ziel-SQL** wird die konvertierte Definition angezeigt, wenn das Metadatenmodell konvertiert wurde.
------
#### [ AWS CLI ]
Um den Metadatenbaum zu durchsuchen, folgen Sie einem sich wiederholenden Muster: Importieren Sie Metadaten auf einer Ebene und beschreiben Sie dann die untergeordneten Elemente auf dieser Ebene. Wiederholen Sie diesen Vorgang, um tiefer in den Baum vorzudringen.
Rufen Sie zunächst [start-metadata-model-import](https://docs.aws.amazon.com/cli/latest/reference/dms/start-metadata-model-import.html) mit einer Auswahlregel auf, die das Metadatenmodell der obersten Ebene identifiziert. Fügen Sie die `server-name` und eine oberste Ebene `category-name` (entweder `Databases` oder`Schemas`, abhängig von der Datenbank-Engine) in die ein. `object-locator` Weitere Hinweise zur Struktur der Auswahlregeln finden Sie unter[Auswahlregeln bei der DMS-Schemakonvertierung](sc-selection-rules.md).
```
aws dms start-metadata-model-import \
--migration-project-identifier "{{my-migration-project}}" \
--origin {{SOURCE}} \
--refresh \
--selection-rules '{"rules":[{"rule-type":"selection","rule-id":"1",
"rule-name":"1","object-locator":{"server-name":"{{my-server}}","category-name":"{{top-level-category}}"},"rule-action":"explicit"}]}'
```
Importanforderungen sind asynchron. Verwenden Sie [describe-metadata-model-imports](https://docs.aws.amazon.com/cli/latest/reference/dms/describe-metadata-model-imports.html), um den Status vor dem Durchsuchen zu überprüfen. Verwenden Sie den `request-id` Filter mit dem von zurückgegebenen `RequestIdentifier` Wert, um einen bestimmten Import zu finden: `start-metadata-model-import`
```
aws dms describe-metadata-model-imports \
--migration-project-identifier "{{my-migration-project}}" \
--filters Name=request-id,Values={{request-identifier}}
```
Rufen Sie nach Abschluss des Imports [describe-metadata-model-children](https://docs.aws.amazon.com/cli/latest/reference/dms/describe-metadata-model-children.html) auf, um die untergeordneten Elemente auf dieser Ebene abzurufen:
```
aws dms describe-metadata-model-children \
--migration-project-identifier "{{my-migration-project}}" \
--origin {{SOURCE}} \
--selection-rules '{"rules":[{"rule-type":"selection","rule-id":"1",
"rule-name":"1","object-locator":{"server-name":"{{my-server}}"},
"rule-action":"explicit"}]}'
```
Jedes Kind in der Antwort enthält ein Feld. `SelectionRules` Übergeben Sie diese Auswahlregeln an den nächsten Import und beschreiben Sie die Aufrufe, um weitere Informationen zu erhalten:
```
{
"MetadataModelChildren": [
{
"MetadataModelName": "Schemas",
"SelectionRules": "{\"rules\":[{\"rule-type\":\"selection\",\"rule-id\":\"1\",\"rule-name\":\"1\",\"object-locator\":{\"server-name\":\"src-database-server\",\"category-name\":\"Schemas\"},\"rule-action\":\"explicit\"}]}"
}
]
}
```
Um zur nächsten Ebene vorzudringen, importieren Sie auf dieser Ebene mithilfe der Auswahlregeln, die Sie vom vorherigen `describe-metadata-model-children` Aufruf erhalten haben, und beschreiben Sie dann die untergeordneten Elemente:
```
aws dms start-metadata-model-import \
--migration-project-identifier "{{my-migration-project}}" \
--origin {{SOURCE}} \
--refresh \
--selection-rules '{{selection-rules-from-previous-response}}'
```
Bevor Sie die untergeordneten Elemente beschreiben, stellen Sie sicher, dass der Import abgeschlossen ist, indem Sie den Status mit überprüfen`describe-metadata-model-imports`. Rufen Sie dann an`describe-metadata-model-children`:
```
aws dms describe-metadata-model-children \
--migration-project-identifier "{{my-migration-project}}" \
--origin {{SOURCE}} \
--selection-rules '{{selection-rules-from-previous-response}}'
```
Die Antwort gibt die Kinder auf dieser Ebene zurück, jedes mit seinen eigenen Auswahlregeln. Übergeben Sie diese Auswahlregeln an den nächsten Import und beschreiben Sie Aufrufe, um weiter in den Baum vorzudringen.
```
{
"MetadataModelChildren": [
{
"MetadataModelName": "{{child-name}}",
"SelectionRules": "{{selection-rules-JSON-string}}"
}
]
}
```
**Verwendung von --refresh im Vergleich zum vollständigen Import**
Wird verwendet`--refresh`, um ein bestimmtes Metadatenmodell aus der Datenbank neu zu laden. Dadurch werden auch die Namen der direkten untergeordneten Elemente geladen. Sie können diese untergeordneten Elemente mit auflisten`describe-metadata-model-children`, aber um sie näher zu beschreiben oder zu durchsuchen, müssen Sie einen weiteren Import auf untergeordneter Ebene ausführen.
Um eine gesamte Unterstruktur zu laden (z. B. alle Objekte in einem Schema, einer Datenbank oder einer bestimmten Kategorie wie Tabellen oder Prozeduren), lassen Sie das `--refresh` Kennzeichen weg und ändern Sie `include` in den Auswahlregeln `rule-action` zu:
```
aws dms start-metadata-model-import \
--migration-project-identifier "{{my-migration-project}}" \
--origin {{SOURCE}} \
--selection-rules '{"rules":[{"rule-type":"selection","rule-id":"1",
"rule-name":"1","object-locator":{{{...}}},
"rule-action":"include"}]}'
```
Das Laden einer vollständigen Unterstruktur kann bei großen Schemas Minuten oder Stunden dauern und belastet Ihre Datenbank. Verwenden Sie für eine interaktive Erkundung bestimmte Zweige `--refresh` und gehen Sie bei Bedarf näher darauf ein.
Um die SQL-Definition eines Metadatenmodells abzurufen, verwenden Sie [describe-metadata-model](https://docs.aws.amazon.com/cli/latest/reference/dms/describe-metadata-model.html). Übergeben Sie die Auswahlregeln, die das spezifische Metadatenmodell aus einer vorherigen Antwort identifizieren: `describe-metadata-model-children`
```
aws dms describe-metadata-model \
--migration-project-identifier "{{my-migration-project}}" \
--origin {{SOURCE}} \
--selection-rules '{{selection-rules-for-target-object}}'
```
Die Antwort umfasst den Namen, den Typ und die SQL-Definition des Metadatenmodells:
```
{
"MetadataModelName": "employees",
"MetadataModelType": "table",
"Definition": "CREATE TABLE hr.employees(\n id integer NOT NULL,\n name varchar(100),\n department_id integer\n);"
}
```
**Anmerkung**
Das `Definition` Feld ist für einige Metadatenmodelle, wie Schemas und Kategorien, möglicherweise nicht gefüllt.
Nachdem Sie Metadaten-Quellmodelle konvertiert haben, sind die konvertierten Definitionen in der Zielstruktur verfügbar. Es gibt drei Möglichkeiten, sie abzurufen.
**Verwenden von Regeln zur Zielauswahl aus der Quellantwort**
Wenn Sie ein Quellmetadatenmodell nach der Konvertierung beschreiben, enthält die Antwort ein `TargetMetadataModels` Feld mit den Regeln für die Zielauswahl:
```
{
"MetadataModelName": "employees",
"MetadataModelType": "table",
"TargetMetadataModels": [
{
"MetadataModelName": "employees",
"SelectionRules": "{\"rules\":[{\"rule-type\":\"selection\",\"rule-id\":\"1\",\"rule-name\":\"1\",\"object-locator\":{\"server-name\":\"tgt-database-server\",\"schema-name\":\"hr\",\"table-name\":\"employees\",\"table-type\":\"table\"},\"rule-action\":\"explicit\"}]}"
}
],
"Definition": "CREATE TABLE hr.employees(\n id integer NOT NULL,\n name varchar(100),\n department_id integer\n);"
}
```
Übergeben Sie die Auswahlregeln von `TargetMetadataModels` an `describe-metadata-model` mit`--origin TARGET`:
```
aws dms describe-metadata-model \
--migration-project-identifier "{{my-migration-project}}" \
--origin TARGET \
--selection-rules '{{selection-rules-from-TargetMetadataModels}}'
```
Die Antwort enthält die konvertierte SQL-Definition in der Syntax der Ziel-Engine:
```
{
"MetadataModelName": "employees",
"MetadataModelType": "table",
"Definition": "CREATE TABLE hr.employees (\nid INT NOT NULL,\nname VARCHAR(100) DEFAULT NULL,\ndepartment_id INT DEFAULT NULL,\nPRIMARY KEY (id)\n);"
}
```
**Verwenden von Get-Target-Selection-Regeln**
Sie können [get-target-selection-rules verwenden, um Quellauswahlregeln direkt](https://docs.aws.amazon.com/cli/latest/reference/dms/get-target-selection-rules.html) in ihre Ziel-Gegenstücke zu konvertieren, ohne zuerst die Quelle aufrufen zu müssen: `describe-metadata-model`
```
aws dms get-target-selection-rules \
--migration-project-identifier "{{my-migration-project}}" \
--selection-rules '{{source-selection-rules}}'
```
**Direktes Navigieren im Zielbaum**
Sie können den Zielbaum auch auf die gleiche Weise wie den Quellbaum durchsuchen, indem Sie`--origin TARGET`. Dies ist nützlich, wenn Sie alle konvertierten Objekte untersuchen möchten, ohne von der Quelle aus zu beginnen.
------
## Erstellen Sie Modelle für Metadaten zu Aussagen
**Anmerkung**
Die Anweisungserstellung unterstützt derzeit nur die folgenden Richtungen: von SQL Server zu Aurora PostgreSQL oder von SQL Server zu Amazon RDS for PostgreSQL.
Mithilfe von SQL-Definitionen können Sie Metadatenmodelle für Anweisungen erstellen. [StartMetadataModelCreation](https://docs.aws.amazon.com/dms/latest/APIReference/API_StartMetadataModelCreation.html) Dies ist nützlich, wenn Sie SQL-Anweisungen konvertieren möchten, die nicht als Objekte in Ihrer Quelldatenbank existieren, z. B. Anwendungsabfragen oder Ad-hoc-SQL-Code.
------
#### [ AWS Management Console ]
Das Erstellen von Modellen für Anweisungsmetadaten ist in der AWS Management Console nicht verfügbar. Verwenden Sie stattdessen das AWS CLI oder ein AWS SDK.
------
#### [ AWS CLI ]
Verwenden Sie [start-metadata-model-creation](https://docs.aws.amazon.com/cli/latest/reference/dms/start-metadata-model-creation.html), um ein Anweisungs-Metadatenmodell zu erstellen. Die Auswahlregeln müssen ein Schema angeben, das in Ihrer Quelldatenbank vorhanden ist. Das erstellte Metadatenmodell wird in diesem Schema unter der `Statements` Kategorie angezeigt.
```
aws dms start-metadata-model-creation \
--migration-project-identifier "{{my-migration-project}}" \
--metadata-model-name "{{GetAllEmployees}}" \
--selection-rules '{"rules":[{"rule-type":"selection","rule-id":"1",
"rule-name":"1","object-locator":{"server-name":"{{my-server}}",
"database-name":"{{my_database}}","schema-name":"{{dbo}}"},
"rule-action":"explicit"}]}' \
--properties '{"StatementProperties":{"Definition":"SELECT * FROM dbo.Employees;"}}'
```
Nach der Erstellung finden Sie das Metadatenmodell in der Baumstruktur unter der `Statements` Kategorie und können es beschreiben:
```
{
"MetadataModelName": "GetAllEmployees",
"MetadataModelType": "statement",
"Definition": "SELECT * FROM dbo.Employees;"
}
```
Nach der Erstellung können Sie jeden unterstützten Vorgang für das Anweisungsmetadatenmodell ausführen, z. B. Bewertung, Konvertierung oder Export.
------