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.
# Verwenden der Tabellenzuweisung zum Angeben von Aufgabeneinstellungen
Die Zuweisung von Tabellen verwendet mehrere Arten von Regeln für die Angabe der Datenquelle, des Quellschemas, der Daten und aller Transformationen, die während der Aufgabe auftreten sollten. Sie können mithilfe von Tabellenzuweisung einzelne zu migrierende Tabellen in einer Datenbank und das für die Migration zu verwendende Schema bestimmen.
Wenn Sie mit der Tabellenzuweisung arbeiten, können Sie mithilfe von Filtern Daten angeben, die aus Tabellenspalten repliziert werden sollen. Außerdem können Sie Transformationen verwenden, um ausgewählte Schemata, Tabellen oder Ansichten zu ändern, bevor sie in die Zieldatenbank geschrieben werden.
**Topics**
+ [Festlegen der Tabellenauswahl und der Transformationsregeln über die Konsole](CHAP_Tasks.CustomizingTasks.TableMapping.Console.md)
+ [Festlegen der Tabellenauswahl- und Transformationsregeln mit JSON](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.md)
+ [Auswahlregeln und Aktionen](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Selections.md)
+ [Platzhalter bei der Tabellenzuordnung](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Wildcards.md)
+ [Transformationsregeln und Aktionen](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Transformations.md)
+ [Verwenden von Transformationsregelausdrücken zum Definieren von Spalteninhalten](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions.md)
+ [Regeln und Operationen für Tabellen- und Sammlungseinstellungen](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.md)
+ [Verwendung von Datenmaskierung zum Verbergen vertraulicher Informationen](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Masking.md)
**Anmerkung**
Wenn Sie mit der Tabellenzuweisung für einen MongoDB-Quellendpunkt arbeiten, können Sie Filter verwenden, um Daten anzugeben, die repliziert werden sollen, und einen Datenbanknamen anstelle von `schema_name` angeben. Sie können den Standard-`"%"` verwenden.
# Festlegen der Tabellenauswahl und der Transformationsregeln über die Konsole
Sie können den verwenden AWS-Managementkonsole , um Tabellenzuordnungen durchzuführen, einschließlich der Angabe von Tabellenauswahl und Transformationen. In der Konsole können Sie im Bereich **Where (Wo)** Schema, Tabelle und Aktion (Einschließen oder Ausschließen) angeben. Im Bereich **Filter** können Sie den Spaltennamen in einer Tabelle sowie die Bedingungen angeben, die für eine Replikationsaufgabe gelten sollen. Zusammen erstellen diese beiden Aktionen eine Auswahlregel.
Sie können Transformationen in einer Tabellenzuweisung einschließen, nachdem Sie mindestens eine Auswahlregel angegeben haben. Sie können Transformationen dazu verwenden, ein Schema oder eine Tabelle umzubenennen, einem Schema oder einer Tabelle ein Präfix oder Suffix anzufügen oder eine Tabellenspalte zu entfernen.
**Anmerkung**
AWS DMS unterstützt nicht mehr als eine Transformationsregel pro Schema-, Tabellen- oder Spaltenebene.
Das folgende Verfahren zeigt, wie Auswahlregeln basierend auf einer Tabelle namens **Customers** in einem Schema mit der Bezeichnung **EntertainmentAgencySample** eingerichtet werden.
**So geben Sie eine Tabellenauswahl, Filterkriterien und Transformationen mithilfe der Konsole an**
1. Melden Sie sich bei [https://console.aws.amazon.com/dms/v2/](https://console.aws.amazon.com/dms/v2/) an AWS-Managementkonsole und öffnen Sie die AWS DMS Konsole.
Wenn Sie als IAM-Benutzer angemeldet sind, müssen Sie über die entsprechenden Zugriffsberechtigungen für AWS DMS verfügen. Weitere Informationen zu den erforderlichen Berechtigungen finden Sie unter [Für die Verwendung sind IAM-Berechtigungen erforderlich AWS DMS](security-iam.md#CHAP_Security.IAMPermissions).
1. Wählen Sie auf der Seite **Dashboard** **Datenbankmigrationsaufgaben** aus.
1. Wählen Sie **Aufgabe erstellen** aus.
1. Geben Sie im Abschnitt **Aufgabenkonfiguration** die Aufgabeninformationen ein, einschließlich **Aufgaben-ID**, **Replikations-Instance**, **Quelldatenbank-Endpunkt**, **Zieldatenbank-Endpunkt** und **Migrationstyp**.
![\[Schema- und Tabellenauswahl\]](http://docs.aws.amazon.com/de_de/dms/latest/userguide/images/datarep-create-task-20.png)
1. Wählen Sie im Abschnitt **Tabellenzuordnung** den Schemanamen und den Tabellennamen aus. Sie können bei der Angabe des Schema- oder Tabellennamens „%“ als Platzhalterzeichen verwenden. Informationen zu anderen Platzhaltern, die Sie verwenden können, finden Sie unter [Platzhalter bei der Tabellenzuordnung](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Wildcards.md). Geben Sie die auszuführende Aktion an, um vom Filter definierte Daten ein- oder auszuschließen.
![\[Schema- und Tabellenauswahl\]](http://docs.aws.amazon.com/de_de/dms/latest/userguide/images/datarep-Tasks-selecttransfrm.png)
1. Geben Sie Filterinformationen mithilfe der Links **Add column filter (Spaltenfilter hinzufügen)** und **Add condition (Bedingung hinzufügen) **an.
1. Wählen Sie **Add column filter (Spaltenfilter hinzufügen)** aus, um eine Spalte und Bedingungen anzugeben.
1. Wählen Sie **Add condition (Bedingung hinzufügen)** aus, um zusätzliche Bedingungen hinzuzufügen.
Das folgende Beispiel zeigt einen Filter für die Tabelle **Customers**, die **AgencyIDs** zwischen **01** und **85** enthält.
![\[Schema- und Tabellenauswahl\]](http://docs.aws.amazon.com/de_de/dms/latest/userguide/images/datarep-Tasks-filter.png)
1. Wenn Sie die gewünschte Auswahl getroffen haben, wählen Sie **Auswahlregel hinzufügen** aus.
1. Nachdem Sie mindestens eine Auswahlregel erstellt haben, können Sie eine Transformation zu der Aufgabe hinzufügen. Wählen Sie **Add transformation rule (Transformationsregel hinzufügen)** aus.
![\[Transformationsregel\]](http://docs.aws.amazon.com/de_de/dms/latest/userguide/images/datarep-Tasks-transform1.png)
1. Wählen Sie das Ziel aus, das Sie transformieren möchten, und geben Sie die angefragten zusätzlichen Informationen ein. Das folgende Beispiel zeigt eine Transformation, bei der die Spalte **AgencyStatus** aus der Tabelle **Customer** gelöscht wird.
![\[Transformationsregel\]](http://docs.aws.amazon.com/de_de/dms/latest/userguide/images/datarep-Tasks-transform2.png)
1. Wählen Sie **Add transformation rule (Transformationsregel hinzufügen)** aus.
1. Wählen Sie **Create task** aus.
**Anmerkung**
AWS DMS unterstützt nicht mehr als eine Transformationsregel pro Schema-, Tabellen- oder Spaltenebene.
# Festlegen der Tabellenauswahl- und Transformationsregeln mit JSON
Zum Festlegen der Tabellenzuweisungen, die Sie während der Migration anwenden möchten, können Sie eine JSON-Datei erstellen. Wenn Sie eine Migrationsaufgabe mithilfe der Konsole erstellen, können Sie nach dieser JSON-Datei suchen oder das JSON direkt in das Tabellenzuweisungsfeld eingeben. Wenn Sie die CLI oder API verwenden, um Migrationen durchzuführen, können Sie diese Datei mit dem Parameter `TableMappings` der API-Operation `CreateReplicationTask` oder `ModifyReplicationTask` angeben.
AWS DMS kann nur JSON-Dateien mit Tabellenzuordnungen mit einer Größe von bis zu 2 MB verarbeiten. Wir empfehlen, dass Sie bei der Arbeit mit DMS-Aufgaben die Größe der JSON-Datei für die Zuordnungsregel unter dem Grenzwert von 2 MB halten. Dadurch werden unerwartete Fehler bei der Erstellung oder Änderung von Aufgaben vermieden. Wenn eine Zuordnungsregeldatei den Grenzwert von 2 MB überschreitet, empfehlen wir, die Tabellen auf mehrere Aufgaben aufzuteilen, um die Größe der Zuordnungsregeldatei so zu reduzieren, dass sie unter diesem Limit bleibt.
Sie können angeben, mit welchen Tabellen, Ansichten und Schemata Sie arbeiten möchten. Sie können auch Tabellen-, Ansichts- und Schematransformationen durchführen und Einstellungen dazu festlegen, wie AWS DMS einzelne Tabellen und Ansichten lädt. Sie erstellen mit den folgenden Regeltypen Tabellenzuweisungsregeln für diese Optionen:
+ `selection`-Regeln – Identifizieren die Typen und Namen der Quelltabellen, Ansichten und Schemata, die geladen werden sollen. Weitere Informationen finden Sie unter [Auswahlregeln und Aktionen](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Selections.md).
+ `transformation`-Regeln – Geben bestimmte Änderungen oder Ergänzungen an bestimmten Quelltabellen und Schemata in der Quelle an, bevor sie auf dem Ziel geladen werden. Weitere Informationen finden Sie unter [Transformationsregeln und Aktionen](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Transformations.md).
Um den Inhalt neuer und vorhandener Spalten zu definieren, können Sie auch einen Ausdruck innerhalb einer Transformationsregel verwenden. Weitere Informationen finden Sie unter [Verwenden von Transformationsregelausdrücken zum Definieren von Spalteninhalten](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions.md).
+ `table-settings`-Regeln – Legen fest, wie DMS-Aufgaben die Daten für einzelne Tabellen laden. Weitere Informationen finden Sie unter [Regeln und Operationen für Tabellen- und Sammlungseinstellungen](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.md).
**Anmerkung**
Für Amazon-S3-Ziele können Sie auch S3-Objekte markieren, die mithilfe des `post-processing`-Regeltyps und der `add-tag`-Regelaktion ausgewählten Tabellen und Schemata zugeordnet sind. Weitere Informationen finden Sie unter [Markieren von Amazon-S3-Objekten](CHAP_Target.S3.md#CHAP_Target.S3.Tagging).
Für die folgenden Ziele können Sie mithilfe des `object-mapping`-Regeltyps angeben, wie und wo ausgewählte Schemata und Tabellen auf das Ziel migriert werden:
Amazon DynamoDB – Weitere Informationen finden Sie unter [Verwenden der Objektzuordnung zum Migrieren von Daten zu DynamoDB](CHAP_Target.DynamoDB.md#CHAP_Target.DynamoDB.ObjectMapping).
Amazon Kinesis – Weitere Informationen finden Sie unter [Verwenden der Objektzuweisung zum Migrieren von Daten zu einem Kinesis-Datenstrom](CHAP_Target.Kinesis.md#CHAP_Target.Kinesis.ObjectMapping).
Apache Kafka – Weitere Informationen finden Sie unter [Verwenden der Objektzuweisung zum Migrieren von Daten zu einem Kafka-Thema](CHAP_Target.Kafka.md#CHAP_Target.Kafka.ObjectMapping).
# Auswahlregeln und Aktionen
Mithilfe der Tabellenzuweisung können Sie angeben, mit welchen Tabellen, Ansichten oder Schemata Sie arbeiten möchten, indem Sie Auswahlregeln und Aktionen verwenden. Für Tabellenzuweisungsregeln, die den Regeltyp "Auswahl" verwenden, können Sie die folgenden Werte anwenden.
**Warnung**
Nehmen Sie keine sensiblen Daten in diese Regeln auf.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/dms/latest/userguide/CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Selections.html)
**Example Migrieren aller Tabellen in einem Schema**
Im folgenden Beispiel werden alle Tabellen aus einem Schema mit dem Namen `Test` in Ihrer Quelle zu Ihrem Zielendpunkt migriert.
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "Test",
"table-name": "%"
},
"rule-action": "include"
}
]
}
```
**Example Migrieren einiger Tabellen in einem Schema**
Im folgenden Beispiel werden alle Tabellen außer denjenigen, die mit `DMS` beginnen, aus einem Schema mit dem Namen `Test` in Ihrer Quelle zu Ihrem Zielendpunkt migriert.
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "Test",
"table-name": "%"
},
"rule-action": "include"
},
{
"rule-type": "selection",
"rule-id": "2",
"rule-name": "2",
"object-locator": {
"schema-name": "Test",
"table-name": "DMS%"
},
"rule-action": "exclude"
}
]
}
```
**Example Migrieren einer bestimmten einzelnen Tabelle in einem einzelnen Schema**
Im folgenden Beispiel wird die `Customer`-Tabelle aus dem `NewCust`-Schema in Ihrer Quelle zu Ihrem Zielendpunkt migriert.
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "NewCust",
"table-name": "Customer"
},
"rule-action": "explicit"
}
]
}
```
Sie können explizit auf mehreren Tabellen und Schemata auswählen, indem Sie mehrere Auswahlregeln angeben.
**Example Migrieren von Tabellen in einer festgelegten Reihenfolge**
Tabellen und Ansichten werden entsprechend ihren Werten in der Ladereihenfolge migriert, wobei höheren Werten in der Migrationssequenz Priorität eingeräumt wird. Im folgenden Beispiel werden zwei Tabellen `loadfirst` mit einem Prioritätswert von 2 und einem Prioritätswert von 1 migriert. Die Migrationsaufgabe würde zuerst die Tabelle verarbeiten, bevor `loadsecond` mit der `loadfirst` Tabelle fortgefahren wird. `loadsecond` Dieser Priorisierungsmechanismus stellt sicher, dass Abhängigkeiten zwischen Datenbankobjekten während des Migrationsprozesses berücksichtigt werden.
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "Test",
"table-name": "loadsecond"
},
"rule-action": "include",
"load-order": "1"
},
{
"rule-type": "selection",
"rule-id": "2",
"rule-name": "2",
"object-locator": {
"schema-name": "Test",
"table-name": "loadfirst"
},
"rule-action": "include",
"load-order": "2"
}
]
}
```
**Anmerkung**
`load-order` gilt für die Tabelleninitialisierung. Das Laden einer nachfolgenden Tabelle wartet nicht darauf, dass das Laden einer vorherigen Tabelle abgeschlossen ist, wenn der Wert `MaxFullLoadSubTasks` größer als 1 ist.
**Example Migrieren einiger Ansichten in einem Schema**
Im folgenden Beispiel werden einige Ansichten aus einem Schema mit dem Namen `Test` in Ihrer Quelle in gleichwertige Tabellen in Ihrem Ziel migriert.
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "2",
"rule-name": "2",
"object-locator": {
"schema-name": "Test",
"table-name": "view_DMS%",
"table-type": "view"
},
"rule-action": "include"
}
]
}
```
**Example Migrieren aller Tabellen und Ansichten in einem Schema**
Im folgenden Beispiel werden alle Tabellen und Ansichten aus einem Schema mit dem Namen `report` in Ihrer Quelle in gleichwertige Tabellen in Ihrem Ziel migriert.
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "3",
"rule-name": "3",
"object-locator": {
"schema-name": "report",
"table-name": "%",
"table-type": "all"
},
"rule-action": "include"
}
]
}
```
# Platzhalter bei der Tabellenzuordnung
In diesem Abschnitt werden Platzhalter beschrieben, die Sie verwenden können, wenn Sie die Schema- und Tabellennamen für die Tabellenzuordnung angeben.
| Platzhalter | Entspricht |
| --- |--- |
| % | Null oder mehr Zeichen |
| \$1 | Ein einzelnes Zeichen |
| [\$1] | Ein wörtlicher Unterstrich |
| [ab] | Eine Reihe von Charakteren. Zum Beispiel entspricht [ab] entweder „a“ oder „b“. |
| [a-d] | Eine Reihe von Zeichen. Zum Beispiel entspricht [a-d] entweder 'a', 'b', 'c' oder 'd'. |
Für Oracle-Quell- und Zielendpunkte können Sie das zusätzliche `escapeCharacter`-Verbindungsattribut verwenden, um ein Escape-Zeichen anzugeben. Ein Escape-Zeichen ermöglicht Ihnen, ein bestimmtes Platzhalterzeichen in Ausdrücken so zu verwenden, als ob es kein Platzhalterzeichen wäre. `escapeCharacter=#` Ermöglicht Ihnen beispielsweise, „\$1“ zu verwenden, damit ein Platzhalterzeichen in einem Ausdruck wie in diesem Beispielcode als normales Zeichen fungiert.
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "542485267",
"rule-name": "542485267",
"object-locator": { "schema-name": "ROOT", "table-name": "TEST#_T%" },
"rule-action": "include",
"filters": []
}
]
}
```
Hier sorgt das Escape-Zeichen '\$1' dafür, dass sich das Platzhalterzeichen '\$1' wie ein normales Zeichen verhält. AWS DMS wählt Tabellen im genannten Schema aus`ROOT`, wobei jede Tabelle einen Namen mit `TEST_T` einem Präfix hat.
# Transformationsregeln und Aktionen
Sie verwenden die Transformationsaktionen, um alle Transformationen anzugeben, die Sie auf das ausgewählte Schema, Tabelle oder Ansicht anwenden möchten. Transformationsregeln sind optional.
## Einschränkungen
+ Sie können nicht mehr als eine Transformationsregelaktion auf dasselbe Objekt (Schema, Tabelle, Spalte, Tabellen-Tablespace oder Index-Tablespace) anwenden. Sie können mehrere Transformationsregelaktionen auf jeder Ebene anwenden, solange jede Transformationsaktion auf ein anderes Objekt angewendet wird. Diese Einschränkung gilt jedoch nicht, wenn Sie Transformationsregeln für die Datenmaskierung verwenden, bei denen Sie eine weitere Transformation wie oder für dieselbe Spalte verwenden können. `ADD-COLUMN` `CHANGE-DATA-TYPE`
+ Bei Tabellennamen und Spaltennamen in Transformationsregeln muss die Groß- und Kleinschreibung beachtet werden. Beispielsweise müssen Sie Tabellennamen und Spaltennamen für eine Oracle- oder Db2-Datenbank in Großbuchstaben angeben.
+ Transformationen werden für Spaltennamen mit Right-to-Left Sprachen nicht unterstützt.
+ Transformationen können nicht für Spalten durchgeführt werden, deren Name Sonderzeichen (z. B. \$1, \$1, /, -) enthält.
+ Die einzige unterstützte Transformation für Spalten, die BLOB/CLOB Datentypen zugeordnet sind, besteht darin, die Spalte auf dem Ziel zu löschen.
+ AWS DMS unterstützt nicht die Replikation von zwei Quelltabellen in eine einzelne Zieltabelle. AWS DMS repliziert Datensätze von Tabelle zu Tabelle und von Spalte zu Spalte gemäß den Transformationsregeln der Replikationsaufgabe. Die Objektnamen müssen eindeutig sein, um Überschneidungen zu vermeiden.
Beispielsweise hat eine Quelltabelle eine Spalte mit dem Namen `ID` und die entsprechende Zieltabelle hat eine bereits existierende Spalte mit dem Namen `id`. Wenn eine Regel eine `ADD-COLUMN` Anweisung verwendet, um eine neue Spalte namens hinzuzufügen`id`, und eine SQLite Anweisung, um die Spalte mit benutzerdefinierten Werten zu füllen, erzeugt dies ein doppeltes, mehrdeutiges Objekt mit dem Namen `id` und wird nicht unterstützt.
+ Beim Erstellen einer Transformationsregel empfehlen wir, den `data-type` Parameter nur zu verwenden, wenn die Auswahlregeln mehrere Spalten angeben, z. B. wenn Sie `column-name` auf `%` festlegen. Wir empfehlen nicht, `data-type` für die Auswahl einer einzelnen Spalte zu verwenden.
+ AWS DMS unterstützt keine Transformationsregeln, bei denen sich Quell- und Zielobjekte (Tabellen) in derselben Datenbank/demselben Schema befinden. Die Verwendung derselben Tabelle als Quelle und Ziel in einer Transformationsregel kann zu unerwarteten und potenziell schädlichen Ergebnissen führen, einschließlich, aber nicht beschränkt auf unbeabsichtigte Änderungen an den Tabellendaten, Änderungen von Tabellenstrukturen oder sogar das Löschen von Tabellen.
## Werte
Für Tabellenzuweisungsregeln, die den Regeltyp "Transformation" verwenden, können Sie die folgenden Werte anwenden.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/dms/latest/userguide/CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Transformations.html)
## Beispiele
**Example Umbenennen eines Schemas**
Im folgenden Beispiel wird ein Schema von `Test` in Ihrer Quelle auf `Test1` in Ihrem Ziel umbenannt.
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "Test",
"table-name": "%"
},
"rule-action": "include"
},
{
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-action": "rename",
"rule-target": "schema",
"object-locator": {
"schema-name": "Test"
},
"value": "Test1"
}
]
}
```
**Example Tabellen umbenennen**
Im folgenden Beispiel wird eine Tabelle von `Actor` in Ihrer Quelle auf `Actor1` in Ihrem Ziel umbenannt.
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "Test",
"table-name": "%"
},
"rule-action": "include"
},
{
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-action": "rename",
"rule-target": "table",
"object-locator": {
"schema-name": "Test",
"table-name": "Actor"
},
"value": "Actor1"
}
]
}
```
**Example Umbenennen einer Spalte**
Im folgenden Beispiel wird eine Spalte in Tabelle `Actor` von `first_name` in Ihrer Quelle auf `fname` in Ihrem Zielendpunkt umbenannt.
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "test",
"table-name": "%"
},
"rule-action": "include"
},
{
"rule-type": "transformation",
"rule-id": "4",
"rule-name": "4",
"rule-action": "rename",
"rule-target": "column",
"object-locator": {
"schema-name": "test",
"table-name": "Actor",
"column-name" : "first_name"
},
"value": "fname"
}
]
}
```
**Example Umbenennen eines Oracle-Tabellen-Tabellenraums**
Im folgenden Beispiel wird der Tabellen-Tabellenraum mit dem Namen `SetSpace` für eine Tabelle mit dem Namen `Actor` in Ihrer Oracle-Quelle auf `SceneTblSpace` in Ihrem Oracle-Zielendpunkt umbenannt.
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "Play",
"table-name": "%"
},
"rule-action": "include"
},
{
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-action": "rename",
"rule-target": "table-tablespace",
"object-locator": {
"schema-name": "Play",
"table-name": "Actor",
"table-tablespace-name": "SetSpace"
},
"value": "SceneTblSpace"
}
]
}
```
**Example Umbenennen eines Oracle-Index-Tabellenraums**
Im folgenden Beispiel wird der Index-Tabellenraum mit dem Namen `SetISpace` für eine Tabelle mit dem Namen `Actor` in Ihrer Oracle-Quelle auf `SceneIdxSpace` in Ihrem Oracle-Zielendpunkt umbenannt.
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "Play",
"table-name": "%"
},
"rule-action": "include"
},
{
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-action": "rename",
"rule-target": "table-tablespace",
"object-locator": {
"schema-name": "Play",
"table-name": "Actor",
"table-tablespace-name": "SetISpace"
},
"value": "SceneIdxSpace"
}
]
}
```
**Example Hinzufügen einer Spalte**
Im folgenden Beispiel wird der Tabelle `Actor` im Schema `test` eine `datetime`- Spalte hinzugefügt.
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "test",
"table-name": "%"
},
"rule-action": "include"
},
{
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-action": "add-column",
"rule-target": "column",
"object-locator": {
"schema-name": "test",
"table-name": "actor"
},
"value": "last_updated",
"data-type": {
"type": "datetime",
"precision": 6
}
}
]
}
```
**Example Entfernen einer Spalte**
Im folgenden Beispiel wird die Tabelle mit dem Namen `Actor` in Ihrer Quelle so transformiert, dass alle Spalten, die mit den Zeichen `col` beginnen, in Ihrem Ziel daraus entfernt werden.
```
{
"rules": [{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "test",
"table-name": "%"
},
"rule-action": "include"
}, {
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-action": "remove-column",
"rule-target": "column",
"object-locator": {
"schema-name": "test",
"table-name": "Actor",
"column-name": "col%"
}
}]
}
```
**Example In Kleinbuchstaben konvertieren**
Im folgenden Beispiel wird ein Tabellenname von `ACTOR` in Ihrer Quelle auf `actor` in Ihrem Ziel umgewandelt.
```
{
"rules": [{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "test",
"table-name": "%"
},
"rule-action": "include"
}, {
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-action": "convert-lowercase",
"rule-target": "table",
"object-locator": {
"schema-name": "test",
"table-name": "ACTOR"
}
}]
}
```
**Example Umwandeln in Großschreibung**
Im folgenden Beispiel werden alle Spalten in allen Tabellen und allen Schemata von Kleinschreibung an Ihrer Quelle in Großschreibung an Ihrem Ziel umgewandelt.
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "test",
"table-name": "%"
},
"rule-action": "include"
},
{
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-action": "convert-uppercase",
"rule-target": "column",
"object-locator": {
"schema-name": "%",
"table-name": "%",
"column-name": "%"
}
}
]
}
```
**Example Hinzufügen eines Präfix**
Im folgenden Beispiel werden alle Tabellen in Ihrer Quelle so transformiert, dass ihnen das Präfix `DMS_` in Ihrem Ziel hinzugefügt wird.
```
{
"rules": [{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "test",
"table-name": "%"
},
"rule-action": "include"
}, {
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-action": "add-prefix",
"rule-target": "table",
"object-locator": {
"schema-name": "test",
"table-name": "%"
},
"value": "DMS_"
}]
}
```
**Example Ersetzen eines Präfix**
Im folgenden Beispiel werden alle Spalten, die das Präfix `Pre_` in Ihrer Quelle enthalten, so transformiert, dass das Präfix durch `NewPre_` in Ihrem Ziel ersetzt wird.
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "test",
"table-name": "%"
},
"rule-action": "include"
},
{
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-action": "replace-prefix",
"rule-target": "column",
"object-locator": {
"schema-name": "%",
"table-name": "%",
"column-name": "%"
},
"value": "NewPre_",
"old-value": "Pre_"
}
]
}
```
**Example Entfernen eines Suffix**
Im folgenden Beispiel werden alle Tabellen in Ihrer Quelle so transformiert, dass aus ihnen das Suffix `_DMS` in Ihrem Ziel entfernt wird.
```
{
"rules": [{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "test",
"table-name": "%"
},
"rule-action": "include"
}, {
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-action": "remove-suffix",
"rule-target": "table",
"object-locator": {
"schema-name": "test",
"table-name": "%"
},
"value": "_DMS"
}]
}
```
**Example Definieren eines Primärschlüssels**
Das folgende Beispiel definiert einen Primärschlüssel mit dem Namen `ITEM-primary-key` auf drei Spalten der `ITEM`-Tabelle, die zu Ihrem Zielendpunkt migriert wurde.
```
{
"rules": [{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "inventory",
"table-name": "%"
},
"rule-action": "include"
}, {
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-action": "define-primary-key",
"rule-target": "table",
"object-locator": {
"schema-name": "inventory",
"table-name": "ITEM"
},
"primary-key-def": {
"name": "ITEM-primary-key",
"columns": [
"ITEM-NAME",
"BOM-MODEL-NUM",
"BOM-PART-NUM"
]
}
}]
}
```
**Example Definieren eines eindeutigen Index**
Das folgende Beispiel definiert einen eindeutigen Index mit dem Namen `ITEM-unique-idx` auf drei Spalten der `ITEM`-Tabelle, die zu Ihrem Zielendpunkt migriert wurde.
```
{
"rules": [{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "inventory",
"table-name": "%"
},
"rule-action": "include"
}, {
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-action": "define-primary-key",
"rule-target": "table",
"object-locator": {
"schema-name": "inventory",
"table-name": "ITEM"
},
"primary-key-def": {
"name": "ITEM-unique-idx",
"origin": "unique-index",
"columns": [
"ITEM-NAME",
"BOM-MODEL-NUM",
"BOM-PART-NUM"
]
}
}]
}
```
**Example Ändern des Datentyps der Zielspalte**
Im folgenden Beispiel wird der Datentyp einer Zielspalte namens `SALE_AMOUNT` von einem vorhandenen Datentyp in `int8` geändert.
```
{
"rule-type": "transformation",
"rule-id": "1",
"rule-name": "RuleName 1",
"rule-action": "change-data-type",
"rule-target": "column",
"object-locator": {
"schema-name": "dbo",
"table-name": "dms",
"column-name": "SALE_AMOUNT"
},
"data-type": {
"type": "int8"
}
}
```
**Example Hinzufügen einer Vorher-Abbild-Spalte**
Für eine Quellspalte mit dem Namen `emp_no` fügt die Transformationsregel im folgenden Beispiel eine neue Spalte mit dem Namen `BI_emp_no` auf dem Ziel hinzu.
```
{
"rules": [{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "%",
"table-name": "%"
},
"rule-action": "include"
},
{
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-target": "column",
"object-locator": {
"schema-name": "%",
"table-name": "employees"
},
"rule-action": "add-before-image-columns",
"before-image-def": {
"column-prefix": "BI_",
"column-suffix": "",
"column-filter": "pk-only"
}
}
]
}
```
Hier füllt die folgende Anweisung eine `BI_emp_no`-Spalte in der entsprechenden Zeile mit 1.
```
UPDATE employees SET emp_no = 3 WHERE BI_emp_no = 1;
```
Beim Schreiben von CDC-Aktualisierungen für unterstützte AWS DMS Ziele lässt sich anhand der `BI_emp_no` Spalte erkennen, für welche Zeilen die Werte in der `emp_no` Spalte aktualisiert wurden.
# Verwenden von Transformationsregelausdrücken zum Definieren von Spalteninhalten
Um Inhalte für neue und vorhandene Spalten zu definieren, können Sie einen Ausdruck innerhalb einer Transformationsregel verwenden. Beispielsweise können Sie mithilfe von Ausdrücken eine Spalte hinzufügen oder Quelltabellenüberschriften zu einem Ziel replizieren. Sie können Ausdrücke auch verwenden, um Datensätze in Zieltabellen als eingefügt, aktualisiert oder an der Quelle gelöscht zu kennzeichnen.
**Topics**
+ [Hinzufügen einer Spalte mithilfe eines Ausdrucks](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-adding)
+ [Markieren von Zieldatensätzen mithilfe eines Ausdrucks](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-Flagging)
+ [Replizieren von Quelltabellenheadern mithilfe von Ausdrücken](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-Headers)
+ [Verwenden von SQLite Funktionen zum Erstellen von Ausdrücken](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-SQLite)
+ [Hinzufügen von Metadaten zu einer Zieltabelle mithilfe von Ausdrücken](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-Metadata)
## Hinzufügen einer Spalte mithilfe eines Ausdrucks
Verwenden Sie eine `add-column`-Regelaktion und ein `column`-Regelziel, um Tabellen mithilfe eines Ausdrucks in einer Transformationsregel Spalten hinzuzufügen.
Im folgenden Beispiel wird der `ITEM`-Tabelle eine neue Spalte hinzugefügt. Der Name der neuen Spalte ist `FULL_NAME`, der Datentyp `string`, und die Länge ist 50 Zeichen. Der Ausdruck verkettet die Werte zweier vorhandener Spalten, `FIRST_NAME` und `LAST_NAME`, so dass sie zu `FULL_NAME` ausgewertet werden. `schema-name`, `table-name` und Ausdrucksparameter und beziehen sich auf Objekte in der Quelldatenbanktabelle. `Value`und der `data-type`-Block bezieht sich auf Objekte in der Zieldatenbanktabelle.
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "Test",
"table-name": "%"
},
"rule-action": "include"
},
{
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-action": "add-column",
"rule-target": "column",
"object-locator": {
"schema-name": "Test",
"table-name": "ITEM"
},
"value": "FULL_NAME",
"expression": "$FIRST_NAME||'_'||$LAST_NAME",
"data-type": {
"type": "string",
"length": 50
}
}
]
}
```
## Markieren von Zieldatensätzen mithilfe eines Ausdrucks
Um Datensätze in Zieltabellen als eingefügt, aktualisiert oder gelöscht in der Quelltabelle zu kennzeichnen, verwenden Sie einen Ausdruck in einer Transformationsregel. Der Ausdruck verwendet eine `operation_indicator`-Funktion, um Datensätze zu kennzeichnen. Datensätze, die aus der Quelle gelöscht werden, werden nicht aus dem Ziel gelöscht. Stattdessen wird der Zieldatensatz mit einem vom Benutzer angegebenen Wert markiert, um anzuzeigen, dass er aus der Quelle gelöscht wurde.
**Anmerkung**
Die `operation_indicator`-Funktion funktioniert nur für Tabellen, die einen Primärschlüssel für die Quell- und die Zieldatenbank haben.
Beispielsweise fügt die folgende Transformationsregel einer Zieltabelle zuerst eine neue `Operation`-Spalte hinzu. Anschließend wird die Spalte mit dem Wert `D` aktualisiert, wenn ein Datensatz aus einer Quelltabelle gelöscht wird.
```
{
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-target": "column",
"object-locator": {
"schema-name": "%",
"table-name": "%"
},
"rule-action": "add-column",
"value": "Operation",
"expression": "operation_indicator('D', 'U', 'I')",
"data-type": {
"type": "string",
"length": 50
}
}
```
## Replizieren von Quelltabellenheadern mithilfe von Ausdrücken
Standardmäßig werden Header für Quelltabellen nicht auf das Ziel repliziert. Um anzugeben, welche Header repliziert werden sollen, verwenden Sie eine Transformationsregel mit einem Ausdruck, der den Spaltenheader der Tabelle enthält.
Sie können die folgenden Spaltenkopfzeilen in Ausdrücken verwenden.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/dms/latest/userguide/CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions.html)
Im folgenden Beispiel wird dem Ziel eine neue Spalte hinzugefügt, indem der Wert für die Stream-Position aus der Quelle verwendet wird. Bei SQL Server ist der Wert für die Stream-Position der LSN für den Quellendpunkt. Bei Oracle ist der Wert für die Stream-Position der SCN für den Quellendpunkt.
```
{
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-target": "column",
"object-locator": {
"schema-name": "%",
"table-name": "%"
},
"rule-action": "add-column",
"value": "transact_id",
"expression": "$AR_H_STREAM_POSITION",
"data-type": {
"type": "string",
"length": 50
}
}
```
Das folgende Beispiel fügt dem Ziel eine neue Spalte hinzu, die eine eindeutige inkrementelle Zahl aus der Quelle hat. Dieser Wert steht für eine 35-stellige eindeutige Zahl auf Aufgabenebene. Die ersten 16 Ziffern sind Teil eines Zeitstempels und die letzten 19 Ziffern sind die vom DBMS inkrementierte Record\$1ID-Nummer.
```
{
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-target": "column",
"object-locator": {
"schema-name": "%",
"table-name": "%"
},
"rule-action": "add-column",
"value": "transact_id",
"expression": "$AR_H_CHANGE_SEQ",
"data-type": {
"type": "string",
"length": 50
}
}
```
## Verwenden von SQLite Funktionen zum Erstellen von Ausdrücken
Mit den Tabelleneinstellungen können Sie alle Einstellungen angeben, die Sie auf die ausgewählte Tabelle oder Ansicht für eine bestimmte Operation anwenden möchten. Regeln für Tabelleneinstellungen sind optional.
**Anmerkung**
Anstelle des Konzepts von Tabellen und Ansichten speichern MongoDB- und DocumentDB-Datenbanken Datensätze als Dokumente, die in *Sammlungen* zusammengefasst werden. Wenn Sie also von einer MongoDB- oder DocumentDB-Quelle migrieren, sollten Sie den Bereichssegmentierungstyp der parallelen Ladeeinstellungen für ausgewählte *Sammlungen* und nicht für Tabellen und Ansichten berücksichtigen.
**Topics**
+ [Verwenden eines CASE-Ausdrucks](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-SQLite.CASE)
+ [Beispiele](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-SQLite.Ex)
Im Folgenden finden Sie Zeichenkettenfunktionen, mit denen Sie Ausdrücke für Transformationsregeln erstellen können.
| Zeichenfolgenfunktionen | Description |
| --- | --- |
| `lower(x)` | Die `lower(x)`-Funktion gibt eine Kopie der Zeichenfolge *`x`* zurück, in der alle Zeichen in Kleinbuchstaben umgewandelt wurden. Die integrierte `lower`-Standardfunktion funktioniert nur für ASCII-Zeichen. |
| `upper(x)` | Die `upper(x)`-Funktion gibt eine Kopie der Zeichenfolge *`x`* zurück, in der alle Zeichen in Großbuchstaben umgewandelt wurden. Die integrierte `upper`-Standardfunktion funktioniert nur für ASCII-Zeichen. |
| `ltrim(x,y)` | Die `ltrim(x,y)`-Funktion gibt eine Zeichenfolge zurück, die gebildet wird, indem alle Zeichen, die in y vorkommen, von der linken Seite von x entfernt werden. Wenn es keinen Wert für y gibt, entfernt `ltrim(x)` Leerzeichen auf der linken Seite von x. |
| `replace(x,y,z)` | Die `replace(x,y,z)`-Funktion gibt eine Zeichenfolge zurück, die gebildet wird, indem jedes Vorkommen der Zeichenfolge y in der Zeichenfolge x durch die Zeichenfolge z ersetzt wird. |
| `rtrim(x,y)` | Die `rtrim(x,y)`-Funktion gibt eine Zeichenfolge zurück, die gebildet wird, indem alle Zeichen, die in y vorkommen, von der rechten Seite von x entfernt werden. Wenn es keinen Wert für y gibt, entfernt `rtrim(x)` Leerzeichen auf der rechten Seite von x. |
| `substr(x,y,z)` | Die `substr(x,y,z)`-Funktion gibt eine Teilzeichenfolge der Eingabezeichenfolge `x` zurück, die mit `y`-ten Zeichen beginnt und *`z`* Zeichen lang ist. Wenn *`z`* nicht angegeben ist, gibt `substr(x,y)` alle Zeichen bis zum Ende der Zeichenfolge `x` zurück, die mit dem `y`-ten Zeichen beginnt. Das am weitesten links stehende Zeichen von `x` ist die Zahl 1. Wenn *`y`* negativ ist, wird das erste Zeichen der Teilzeichenfolge ermittelt, indem von rechts statt von links gezählt wird. Wenn *`z`* negativ ist, werden die `abs(z)` Zeichen vor dem `y`-ten Zeichen zurückgegeben. Wenn es sich bei `x` um eine Zeichenfolge handelt, beziehen sich die Indizes der Zeichen auf tatsächliche UTF-8-Zeichen. Wenn es sich bei `x` um ein BLOB handelt, beziehen sich die Indizes auf Bytes. |
| trim(x,y) | Die `trim(x,y)`-Funktion gibt eine Zeichenfolge zurück, die gebildet wird, indem alle Zeichen, die in `y` vorkommen, von beiden Seiten von rechten Seite von `x` entfernt werden. Wenn es keinen Wert für `y` gibt, entfernt `trim(x)` Leerzeichen von beiden Seiten von `x`. |
Im Folgenden finden Sie LOB-Funktionen, mit denen Sie Ausdrücke für Transformationsregeln erstellen können.
| LOB-Funktionen | Description |
| --- | --- |
| `hex(x)` | Die `hex`-Funktion empfängt ein BLOB als Argument und gibt eine hexadezimale Zeichenkettenversion des BLOB-Inhalts in Großbuchstaben zurück. |
| `randomblob (N)` | Die `randomblob(N)`-Funktion gibt ein `N`-Byte-BLOB zurück, das pseudozufällige Bytes enthält. Falls kleiner als 1 *N* ist, wird ein zufälliges 1-Byte-BLOB zurückgegeben. |
| `zeroblob(N)` | Die `zeroblob(N)`-Funktion gibt ein BLOB zurück, das aus `N` Bytes von 0x00 besteht. |
Im Folgenden finden Sie numerische Funktionen, mit denen Sie Ausdrücke für Transformationsregeln erstellen können.
| Numerische Funktionen | Description |
| --- | --- |
| `abs(x)` | Die `abs(x)`-Funktion gibt den absoluten Wert des numerischen Arguments `x` zurück. Die `abs(x)` Funktion gibt NULL zurück, wenn NULL *x* ist. Die `abs(x)` Funktion gibt 0,0 zurück, wenn **x** es sich um eine Zeichenfolge oder ein BLOB handelt, das nicht in einen numerischen Wert konvertiert werden kann. |
| `random()` | Die `random`-Funktion gibt eine pseudozufällige Ganzzahl zwischen -9 223 372 036 854 775 808 und \$19 223 372 036 854 775 807 zurück. |
| `round (x,y)` | Die `round (x,y)` Funktion gibt einen Gleitkommawert zurück, der auf *y* Ziffern rechts vom Dezimaltrennzeichen *x* gerundet ist. Wenn es keinen Wert für gibt, wird davon ausgegangen*y*, dass er 0 ist. |
| `max (x,y...)` | Die `max`-Funktion mit mehreren Argumenten gibt das Argument mit dem Maximalwert zurück oder NULL, wenn ein Argument NULL ist. Die `max`-Funktion durchsucht ihre Argumente von links nach rechts nach einem Argument, das eine Sortierfunktion definiert. Wenn eine gefunden wird, verwendet sie diese Sortierfunktion für alle Zeichenkettenvergleiche. Wenn keines der Argumente zur `max`-Definition einer Sortierfunktion vorhanden ist, wird die `BINARY`-Sortierfunktion verwendet. Die `max`-Funktion ist eine einfache Funktion, wenn sie zwei oder mehr Argumente hat, aber sie funktioniert als Aggregatfunktion, wenn sie ein einziges Argument hat. |
| `min (x,y...)` | Die `min`-Funktion mit mehreren Argumenten gibt das Argument mit dem Mindestwert zurück. Die `min`-Funktion durchsucht ihre Argumente von links nach rechts nach einem Argument, das eine Sortierfunktion definiert. Wenn eine gefunden wird, verwendet sie diese Sortierfunktion für alle Zeichenkettenvergleiche. Wenn keines der Argumente zur `min`-Definition einer Sortierfunktion vorhanden ist, wird die `BINARY`-Sortierfunktion verwendet. Die `min`-Funktion ist eine einfache Funktion, wenn sie zwei oder mehr Argumente hat, aber sie funktioniert als Aggregatfunktion, wenn sie ein einziges Argument hat. |
Im Folgenden finden Sie NULL-Prüffunktionen, mit denen Sie Ausdrücke für Transformationsregeln erstellen können.
| Funktionen zur NULL-Prüfung | Description |
| --- | --- |
| `coalesce (x,y...)` | Die `coalesce`-Funktion gibt eine Kopie ihres ersten Arguments zurück, das nicht NULL ist, aber sie gibt NULL zurück, wenn alle Argumente NULL sind. Die Koaleszenzfunktion hat mindestens zwei Argumente. |
| `ifnull(x,y)` | Die `ifnull`-Funktion gibt eine Kopie ihres ersten Arguments zurück, das nicht NULL ist, aber sie gibt NULL zurück, wenn beide Argumente NULL sind. Die `ifnull`-Funktion hat genau zwei Argumente. Die `ifnull`-Funktion ist dieselbe wie `coalesce` mit zwei Argumenten. |
| `nullif(x,y)` | Die `nullif(x,y)`-Funktion gibt eine Kopie ihres ersten Arguments zurück, wenn die Argumente unterschiedlich sind, aber sie gibt NULL zurück, wenn die Argumente identisch sind. Die `nullif(x,y)`-Funktion durchsucht ihre Argumente von links nach rechts nach einem Argument, das eine Sortierfunktion definiert. Wenn eine gefunden wird, verwendet sie diese Sortierfunktion für alle Zeichenkettenvergleiche. Wenn keines der Argumente zur Definition einer Sortierfunktion vorhanden ist, wird die `BINARY`-Sortierfunktion verwendet. |
Im Folgenden finden Sie Datums- und Zeitfunktionen, mit denen Sie Ausdrücke für Transformationsregeln erstellen können.
| Datums- und Zeitfunktionen | Description |
| --- | --- |
| `date(timestring, modifier, modifier...)` | Die `date` Funktion gibt das Datum im Format zurück YYYY-MM-DD. |
| `time(timestring, modifier, modifier...)` | Die `time`-Funktion gibt die Uhrzeit im Format HH:MM:SS zurück. |
| `datetime(timestring, modifier, modifier...)` | Die `datetime` Funktion gibt Datum und Uhrzeit im Format YYYY-MM-DD HH:MM:SS zurück. |
| `julianday(timestring, modifier, modifier...)` | Die `julianday`-Funktion gibt die Anzahl der Tage seit dem Mittag in Greenwich am 24. November 4714 v. Chr. zurück. |
| `strftime(format, timestring, modifier, modifier...)` | Die `strftime`-Funktion gibt das Datum gemäß der als erstes Argument angegebenen Formatzeichenfolge zurück, wobei eine der folgenden Variablen verwendet wird: `%d`: Tag des Monats `%H`: Stunde 00-24 `%f`: \$1\$1 Sekundenbruchteile SS.SSS `%j`: Tag des Jahres 001-366 `%J`: \$1\$1 Julianische Tageszahl `%m`: Monat 01–12 `%M`: Minute (00–59) `%s`: Sekunden seit dem 01.01.1970 `%S`: Sekunden (00–59) `%w`: Wochentag (0–6; wobei Sonntag =0 ist) `%W`: Woche des Jahres 00–53 `%Y`: Jahr 0000–9999 `%%`: % |
Im Folgenden finden Sie eine Hash-Funktionen, mit der Sie Ausdrücke für Transformationsregeln erstellen können.
| Hash-Funktion | Description |
| --- | --- |
| `hash_sha256(x)` | Die `hash`-Funktion generiert einen Hashwert für eine Eingabespalte (unter Verwendung des SHA-256-Algorithmus) und gibt den Hexadezimalwert des generierten Hashwerts zurück. Um die `hash`-Funktion in einem Ausdruck zu verwenden, fügen Sie dem Ausdruck `hash_sha256(x)` hinzu und ersetzen Sie *`x`* durch den Namen der Quellspalte. |
### Verwenden eines CASE-Ausdrucks
Der SQLite `CASE` Ausdruck wertet eine Liste von Bedingungen aus und gibt einen Ausdruck zurück, der auf dem Ergebnis basiert. Die Syntax wird im Folgenden angezeigt.
```
CASE case_expression
WHEN when_expression_1 THEN result_1
WHEN when_expression_2 THEN result_2
...
[ ELSE result_else ]
END
# Or
CASE
WHEN case_expression THEN result_1
WHEN case_expression THEN result_2
...
[ ELSE result_else ]
END
```
### Beispiele
**Example des Hinzufügens einer neuen Zeichenkettenspalte zur Zieltabelle unter Verwendung einer Case-Bedingung**
Beispielsweise fügt die folgende Transformationsregel einer Zieltabelle, `employee`, zuerst eine neue Zeichenfolgenspalte, `emp_seniority`, hinzu. Es verwendet die SQLite `round` Funktion für die Gehaltsspalte mit einer Fallbedingung, um zu überprüfen, ob das Gehalt 20.000 entspricht oder überschreitet. Ist dies der Fall, erhält die Spalte den Wert `SENIOR` und alles andere hat den Wert `JUNIOR`.
```
{
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-action": "add-column",
"rule-target": "column",
"object-locator": {
"schema-name": "public",
"table-name": "employee"
},
"value": "emp_seniority",
"expression": " CASE WHEN round($emp_salary)>=20000 THEN ‘SENIOR’ ELSE ‘JUNIOR’ END",
"data-type": {
"type": "string",
"length": 50
}
}
```
**Example des Hinzufügens einer neuen Zeichenkettenspalte zur Zieltabelle mithilfe einer SUBSTR-Funktion**
Die folgende Beispieltransformationsregel fügt mithilfe von SQLite Operatoren oder Funktionen eine neue Zeichenfolgenspalte hinzu, um die Daten in einer Spalte zu definieren. Bei diesem Ansatz werden SQLite Funktionen verwendet, um die aus Oracle geladenen GUID-Daten in das UUID-Format umzuwandeln, bevor sie in die PostgreSQL-Zieltabelle eingefügt werden.
Die folgende Regel verwendet die Funktionen SQLite Teilzeichenfolge (SUBSTR), Hexadezimalfunktion (HEX) und Kleinschreibung (LOWER), um die GUID-Daten in mehrere durch Bindestriche getrennte Gruppen aufzuteilen, insbesondere eine Gruppe von 8 Ziffern, gefolgt von drei Gruppen von 4 Ziffern, gefolgt von einer Gruppe von 12 Ziffern, also insgesamt 32 Ziffern, die die 128 Bit repräsentieren.
Im Folgenden finden Sie die Beispielquelldaten und die Ausgabe für die Zielnachverarbeitung mithilfe der Transformationsregel:
**Quelltabelle (Oracle GUID-Format)**
T\$1 COL2
```
06F6949D234911EE80670242AC120002
1A2B3C4D5E6F11EE80670242AC120003
F5E4D3C2B1A011EE80670242AC120004
```
**Zieltabelle (PostgreSQL UUID-Format)**
COL2T\$1\$1TMP
```
06f6949d-2349-11ee-8067-0242ac120002
1a2b3c4d-5e6f-11ee-8067-0242ac120003
f5e4d3c2-b1a0-11ee-8067-0242ac120004
```
```
{
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-action": "add-column",
"rule-target": "column",
"object-locator": {
"schema-name": "SPORTS",
"table-name": "TEST_TBL_2"
},
"value": "t_col2_tmp",
"expression": "CASE LOWER(SUBSTR(HEX($T_COL2), 1, 8) || '-' || SUBSTR(HEX($T_COL2), 9, 4) || '-' || SUBSTR(HEX($T_COL2), 13, 4) || '-' || SUBSTR(HEX($T_COL2), 17, 4) || '-' || SUBSTR(HEX($T_COL2), 21, 12)) WHEN '----' THEN NULL ELSE LOWER(SUBSTR(HEX($T_COL2), 1, 8) || '-' || SUBSTR(HEX($T_COL2), 9, 4) || '-' || SUBSTR(HEX($T_COL2), 13, 4) || '-' || SUBSTR(HEX($T_COL2), 17, 4) || '-' || SUBSTR(HEX($T_COL2), 21, 12)) END",
"data-type": {
"type": "string",
"length": 60
}
}
```
**Example des Hinzufügens einer neuen Datumsspalte zur Zieltabelle**
Im folgenden Beispiel wird der Zieltabelle, `employee`, eine neue Datumsspalte, `createdate`, hinzugefügt. Wenn Sie die SQLite Datumsfunktion verwenden`datetime`, wird das Datum für jede eingefügte Zeile zur neu erstellten Tabelle hinzugefügt.
```
{
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-action": "add-column",
"rule-target": "column",
"object-locator": {
"schema-name": "public",
"table-name": "employee"
},
"value": "createdate",
"expression": "datetime ()",
"data-type": {
"type": "datetime",
"precision": 6
}
}
```
**Example des Hinzufügens einer neuen numerischen Spalte zur Zieltabelle**
Im folgenden Beispiel wird der Zieltabelle, `employee`, eine neue numerische Spalte, `rounded_emp_salary`, hinzugefügt. Sie verwendet die SQLite `round` Funktion, um das gerundete Gehalt hinzuzufügen.
```
{
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-action": "add-column",
"rule-target": "column",
"object-locator": {
"schema-name": "public",
"table-name": "employee"
},
"value": "rounded_emp_salary",
"expression": "round($emp_salary)",
"data-type": {
"type": "int8"
}
}
```
**Example des Hinzufügens einer neuen Zeichenkettenspalte zur Zieltabelle unter Verwendung der Hash–Funktion**
Im folgenden Beispiel wird der Zieltabelle, `employee`, eine neue Zeichenkettenspalte, `hashed_emp_number`, hinzugefügt. Die SQLite `hash_sha256(x)` Funktion erstellt Hashwerte auf dem Ziel für die Quellspalte,`emp_number`.
```
{
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-action": "add-column",
"rule-target": "column",
"object-locator": {
"schema-name": "public",
"table-name": "employee"
},
"value": "hashed_emp_number",
"expression": "hash_sha256($emp_number)",
"data-type": {
"type": "string",
"length": 64
}
}
```
## Hinzufügen von Metadaten zu einer Zieltabelle mithilfe von Ausdrücken
Sie können die Metadateninformationen zur Zieltabelle hinzufügen, indem Sie die folgenden Ausdrücke verwenden:
+ `$AR_M_SOURCE_SCHEMA` – Der Name des Quellschemas.
+ `$AR_M_SOURCE_TABLE_NAME` – Der Name der Quelltabelle.
+ `$AR_M_SOURCE_COLUMN_NAME` – Der Name einer Spalte in der Quelltabelle.
+ `$AR_M_SOURCE_COLUMN_DATATYPE` – Der Datentyp einer Spalte in der Quelltabelle.
**Example des Hinzufügens einer Spalte für einen Schemanamen unter Verwendung des Schemanamens aus der Quelle**
Im folgenden Beispiel wird dem Ziel eine neue Spalte mit dem Namen `schema_name` hinzugefügt, indem der Schemaname aus der Quelle verwendet wird.
```
{
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-action": "add-column",
"rule-target": "column",
"object-locator": {
"schema-name": "%",
"table-name": "%"
},
"rule-action": "add-column",
"value":"schema_name",
"expression": "$AR_M_SOURCE_SCHEMA",
"data-type": {
"type": "string",
"length": 50
}
}
```
# Regeln und Operationen für Tabellen- und Sammlungseinstellungen
Mit den Tabelleneinstellungen können Sie alle Einstellungen angeben, die Sie auf die ausgewählte Tabelle oder Ansicht für eine bestimmte Operation anwenden möchten. Regeln für Tabelleneinstellungen sind optional, je nach Endpunkt- und Migrationsanforderungen.
Anstelle des Konzepts von Tabellen und Ansichten speichern MongoDB- und Amazon-DocumentDB-Datenbanken Datensätze als Dokumente, die in *Sammlungen* zusammengefasst werden. Eine einzelne Datenbank für einen MongoDB- oder Amazon-DocumentDB-Endpunkt ist ein bestimmter Satz von Sammlungen, die durch den Datenbanknamen identifiziert werden.
Bei der Migration von einer MongoDB- oder Amazon-DocumentDB-Quelle arbeiten Sie etwas anders mit den Einstellungen für paralleles Laden. In diesem Fall sollten Sie den Typ „Autosegmentierung“ oder „Bereichssegmentierung“ der Einstellungen für paralleles Laden für ausgewählte Sammlungen und nicht für Tabellen und Ansichten in Betracht ziehen.
**Topics**
+ [Platzhalter in Tabelleneinstellungen sind eingeschränkt](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.Wildcards)
+ [Verwendung des parallelen Ladens für ausgewählte Tabellen und Ansichten](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.ParallelLoad)
+ [Angeben von LOB-Einstellungen für eine ausgewählte Tabelle oder Ansicht](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.LOB)
+ [Beispiele für Tabelleneinstellungen](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.Examples)
Für Termersetzungsregeln, die den Tabelleneinstellungsregeltyp geändert haben, können Sie die folgenden Parameter verwenden.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/dms/latest/userguide/CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.html)
## Platzhalter in Tabelleneinstellungen sind eingeschränkt
Die Verwendung des Prozent-Platzhalters (`"%"`) in-`"table-settings"` Regeln wird für Quelldatenbanken nicht unterstützt, wie im Folgenden dargestellt.
```
{
"rule-type": "table-settings",
"rule-id": "8",
"rule-name": "8",
"object-locator": {
"schema-name": "ipipeline-prod",
"table-name": "%"
},
"parallel-load": {
"type": "partitions-auto",
"number-of-partitions": 16,
"collection-count-from-metadata": "true",
"max-records-skip-per-page": 1000000,
"batch-size": 50000
}
}
```
Wenn Sie die `"table-settings"` Regeln wie abgebildet verwenden`"%"`, wird die folgende Ausnahme AWS DMS zurückgegeben.
```
Error in mapping rules. Rule with ruleId = x failed validation. Exact
schema and table name required when using table settings rule.
```
AWS Empfiehlt außerdem, nicht eine große Anzahl großer Sammlungen mithilfe einer einzigen Aufgabe mit zu laden`parallel-load`. Beachten Sie, dass von AWS DMS der Ressourcenkonflikt sowie die Anzahl der parallel geladenen Segmente um den Wert des Parameters `MaxFullLoadSubTasks` für die Aufgabeneinstellungen begrenzt wird, wobei der Höchstwert 49 beträgt.
Geben Sie stattdessen alle Sammlungen für Ihre Quelldatenbank für die größten Sammlungen an, indem Sie sie `"schema-name"` und `"table-name"` einzeln angeben. Skalieren Sie Ihre Migration außerdem korrekt. Führen Sie beispielsweise mehrere Aufgaben auf einer ausreichenden Anzahl von Replikations-Instances aus, um eine große Anzahl großer Sammlungen in Ihrer Datenbank zu verwalten.
## Verwendung des parallelen Ladens für ausgewählte Tabellen und Ansichten
Um die Migration zu beschleunigen und effizienter zu gestalten, können Sie für ausgewählte Tabellen, Ansichten und Sammlungen die parallele Ladung verwenden. Mit anderen Worten: Sie können eine einzelne segmentierte Tabelle, Ansicht oder Sammlung mit mehreren Threads parallel migrieren. Zu diesem Zweck AWS DMS teilt eine Vollladeaufgabe in Threads auf, wobei jedes Tabellensegment einem eigenen Thread zugewiesen wird.
Mit diesem parallelen Ladevorgang können mehrere Threads mehrere Tabellen, Ansichten und Sammlungen vom Quellendpunkt entladen. Anschließend können Sie mehrere Threads migrieren und die gleichen Tabellen, Ansichten und Sammlungen parallel auf den Zielendpunkt laden. Bei einigen Datenbank-Engines können Sie die Tabellen und Ansichten nach vorhandenen Partitionen oder Unterpartitionen aufteilen. Für andere Datenbank-Engines können Sie Sammlungen AWS DMS automatisch nach bestimmten Parametern segmentieren lassen (Autosegmentierung). Andernfalls können Sie jede Tabelle, Ansicht oder Sammlung nach den von Ihnen angegebenen Spaltenwertbereichen segmentieren.
Paralleles Laden wird für die folgenden Quellendpunkte unterstützt:
+ Oracle
+ Microsoft SQL Server
+ MySQL
+ PostgreSQL
+ IBM Db2 (LUW)
+ SAP Adaptive Server Enterprise (ASE)
+ MongoDB (unterstützt nur die Optionen Autosegmentierung und Bereichssegmentierung einer parallelen Volllast)
+ Amazon DocumentDB (unterstützt nur die Optionen Autosegmentierung und Bereichssegmentierung einer parallel Volllast)
AWS DMS Unterstützt für MongoDB- und Amazon DocumentDB DocumentDB-Endpoints die folgenden Datentypen für Spalten, die Partitionsschlüssel für die Bereichssegmentierungsoption einer parallel Volllast sind.
+ Double
+ Zeichenfolge
+ ObjectId
+ 32-Bit-Ganzzahl
+ 64-Bit-Ganzzahl
Das parallele Laden zur Verwendung mit Tabelleneinstellungsregeln wird für die folgenden Zielendpunkte unterstützt:
+ Oracle
+ Microsoft SQL Server
+ MySQL
+ PostgreSQL
+ Amazon S3
+ SAP Adaptive Server Enterprise (ASE)
+ Amazon Redshift
+ MongoDB (unterstützt nur die Optionen Autosegmentierung und Bereichssegmentierung einer parallelen Volllast)
+ Amazon DocumentDB (unterstützt nur die Optionen Autosegmentierung und Bereichssegmentierung einer parallel Volllast)
+ Db2 LUW
Verwenden Sie die `MaxFullLoadSubTasks`-Aufgabeneinstellung, um die maximale Anzahl an Tabellen und Ansichten anzugeben, die parallel geladen werden.
Um die maximale Anzahl von Threads pro Tabelle oder Ansicht für die unterstützten Ziele einer Aufgabe zum parallelen Laden anzugeben, definieren Sie mehr Segmente mithilfe von Spaltenwertgrenzen.
**Wichtig**
`MaxFullLoadSubTasks` steuert die Anzahl der Tabellen oder Tabellensegmente, die parallel geladen werden sollen. `ParallelLoadThreads` steuert die Anzahl der Threads, die von einer Migrationsaufgabe verwendet werden, um die Lasten parallel auszuführen. *Diese Einstellungen sind multiplikativ*. Daher ist die Gesamtzahl der Threads, die während einer Vollast-Aufgabe verwendet werden, ungefähr das Ergebnis des Werts `ParallelLoadThreads ` multipliziert mit dem Wert von `MaxFullLoadSubTasks` (`ParallelLoadThreads` **\$1** `MaxFullLoadSubtasks)`.
Wenn Sie Aufgaben mit einer hohen Anzahl von Volllast-Unteraufgaben und einer hohen Anzahl von parallelen Lade-Threads erstellen, kann Ihre Aufgabe zu viel Speicher verbrauchen und fehlschlagen.
Um die maximale Anzahl von Threads pro Tabelle für Amazon DynamoDB-, Amazon-Kinesis-Data-Streams-, Apache-Kafka- oder Amazon-Elasticsearch-Ziele anzugeben, verwenden Sie die Zielmetadaten-Aufgabeneinstellung `ParallelLoadThreads`.
Sie geben die Puffergröße für eine Aufgabe zum parallelen Laden bei Verwendung von `ParallelLoadThreads` mithilfe der Zielmetadaten-Aufgabeneinstellung `ParallelLoadBufferSize` an.
Die Verfügbarkeit von `ParallelLoadThreads` und `ParallelLoadBufferSize` sowie deren Einstellungen hängen vom Ziel-Endpunkt ab.
Weitere Informationen zu den Einstellungen `ParallelLoadThreads` und `ParallelLoadBufferSize` finden Sie unter [Ziel-Metadaten-Aufgabeneinstellungen](CHAP_Tasks.CustomizingTasks.TaskSettings.TargetMetadata.md). Weitere Informationen zur `MaxFullLoadSubTasks`-Einstellung finden Sie unter [Aufgabeneinstellungen für vollständiges Laden](CHAP_Tasks.CustomizingTasks.TaskSettings.FullLoad.md). Weitere Informationen zu den Zielendpunkten finden Sie unter den entsprechenden Themen.
Wenn Sie paralleles Laden verwenden möchten, können Sie mit der `parallel-load`-Option eine Tabellenzuweisungsregel des Typs `table-settings` angeben. In der `table-settings`-Regel können Sie die Segmentierungskriterien für eine einzelne Tabelle, Ansicht oder Sammlung, die parallel geladen werden soll, angeben. Um dies zu tun, setzen Sie den `type`-Parameter der `parallel-load`-Option auf eine der verschiedenen Optionen.
Wie Sie dies tun, hängt davon ab, wie Sie die Tabelle, Ansicht oder Sammlung für das parallele Laden segmentieren möchten.
+ Nach Partitionen (oder Segmenten) – Alle vorhandenen Tabellen- oder Ansichtspartitionen (oder Segmente) werden mithilfe des `partitions-auto`-Typs geladen. Oder Laden nur ausgewählter Partitionen mithilfe des `partitions-list`-Typs mit einem angegebenen Partitionen-Array.
Nur für MongoDB- und Amazon DocumentDB DocumentDB-Endpoints laden Sie alle oder bestimmte Sammlungen nach Segmenten, die AWS DMS automatisch auch unter Verwendung des `partitions-auto` Typs und zusätzlicher optionaler Parameter berechnet werden. `table-settings`
+ (Nur Oracle-Endpunkte) Nach Unterpartitionen – Laden alle vorhandenen Tabellen- oder Ansichtsunterpartitionen mithilfe des `subpartitions-auto`-Typs. Oder Laden nur ausgewählter Unterpartitionen mithilfe des `partitions-list`-Typs mit einem `subpartitions`-Array.
+ Nach Segmenten, die Sie definieren – Laden von Ihnen definierter Tabellen-, Ansichts- oder Sammlungssegmente mithilfe von Spalte-Wert-Grenzen. Um dies zu tun, verwenden Sie den `ranges`-Typ mit angegebenen `columns`- und `boundaries`-Arrays.
**Anmerkung**
PostgreSQL-Endpunkte unterstützen nur diese Art paralleler Ladevorgänge. MongoDB und Amazon DocumentDB als Quellendpunkte unterstützen sowohl diesen Bereichssegmentierungstyp als auch den Autosegmentierungstyp einer parallelen Volllast (`partitions-auto`).
Um weitere Tabellen, Ansichten oder Sammlungen zum parallelen Laden zu identifizieren, geben Sie zusätzliche `table-settings`-Objekte mit `parallel-load`-Optionen an.
Die folgenden Verfahren beschreiben das Codieren von JSON für jeden parallelen Ladetyp, vom einfachsten zum kompliziertesten.
**So geben Sie alle Tabellen-, Ansichts- oder Sammlungspartitionen oder alle Tabellen- oder Ansichts-Unterpartitionen an**
+ Geben Sie `parallel-load` entweder mit dem `partitions-auto`-Typ oder dem `subpartitions-auto`-Typ an (aber nicht mit beiden).
Jede Tabellen-, Ansichts- oder Sammlungspartition oder -unterpartition wird dann automatisch einem eigenen Thread zugeordnet.
Bei manchen Endpunkten beinhaltet das parallele Laden nur dann Partitionen oder Unterpartitionen nur, wenn sie bereits für die Tabelle oder Ansicht definiert sind. Für MongoDB- und Amazon DocumentDB DocumentDB-Quellendpunkte können Sie die Partitionen (oder Segmente) anhand optionaler zusätzlicher Parameter AWS DMS automatisch berechnen lassen. Dies sind beispielsweise `number-of-partitions`, `collection-count-from-metadata`, `max-records-skip-per-page` und `batch-size`.
**So geben Sie ausgewählte Tabellen- oder Ansichtspartitionen, -unterpartitionen oder beides an:**
1. Geben Sie `parallel-load` mit dem `partitions-list`-Typ an.
1. (Optional) Fügen Sie Partitionen ein, indem Sie ein Array von Partitionsnamen als den Wert für `partitions` angeben.
Jede angegebene Partition wird dann einem eigenen Thread zugeordnet.
**Wichtig**
Stellen Sie bei Oracle-Endpunkten sicher, dass sich Partitionen und Unterpartitionen nicht überlappen, wenn Sie sie für das parallele Laden auswählen. Wenn Sie überlappende Partitionen und Unterpartitionen verwenden, um Daten parallel zu laden, werden Einträge dupliziert oder der Vorgang schlägt aufgrund einer Verletzung der Primärschlüssel-Duplikat-Regel fehl.
1. (Optional, nur für Oracle-Endpunkte) Fügen Sie Unterpartitionen ein, indem Sie ein Array von Unterpartitionsnamen als den Wert für `subpartitions` angeben.
Jede angegebene Unterpartition wird dann einem eigenen Thread zugeordnet.
**Anmerkung**
Paralleles Laden enthält Partitionen oder Unterpartitionen nur, wenn sie bereits für die Tabelle oder Ansicht definiert sind.
Sie können Tabellen- oder Ansichtssegmente als Bereiche von Spaltenwerten angeben. Wenn Sie dies tun, achten Sie auf diese Spalteneigenschaften:
+ Die Angabe indizierter Spalten verbessert die Leistung erheblich.
+ Sie können bis zu 10 Spalten angeben.
+ Sie können keine Spalten verwenden, um Segmentgrenzen mit den folgenden AWS DMS Datentypen zu definieren: DOUBLE, FLOAT, BLOB, CLOB und NCLOB
+ Datensätze mit Nullwerten werden nicht repliziert.
**So geben Sie Tabellen-, Ansichts- oder Sammlungssegmente als Bereiche von Spaltenwerten an**
1. Geben Sie `parallel-load` mit dem `ranges`-Typ an.
1. Definieren Sie eine Begrenzung zwischen Tabellen- oder Ansichtssegmenten, indem Sie ein Array von Tabellenspaltennamen als den Wert für `columns` angeben. Wiederholen Sie diese Schritte für jede Spalte, für die Sie eine Begrenzung zwischen Tabellen- oder Ansichtssegmenten definieren möchten.
Beachten Sie, dass die Reihenfolge der Spalten von Bedeutung ist. Dabei ist die erste Spalte bei der Definition jeder Begrenzung am wichtigsten und die letzte Spalte ist am unwichtigsten. Einzelheiten dazu finden Sie in den folgenden Schritten und Abschnitten.
1. Definieren Sie die Datenbereiche für alle Tabellen- oder Ansichtssegmente durch Angabe eines Begrenzungsarrays als Wert für `boundaries`. Bei einem *Begrenzungsarray* handelt es sich um ein Array mit Spalte-Wert-Arrays. Führen Sie dazu die folgenden Schritte aus:
1. Geben Sie jedes Element eines Spalte-Wert-Arrays als Wert an, der jeder Spalte entspricht. Dabei stellt jedes *Spalte-Wert-Array* die obere Grenze für jedes Tabellen- oder Ansichtssegment dar, das Sie definieren möchten: Geben Sie jede Spalte in der gleichen Reihenfolge an, in der Sie diese Spalte in dem `columns`-Array angegeben haben.
Geben Sie Werte für DATE-Spalten in dem von der Quelle unterstützten Format an.
1. Geben Sie jedes Array mit Spaltenwerten der Reihe nach als obere Grenze für jedes Segment vom unteren zum Segment der Tabelle oder Ansicht an. next-to-top Wenn Zeilen oberhalb der von Ihnen angegebenen oberen Grenze vorhanden sind, stellend diese Zeilen die oberen Segment der Tabelle oder Ansicht dar. Damit ist die Anzahl der bereichsbasierten Segmente potentiell eins höher, als die Anzahl der Segmentgrenzen im Grenz-Array. Jedes dieser bereichsbasierten Segmente wird einem eigenen Thread zugeordnet.
Alle Tabellendaten, die nicht Null sind, werden repliziert. Dies gilt auch, wenn Sie nicht für alle Spalten in der Tabelle oder Ansicht Datenbereiche definieren.
Nehmen wir beispielsweise an, Sie definieren drei Spaltenwert-Arrays für Spalten COL1,, COL2 und wie folgt. COL3
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/dms/latest/userguide/CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.html)
Sie haben drei Segmentgrenzen für einen möglichen Gesamtwert von vier Segmenten definiert.
Um die Bereiche der für jedes Segment zu replizierenden Zeilen zu identifizieren, wendet die Replikations-Instance einen Suchalgorithmus auf diese drei Spalten für jedes der vier Segmente an. Die Suche sieht wie folgt aus:
**Segment 1**
Replizieren Sie alle Zeilen, in denen Folgendes zutrifft: Die ersten Werte mit zwei Spalten sind kleiner oder gleich den entsprechenden Werten für die Obergrenze für **Segment 1**. Außerdem sind die Werte der dritten Spalte kleiner als der Wert der Obergrenze für **Segment 1** .
**Segment 2**
Replizieren Sie alle Zeilen (außer **Segment 1**-Zeilen), wobei Folgendes zutrifft: Die ersten Werte mit zwei Spalten sind kleiner oder gleich den entsprechenden Werten für die Obergrenze für **Segment 2**. Außerdem sind die Werte der dritten Spalte kleiner als der Wert der Obergrenze für **Segment 2** .
**Segment 3**
Replizieren Sie alle Zeilen (außer **Segment 2**-Zeilen), wobei Folgendes zutrifft: Die ersten Werte mit zwei Spalten sind kleiner oder gleich den entsprechenden Werten für die Obergrenze für **Segment 3**. Außerdem sind die Werte der dritten Spalte kleiner als der Wert für den oberen Grenzwert für **Segment 3** .
**Segment 4**
Replizieren Sie alle verbleibenden Zeilen (außer den Zeilen **Segment 1, 2 und 3**).
In diesem Fall erstellt die Replikations-Instance wie folgt eine `WHERE`-Klausel zum Laden jedes Segment:
**Segment 1**
`((COL1 < 10) OR ((COL1 = 10) AND (COL2 < 30)) OR ((COL1 = 10) AND (COL2 = 30) AND (COL3 < 105)))`
**Segment 2**
`NOT ((COL1 < 10) OR ((COL1 = 10) AND (COL2 < 30)) OR ((COL1 = 10) AND (COL2 = 30) AND (COL3 < 105))) AND ((COL1 < 20) OR ((COL1 = 20) AND (COL2 < 20)) OR ((COL1 = 20) AND (COL2 = 20) AND (COL3 < 120)))`
**Segment 3**
`NOT ((COL1 < 20) OR ((COL1 = 20) AND (COL2 < 20)) OR ((COL1 = 20) AND (COL2 = 20) AND (COL3 < 120))) AND ((COL1 < 100) OR ((COL1 = 100) AND (COL2 < 12)) OR ((COL1 = 100) AND (COL2 = 12) AND (COL3 < 99)))`
**Segment 4**
`NOT ((COL1 < 100) OR ((COL1 = 100) AND (COL2 < 12)) OR ((COL1 = 100) AND (COL2 = 12) AND (COL3 < 99)))`
## Angeben von LOB-Einstellungen für eine ausgewählte Tabelle oder Ansicht
Sie können die LOB-Aufgabeneinstellungen für eine oder mehrere Tabellen einrichten, indem Sie eine Tabellenzuordnungsregel des Typs `table-settings` mit der `lob-settings`-Option für ein oder mehrere `table-settings`-Objekte erstellen.
Das Angeben von LOB-Einstellungen für ausgewählte Tabellen oder Ansichten wird für die folgenden Quell-Endpunkte unterstützt:
+ Oracle
+ Microsoft SQL Server
+ MySQL
+ PostgreSQL
+ IBM Db2, abhängig von den `mode`- und `bulk-max-size`-Einstellungen, wie im Folgenden beschrieben
+ SAP Adaptive Server Enterprise (ASE), abhängig von den `mode`-und `bulk-max-size`-Einstellungen, wie im Folgenden beschrieben
Das Angeben von LOB-Einstellungen für ausgewählte Tabellen oder Ansichten wird für die folgenden Zielendpunkte unterstützt:
+ Oracle
+ Microsoft SQL Server
+ MySQL
+ PostgreSQL
+ SAP ASE, je nach den `mode`- und `bulk-max-size`-Einstellungen, wie im Folgenden beschrieben
**Anmerkung**
Sie können LOB-Datentypen nur mit Tabellen und Ansichten verwenden, die einen Primärschlüssel enthalten.
Wenn Sie LOB-Einstellungen für eine ausgewählte Tabelle oder Ansicht verwenden möchten, erstellen Sie eine Tabellenzuweisungsregel des Typs `table-settings` mit der `lob-settings`-Option. Damit wird die LOB-Behandlung für die Tabelle oder Ansicht angegeben, die von der `object-locator`-Option identifiziert wird. In der `table-settings`-Regel können Sie mit den folgenden Parametern ein `lob-settings`-Objekt angeben:
+ `mode` – Gibt den Mechanismus für die Behandlung der LOB-Migration für die ausgewählte Tabelle oder Ansicht wie folgt an:
+ `limited` – Der eingeschränkte LOB-Standardmodus ist der schnellste und effizienteste Modus. Verwenden Sie diesen Modus nur, wenn Sie alle klein LOBs sind (innerhalb von 100 MB) oder wenn der Zielendpunkt keine unbegrenzte LOB-Größe unterstützt. Auch wenn Sie ihn verwenden`limited`, LOBs müssen alle innerhalb der von Ihnen festgelegten Größe liegen. `bulk-max-size`
In diesem Modus migriert die Replikationsinstanz bei einer Aufgabe mit vollständigem Laden alle LOBs Inline-Daten zusammen mit anderen Spaltendatentypen als Teil des Haupttabellen- oder View-Speichers. Die Instance kürzt allerdings jedes LOB, das größer als Ihr `bulk-max-size`-Wert ist, auf die angegebene Größe. Bei einer CDC-Ladeaufgabe (Change Data Capture) migriert die Instanz alle Daten LOBs mithilfe einer Quelltabellensuche, wie im standardmäßigen vollständigen LOB-Modus (siehe unten).
**Anmerkung**
Sie können Ansichten nur für Full-Load-Aufgaben migrieren.
+ `unlimited` – Der Migrationsmechanismus für den vollständigen LOB-Modus hängt von dem Wert ab, den Sie wie folgt für `bulk-max-size` festgelegt haben:
+ **Vollständiger Standard-LOB-Modus** — Wenn Sie den Wert `bulk-max-size` auf Null setzen, migriert die Replikationsinstanz alle LOBs Daten im vollständigen LOB-Standardmodus. Dieser Modus erfordert eine Suche in der Quelltabelle oder -ansicht, um jedes LOB unabhängig von seiner Größe zu migrieren. Dies führt in der Regel zu einer sehr viel langsameren Migration als im eingeschränkten LOB-Modus. Verwenden Sie diesen Modus nur, wenn alle oder die meisten Ihrer Geräte groß LOBs sind (1 GB oder mehr).
+ **Vollständiger LOB-Kombinationsmodus** – Wenn Sie `bulk-max-size` auf einen Wert ungleich Null festlegen, verwendet dieser vollständige LOB-Modus eine Kombination aus eingeschränktem LOB-Modus und vollständigem LOB-Standardmodus. Das heißt, wenn eine LOB-Größe innerhalb Ihres `bulk-max-size`-Werts liegt, migriert die Instance das LOB inline wie im eingeschränkten LOB-Modus. Wenn die LOB-Größe diesen Wert übersteigt, migriert die Instance das LOB mithilfe einer Quelltabellen- oder Quellansichtssuche wie im vollständigen LOB-Standardmodus. Bei einer CDC-Ladeaufgabe (Change Data Capture) migriert die Instance alle Daten LOBs mithilfe einer Quelltabellensuche, wie im standardmäßigen vollständigen LOB-Modus (siehe unten). Dies geschieht unabhängig von der LOB-Größe.
**Anmerkung**
Sie können Ansichten nur für Full-Load-Aufgaben migrieren.
Dieser Modus resultiert in einem Kompromiss bei der Migrationsgeschwindigkeit. Sie liegt zwischen dem schnelleren eingeschränkten LOB-Modus und dem langsameren vollständigen LOB-Standardmodus. Verwenden Sie diesen Modus nur, wenn Sie eine Mischung aus Klein und Groß LOBs haben und die LOBs meisten davon klein sind.
Dieser kombinierte vollständige LOB-Modus ist nur verfügbar für die folgenden Endpunkte:
+ IBM Db2 als Quelle
+ SAP ASE als Quelle oder Ziel
Unabhängig vom Mechanismus, den Sie für den `unlimited` Modus angeben, migriert die Instanz LOBs vollständig, ohne Kürzung.
+ `none`— Die Replikationsinstanz migriert LOBs in der ausgewählten Tabelle oder Ansicht mithilfe Ihrer LOB-Einstellungen für die Aufgabe. Sie können diese Option verwenden, um Migrationsergebnisse mit und ohne LOB-Einstellungen besonders für die ausgewählte Tabelle oder Ansicht zu vergleichen.
Wenn die angegebene Tabelle oder Ansicht in der Replikation LOBs enthalten ist, können Sie die `BatchApplyEnabled` Task-Einstellung auf „`true`Nur bei Verwendung des `limited` LOB-Modus“ festlegen.
In einigen Fällen könnten Sie `BatchApplyEnabled` auf `true` und `BatchApplyPreserveTransaction` auf `false` setzen. In diesen Fällen wird für die Instanz festgelegt, `true` ob `BatchApplyPreserveTransaction` es sich bei der Tabelle oder Ansicht um Oracle handelt LOBs und ob es sich bei den Quell- und Zielendpunkten um Oracle handelt.
+ `bulk-max-size` – Legen Sie diesen Wert in Kilobyte auf Null oder ungleich Null fest. Dies ist, wie bereits für vorherige Elemente beschrieben, vom `mode` abhängig. Im `limited`-Modus müssen Sie für diesen Parameter einen Wert ungleich Null setzen.
Die Instanz wird in das Binärformat LOBs konvertiert. Aus diesem Grund multiplizieren Sie die Größe der größten LOBs, die Sie replizieren müssen, mit drei. Beispiel: Wenn Ihr größtes LOB 2 MB groß ist, legen Sie `bulk-max-size` auf 6.000 (6 MB) fest.
## Beispiele für Tabelleneinstellungen
Im Folgenden finden Sie einige Beispiele, die die Verwendung der Tabelleneinstellungen illustrieren.
**Example Laden einer nach Partitionen segmentierten Tabelle**
Im folgenden Beispiel wird eine `SALES`-Tabelle effizienter in Ihre Quelle geladen, indem basierend auf allen Partitionen sie parallel geladen wird.
```
{
"rules": [{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "%",
"table-name": "%"
},
"rule-action": "include"
},
{
"rule-type": "table-settings",
"rule-id": "2",
"rule-name": "2",
"object-locator": {
"schema-name": "HR",
"table-name": "SALES"
},
"parallel-load": {
"type": "partitions-auto"
}
}
]
}
```
**Example Laden einer nach Unterpartitionen segmentierten Tabelle**
Im folgenden Beispiel wird eine `SALES`-Tabelle effizienter in Ihre Oracle-Quelle geladen, indem sie auf allen Unterpartitionen parallel geladen wird.
```
{
"rules": [{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "%",
"table-name": "%"
},
"rule-action": "include"
},
{
"rule-type": "table-settings",
"rule-id": "2",
"rule-name": "2",
"object-locator": {
"schema-name": "HR",
"table-name": "SALES"
},
"parallel-load": {
"type": "subpartitions-auto"
}
}
]
}
```
**Example Laden einer segmentierten Tabelle entsprechend einer Partitionsliste**
Im folgenden Beispiel wird eine `SALES`-Tabelle in Ihre Quelle geladen, indem sie entsprechend einer bestimmten Partitionsliste parallel geladen wird. Hier werden die angegebenen Partitionen nach Werten benannt, beginnend mit Teilen des englischen Alphabets, z. B. `ABCD`, `EFGH` usw.
```
{
"rules": [{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "%",
"table-name": "%"
},
"rule-action": "include"
},
{
"rule-type": "table-settings",
"rule-id": "2",
"rule-name": "2",
"object-locator": {
"schema-name": "HR",
"table-name": "SALES"
},
"parallel-load": {
"type": "partitions-list",
"partitions": [
"ABCD",
"EFGH",
"IJKL",
"MNOP",
"QRST",
"UVWXYZ"
]
}
}
]
}
```
**Example Laden einer segmentierten Oracle-Tabelle entsprechend einer ausgewählten Liste mit Partitionen und Unterpartitionen**
Im folgenden Beispiel wird eine `SALES`-Tabelle in Ihre Oracle-Quelle geladen, indem sie entsprechend einer ausgewählten Liste mit Partitionen und Unterpartitionen parallel geladen wird. Hier werden die angegebenen Partitionen nach Werten benannt, beginnend mit Teilen des englischen Alphabets, z. B. `ABCD`, `EFGH` usw. Die angegebenen Unterpartitionen sind nach mit Zahlen beginnenden Werten benannt, z. B. `01234` und `56789`.
```
{
"rules": [{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "%",
"table-name": "%"
},
"rule-action": "include"
},
{
"rule-type": "table-settings",
"rule-id": "2",
"rule-name": "2",
"object-locator": {
"schema-name": "HR",
"table-name": "SALES"
},
"parallel-load": {
"type": "partitions-list",
"partitions": [
"ABCD",
"EFGH",
"IJKL",
"MNOP",
"QRST",
"UVWXYZ"
],
"subpartitions": [
"01234",
"56789"
]
}
}
]
}
```
**Example Laden einer durch Spaltenwertbereiche segmentierten Tabelle**
Im folgenden Beispiel wird eine `SALES`-Tabelle in Ihre Quelle geladen, indem sie nach den durch Bereich der `SALES_NO`- und `REGION`-Spaltenwerte angegebenen Segmente parallel geladen wird.
```
{
"rules": [{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "%",
"table-name": "%"
},
"rule-action": "include"
},
{
"rule-type": "table-settings",
"rule-id": "2",
"rule-name": "2",
"object-locator": {
"schema-name": "HR",
"table-name": "SALES"
},
"parallel-load": {
"type": "ranges",
"columns": [
"SALES_NO",
"REGION"
],
"boundaries": [
[
"1000",
"NORTH"
],
[
"3000",
"WEST"
]
]
}
}
]
}
```
Hier werden zwei Spalten für die Segmentbereiche mit den Namen `SALES_NO` und `REGION` angegeben. Es werden zwei Grenzen mit den beiden Spaltenwertsätzen `["1000","NORTH"]` und `["3000","WEST"]` angegeben.
Diese beiden Grenzen identifizieren somit die folgenden drei Tabellensegmente, die parallel geladen werden:
Segment 1
Zeilen mit `SALES_NO` kleiner oder gleich 1.000 und mit `REGION` kleiner als "NORTH" sind. Mit anderen Worten: Verkaufszahlen bis zu 1.000 in der EAST-Region.
Segment 2
Andere Zeilen als **Segment 1** mit `SALES_NO` kleiner oder gleich 3.000 und `REGION` kleiner als "WEST". Mit anderen Worten: Verkaufszahlen zwischen 1.000 und 3.000 in den Regionen „NORTH“ und „SOUTH“.
Segment 3
Alle verbleibenden Zeilen außer **Segment 1** und **Segment 2**. Mit anderen Worten: Verkaufszahlen über 3.000 in der WEST-Region.
**Example Laden von zwei Tabellen: Eine segmentiert nach Bereichen, die andere nach Partitionen**
Das folgende Beispiel lädt eine `SALES`-Tabelle parallel nach Segmentgrenzen, die Sie identifizieren. Es lädt außerdem eine `ORDERS`-Tabelle parallel nach allen ihren Partitionen, wie in früheren Beispielen.
```
{
"rules": [{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "%",
"table-name": "%"
},
"rule-action": "include"
},
{
"rule-type": "table-settings",
"rule-id": "2",
"rule-name": "2",
"object-locator": {
"schema-name": "HR",
"table-name": "SALES"
},
"parallel-load": {
"type": "ranges",
"columns": [
"SALES_NO",
"REGION"
],
"boundaries": [
[
"1000",
"NORTH"
],
[
"3000",
"WEST"
]
]
}
},
{
"rule-type": "table-settings",
"rule-id": "3",
"rule-name": "3",
"object-locator": {
"schema-name": "HR",
"table-name": "ORDERS"
},
"parallel-load": {
"type": "partitions-auto"
}
}
]
}
```
**Example Laden Sie eine Tabelle LOBs mithilfe der LOB-Einstellungen der Aufgabe**
Im folgenden Beispiel wird eine `ITEMS` Tabelle in Ihre Quelle geladen, einschließlich aller LOBs, wobei die LOB-Einstellungen der Aufgabe verwendet werden. Die `bulk-max-size`-Einstellung von 100 MB wird ignoriert und nur für ein schnelles Zurücksetzen auf den `limited`- oder `unlimited`-Modus beibehalten.
```
{
"rules": [{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "%",
"table-name": "%"
},
"rule-action": "include"
},
{
"rule-type": "table-settings",
"rule-id": "2",
"rule-name": "2",
"object-locator": {
"schema-name": "INV",
"table-name": "ITEMS"
},
"lob-settings": {
"mode": "none",
"bulk-max-size": "100000"
}
}
]
}
```
**Example Eine Tabelle im eingeschränkten LOBs LOB-Modus laden**
Im folgenden Beispiel wird eine `ITEMS` Tabelle aus Ihrer Quelle LOBs im eingeschränkten LOB-Modus (Standard) mit einer maximalen Größe von 100 MB ohne Kürzung geladen. Alle Daten LOBs , die diese Größe überschreiten, werden auf 100 MB gekürzt. Alle LOBs werden zusammen mit allen anderen Spaltendatentypen geladen.
```
{
"rules": [{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "%",
"table-name": "%"
},
"rule-action": "include"
},
{
"rule-type": "table-settings",
"rule-id": "2",
"rule-name": "2",
"object-locator": {
"schema-name": "INV",
"table-name": "ITEMS"
},
"lob-settings": {
"bulk-max-size": "100000"
}
}
]
}
```
**Example Laden Sie eine Tabelle im LOBs standardmäßigen vollständigen LOB-Modus**
Im folgenden Beispiel wird eine `ITEMS` Tabelle in Ihre Quelle geladen, einschließlich aller Tabellen LOBs ohne Kürzung. Dabei wird der vollständige LOB-Standardmodus verwendet. Alle Daten LOBs, unabhängig von ihrer Größe, werden getrennt von anderen Datentypen geladen. Dabei wird nach jedem LOB in der Quelltabelle gesucht.
```
{
"rules": [{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "%",
"table-name": "%"
},
"rule-action": "include"
},
{
"rule-type": "table-settings",
"rule-id": "2",
"rule-name": "2",
"object-locator": {
"schema-name": "INV",
"table-name": "ITEMS"
},
"lob-settings": {
"mode": "unlimited",
"bulk-max-size": "0"
}
}
]
}
```
**Example Lädt eine Tabelle LOBs mithilfe der Kombination im vollständigen LOB-Modus**
Im folgenden Beispiel wird eine `ITEMS` Tabelle in Ihre Quelle geladen, einschließlich aller Tabellen LOBs ohne Kürzung. Dabei wird der kombinierte vollständige LOB-Modus verwendet. Alle Daten mit LOBs einer Größe von bis zu 100 MB werden zusammen mit anderen Datentypen inline geladen, wie im eingeschränkten LOB-Modus. Alle Daten mit einer Größe von LOBs mehr als 100 MB werden getrennt von anderen Datentypen geladen. Dieser separate Ladevorgang verwendet eine Suche für jedes dieser LOB in der Quelltabelle, wie im standardmäßigen vollständigen LOB-Modus.
```
{
"rules": [{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "%",
"table-name": "%"
},
"rule-action": "include"
},
{
"rule-type": "table-settings",
"rule-id": "2",
"rule-name": "2",
"object-locator": {
"schema-name": "INV",
"table-name": "ITEMS"
},
"lob-settings": {
"mode": "unlimited",
"bulk-max-size": "100000"
}
}
]
}
```
# Verwendung von Datenmaskierung zum Verbergen vertraulicher Informationen
Um sensible Daten zu verbergen, die in einer oder mehreren Spalten der zu migrierenden Tabellen gespeichert sind, können Sie die Aktionen der Transformationsregeln für die Datenmaskierung nutzen. Ab Version 3.5.4 ist die Verwendung von Transformationsregelaktionen für die Datenmaskierung bei der Tabellenzuordnung möglich, sodass Sie den Inhalt einer oder mehrerer Spalten während des Migrationsprozesses ändern können. AWS DMS AWS DMS lädt die geänderten Daten in die Zieltabellen.
AWS Database Migration Service bietet drei Optionen für Aktionen der Transformationsregel zur Datenmaskierung:
+ Datenmaskierung: Ziffernmaske
+ Datenmaskierung: Ziffern werden nach dem Zufallsprinzip sortiert
+ Datenmaskierung: Hashing-Maske
Diese Aktionen für Transformationsregeln zur Datenmaskierung können in der Tabellenzuordnung Ihrer Replikationsaufgabe konfiguriert werden, ähnlich wie bei anderen Transformationsregeln. Das Regelziel sollte auf Spaltenebene festgelegt werden.
## Maskierung von Zahlen in Spaltendaten mit einem Maskierungszeichen
Mit der Transformationsregelaktion „Datenmaskierung: Ziffernmaske“ können Sie numerische Daten in einer oder mehreren Spalten maskieren, indem Sie Ziffern durch ein einzelnes druckbares ASCII-Zeichen ersetzen, das Sie angeben (ohne Leerzeichen oder Leerzeichen).
Hier ist ein Beispiel, das alle Ziffern in der `cust_passport_no` Spalte der `customer_master` Tabelle mit dem Maskierungszeichen maskiert `'#'` und die maskierten Daten in die Zieltabelle lädt:
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "cust_schema",
"table-name": "%"
},
"rule-action": "include"
},
{
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-target": "column",
"object-locator": {
"schema-name": "cust_schema",
"table-name": "customer_master",
"column-name": "cust_passport_no"
},
"rule-action": "data-masking-digits-mask",
"value": "#"
}
]
}
```
Wenn die Spalte `cust_passport_no` in der Quelltabelle beispielsweise den Datensatz „C6 BGJ566669 K“ enthält, schreibt die AWS DMS Aufgabe diese Daten in die Zieltabelle als. `"C#BGJ######K"`
## Ersetzen von Zahlen in der Spalte durch Zufallszahlen
Mit der Transformationsregel „Datenmaskierung: Randomize Digits“ können Sie jede numerische Ziffer in einer oder mehreren Spalten durch eine Zufallszahl ersetzen. AWS DMS Ersetzt im folgenden Beispiel jede Ziffer in der `cust_passport_no` Spalte der Quelltabelle `customer_master` durch eine Zufallszahl und schreibt die geänderten Daten in die Zieltabelle:
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "cust_schema",
"table-name": "%"
},
"rule-action": "include"
},
{
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-target": "column",
"object-locator": {
"schema-name": "cust_schema",
"table-name": "customer_master",
"column-name": "cust_passport_no"
},
"rule-action": "data-masking-digits-randomize"
}
]
}
```
Die AWS DMS Aufgabe transformiert beispielsweise den Wert `"C6BGJ566669K"` in der `cust_passport_no` Spalte der Quelltabelle in die Zieldatenbank `"C1BGJ842170K"` und schreibt ihn in die Zieldatenbank.
## Ersetzen von Spaltendaten durch einen Hashwert
Die Transformationsregel „Data Masking: Hashing Mask“ ermöglicht es Ihnen, die Spaltendaten durch einen mit dem Algorithmus generierten Hash zu ersetzen. `SHA256` Die Länge des Hashs wird immer 64 Zeichen betragen, daher sollte die Länge der Zieltabellenspalte mindestens 64 Zeichen betragen. Alternativ können Sie der Spalte eine `change-data-type` Transformationsregelaktion hinzufügen, um die Breite der Spalte in der Zieltabelle zu erhöhen.
Das folgende Beispiel generiert einen 64 Zeichen langen Hashwert für die Daten in der `cust_passport_no` Spalte der Quelltabelle `customer_master` und lädt die transformierten Daten in die Zieltabelle, nachdem die Spaltenlänge erhöht wurde:
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "cust_schema",
"table-name": "%"
},
"rule-action": "include"
},
{
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-target": "column",
"object-locator": {
"schema-name": "cust_schema",
"table-name": "customer_master",
"column-name": "cust_passport_no"
},
"rule-action": "change-data-type",
"data-type": {
"type": "string",
"length": "100",
"scale": ""
}
},
{
"rule-type": "transformation",
"rule-id": "3",
"rule-name": "3",
"rule-target": "column",
"object-locator": {
"schema-name": "cust_schema",
"table-name": "customer_master",
"column-name": "cust_passport_no"
},
"rule-action": "data-masking-hash-mask"
}
]
}
```
Wenn die Spalte `cust_passport_no` der Quelltabelle beispielsweise einen Wert enthält`“C6BGJ566669K”`, schreibt AWS DMS Task einen Hash in `“7CB06784764C9030CCC41E25C15339FEB293FFE9B329A72B5FED564E99900C75”` die Zieltabelle.
## Einschränkungen
+ Jede Transformationsregeloption für Datenmaskierung wird nur für bestimmte AWS DMS Datentypen unterstützt:
+ Datenmaskierung: Die Ziffernmaske wird für Spalten der Datentypen unterstützt: `WSTRING` und. `STRING`
+ Datenmaskierung: Die Randomisierung von Ziffern wird für Spalten des Datentyps unterstützt: `WSTRING, STRING; NUMERIC, INT1, INT2, INT4, and INT8 ` mit vorzeichenlosen Gegenstücken.
+ Datenmaskierung: Hashing Mask wird für Spalten der Datentypen unterstützt: und. `WSTRING` `STRING`
Weitere Informationen zur Zuordnung von AWS DMS Datentypen zu den Datentypen Ihrer Quell-Engine finden Sie in der Datentypzuordnung Ihrer Quell-Engine mit AWS DMS Datentypen. Siehe Quelldatentypen für [Quelldatentypen für Oracle](CHAP_Source.Oracle.md#CHAP_Source.Oracle.DataTypes)[Quelldatentypen für SQL Server](CHAP_Source.SQLServer.md#CHAP_Source.SQLServer.DataTypes),[Quelldatentypen für PostgreSQL](CHAP_Source.PostgreSQL.md#CHAP_Source-PostgreSQL-DataTypes), und[Quelldatentypen für MySQL](CHAP_Source.MySQL.md#CHAP_Source.MySQL.DataTypes).
+ Die Verwendung einer Datenmaskierungsregelaktion für eine Spalte mit einem inkompatiblen Datentyp führt zu einem Fehler in der DMS-Aufgabe. Informationen zum Verhalten DataMaskingErrorPolicy bei der Fehlerbehandlung finden Sie in den DMS-Aufgabeneinstellungen. Mehr über `DataMaskingErrorPolicy` erfahren Sie unter [Aufgabeneinstellungen zur Fehlerbehandlung](CHAP_Tasks.CustomizingTasks.TaskSettings.ErrorHandling.md).
+ Sie können eine change-data-type Transformationsregelaktion hinzufügen, um den Datentyp der Spalte in einen kompatiblen Typ zu ändern, falls Ihr Quellspaltentyp für die Maskierungsoption, die Sie verwenden möchten, nicht unterstützt wird. Die Zahl `rule-id` der `change-data-type` Transformation sollte kleiner als die Regel-ID der Maskierungstransformation sein, damit die Änderung des Datentyps vor der Maskierung erfolgt.
+ Verwenden Sie die Aktion Datenmaskierung: Hashing-Maske zum Maskieren von Primärschlüssel/Einzelschlüssel-/Fremdschlüsselspalten, da der generierte Hashwert eindeutig und konsistent sein wird. Die beiden anderen Maskierungsoptionen können die Einzigartigkeit nicht garantieren.
+ Datenmaskierung: Ziffernmaske und Datenmaskierung: Randomisierung von Ziffern wirken sich nur auf die Ziffern in den Spaltendaten aus und wirken sich nicht auf die Länge der Daten aus, während Datenmaskierung: Hashing Mask die gesamte Spalte modifiziert, die Datenlänge ändert sich auf 64 Zeichen. Daher sollte die Zieltabelle, die entsprechend erstellt werden soll, oder eine change-data-type Transformationsregel für die Spalte hinzugefügt werden, die maskiert wird.
+ Spalten, für die eine Transformationsregelaktion für die Datenmaskierung angegeben ist, sind von der Datenüberprüfung in ausgeschlossen. AWS DMS Wenn die Spalten Primärschlüssel/Eindeutiger Schlüssel maskiert sind, wird für diese Tabelle keine Datenüberprüfung ausgeführt. Der Validierungsstatus dieser Tabelle entspricht. `No Primary key`