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 einer Amazon-DynamoDB-Datenbank als Ziel für AWS Database Migration Service
Mit AWS DMS können Sie Daten in eine Amazon-DynamoDB-Tabelle migrieren. Amazon DynamoDB ist ein vollständig verwalteter NoSQL-Datenbank-Service, der schnelle und planbare Leistung mit nahtloser Skalierbarkeit bietet. AWS DMS unterstützt die Verwendung von relationalen Datenbanken oder MongoDB als Quelle.
In DynamoDB sind Tabellen, Elemente und Attribute die zentralen Komponenten, mit denen Sie arbeiten. Eine Tabelle ist eine Sammlung von Elementen und jedes Element wiederum eine Sammlung von Attributen. DynamoDB nutzt die als Partitionsschlüssel bezeichneten Primärschlüssel, um jedes Element in einer Tabelle eindeutig zu identifizieren. Sie können auch Schlüssel und sekundäre Indizes verwenden, um die Abfrage flexibler zu gestalten.
Verwenden Sie Objektzuordnungen zum Migrieren Ihrer Daten aus einer Quelldatenbank in eine DynamoDB-Zieltabelle. Anhand von Objektzuweisungen können Sie bestimmen, wo sich die Quelldaten in der Zieltabelle befinden.
Wenn AWS DMS Tabellen auf einem DynamoDB-Zielendpunkt erstellt, werden dabei so viele Tabellen wie im Quelldatenbank-Endpunkt erstellt. AWS DMS legt auch mehrere DynamoDB-Parameterwerte fest. Die Kosten für die Erstellung der Tabelle sind abhängig von der Datenmenge und der Anzahl der zu migrierenden Tabellen.
Anmerkung
Die Option SSL-Modus in der AWS DMS-Konsole oder -API ist für einige Daten-Streaming- und NoSQL-Services wie Kinesis und DynamoDB nicht anwendbar. Diese sind standardmäßig sicher, daher zeigt AWS DMS für den SSL-Modus „Keine“ an (SSL-Modus=Keine). Sie müssen keine zusätzliche Konfiguration für Ihren Endpunkt angeben, um SSL verwenden zu können. Wenn Sie beispielsweise DynamoDB als Zielendpunkt verwenden, ist dies standardmäßig sicher. Alle API-Aufrufe an DynamoDB verwenden SSL, sodass keine zusätzliche SSL-Option am AWS DMS-Endpunkt erforderlich ist. Mithilfe des HTTPS-Protokolls, das AWS DMS standardmäßig verwendet, wenn eine Verbindung mit einer DynamoDB-Datenbank hergestellt wird, können Sie Daten sicher über SSL-Endpunkte einfügen und abrufen.
Um die Übertragungsgeschwindigkeit zu erhöhen, unterstützt AWS DMS Multi-Thread-Volllastvorgänge in eine DynamoDB-Ziel-Instance. DMS unterstützt Multithreading u. a. mithilfe der folgenden Aufgabeneinstellungen:
-
MaxFullLoadSubTasks– Geben Sie diese Option an, um die maximale Anzahl von Quelltabellen festzulegen, die parallel geladen werden sollen. DMS lädt jede Tabelle mithilfe einer dedizierten Unteraufgabe in die entsprechende DynamoDB-Zieltabelle. Der Standardwert ist 8. Der Höchstwert ist 49. -
ParallelLoadThreads– Verwenden Sie diese Option, um die Anzahl der Threads anzugeben, die AWS DMS zum Laden der einzelnen Tabellen in die DynamoDB-Zieltabellen verwendet. Der Standardwert ist 0 (Single-Thread). Der maximale Wert beträgt 200. Sie können eine Erhöhung dieses Höchstwerts anfordern.Anmerkung
DMS weist jedem Segment einer Tabelle einen eigenen Thread zum Laden zu. Geben Sie aus diesem Grund für
ParallelLoadThreadsdie maximale Anzahl der Segmente an, die Sie für eine Tabelle in der Quelle verwenden werden. -
ParallelLoadBufferSize– Verwenden Sie diese Option, um die maximale Anzahl der Datensätze anzugeben, die in dem Puffer gespeichert werden sollen, den die parallelen Lade-Threads zum Laden von Daten in das DynamoDB-Ziel verwenden. Der Standardwert lautet 50. Die maximale Wert ist 1.000. Verwenden Sie diese Einstellung mitParallelLoadThreads;ParallelLoadBufferSizeist nur gültig, wenn es mehr als einen Thread gibt. -
Table-Mapping-Einstellungen für einzelne Tabellen – Verwenden Sie
table-settings-Regeln, um einzelne Tabellen von der Quelle zu unterscheiden, die Sie parallel laden möchten. Verwenden Sie diese Regeln darüber hinaus, um festzulegen, wie die Zeilen jeder Tabelle für das Multithread-Laden aufgegliedert werden sollen. Weitere Informationen finden Sie unter Regeln und Operationen für Tabellen- und Sammlungseinstellungen.
Anmerkung
Wenn AWS DMS DynamoDB-Parameterwerte für eine Migrationsaufgabe festlegt, wird der Parameterwert für Lesekapazitätseinheiten (Read Capacity Units, RCU) standardmäßig auf 200 festgelegt.
Der Schreibkapazitätseinheiten (WCU)-Parameterwert ist auch festgelegt, aber sein Wert hängt von mehreren anderen Einstellungen ab:
-
Der Standardwert für den WCU-Parameter lautet 200.
-
Wenn die Einstellung für die
ParallelLoadThreads-Aufgabe größer als 1 ist (der Standard ist 0), dann wird der WCU-Parameter auf das 200-fache desParallelLoadThreads-Werts festgelegt. Für die genutzten Ressourcen fallen AWS DMS-Standardnutzungsgebühren an.
Migrieren aus einer relationalen Datenbank in eine DynamoDB-Tabelle
AWS DMS unterstützt die Migration von Daten in skalare DynamoDB-Datentypen. Bei der Migration von Daten aus einer relationalen Datenbank wie Oracle oder MySQL zu DynamoDB sollten Sie die Art und Weise, wie Sie diese Daten speichern, umstrukturieren.
Derzeit unterstützt AWS DMS die Umstrukturierung einzelner Tabellen in die skalaren DynamoDB-Datentypattribute. Wenn Sie Daten aus einer relationalen Datenbanktabelle zu DynamoDB migrieren, formatieren Sie die Daten aus einer Tabelle in die skalaren DynamoDB-Datentypattribute um. Diese Attribute können Daten aus mehreren Spalten aufnehmen und Sie können eine Spalte direkt einem Attribut zuweisen.
AWS DMS unterstützt die folgenden skalaren DynamoDB-Datentypen:
-
String
-
Zahl
-
Boolesch
Anmerkung
NULL-Daten aus der Quelle werden auf dem Ziel ignoriert.
Voraussetzungen für die Verwendung von DynamoDB als Ziel für AWS Database Migration Service
Bevor Sie eine DynamoDB-Datenbank als Ziel für AWS DMS einsetzen können, müssen Sie eine IAM-Rolle erstellen. Diese IAM-Rolle muss AWS DMS zum Zugriff und zum Gewähren von Zugriff auf die DynamoDB-Tabellen berechtigen, in die migriert wird. In der folgenden IAM-Richtlinie sind die Mindestzugriffsberechtigungen dargestellt.
{ "Version": "2012-10-17", "Statement": [ { "Sid": "", "Effect": "Allow", "Principal": { "Service": "dms.amazonaws.com" }, "Action": "sts:AssumeRole" } ] }
Die Rolle, die Sie für die Migration zu DynamoDB verwenden, muss die folgenden Berechtigungen aufweisen:
{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "dynamodb:PutItem", "dynamodb:CreateTable", "dynamodb:DescribeTable", "dynamodb:DeleteTable", "dynamodb:DeleteItem", "dynamodb:UpdateItem" ], "Resource": [ "arn:aws:dynamodb:us-west-2:account-id:table/name1", "arn:aws:dynamodb:us-west-2:account-id:table/OtherName*", "arn:aws:dynamodb:us-west-2:account-id:table/awsdms_apply_exceptions", "arn:aws:dynamodb:us-west-2:account-id:table/awsdms_full_load_exceptions" ] }, { "Effect": "Allow", "Action": [ "dynamodb:ListTables" ], "Resource": "*" } ] }
Einschränkungen bei Verwendung von DynamoDB als Ziel für AWS Database Migration Service
Die folgenden Einschränkungen gelten bei Verwendung von DynamoDB als Ziel:
-
DynamoDB begrenzt die Genauigkeit des Number-Datentyps auf 38 Stellen. Speichern Sie alle Datentypen mit einer höheren Genauigkeit als Zeichenfolge. Sie müssen dies explizit mithilfe der Objektzuweisungsfunktion festlegen.
-
Da DynamoDB keinen Date-Datentyp hat, werden die Daten, die diesen Datentyp verwenden, in Zeichenfolgen umgewandelt.
-
DynamoDB lässt keine Aktualisierungen der Primärschlüssel-Attribute zu. Diese Einschränkung ist wichtig, wenn Sie die laufende Replikation mit Change Data Capture (CDC) verwenden, da sie zu unerwünschten Daten im Ziel führen kann. Je nachdem, wie Sie das Objekt zuweisen, kann eine CDC-Operation, die den Primärschlüssel aktualisiert, Folgendes tun. Es kann entweder fehlschlagen oder ein neues Element mit dem aktualisierten Primärschlüssel und unvollständigen Daten einfügen.
-
AWS DMS unterstützt nur die Replikation von Tabellen mit nicht zusammengesetzten Primärschlüsseln. Die Ausnahme ist, wenn Sie eine Objektzuweisung für die Zieltabelle mit einem benutzerdefinierten Partitionsschlüssel oder Sortierschlüssel (oder beiden) festlegen.
-
AWS DMS unterstützt keine LOB-Daten, es sei denn, es handelt sich um CLOB-Daten. Beim Migrieren von Daten wandelt AWS DMS CLOB-Daten in eine DynamoDB-Zeichenfolge um.
-
Bei der Verwendung von DynamoDB als Ziel wird nur die Steuerungstabelle „Apply Exceptions (Ausnahmen anwenden)“ (
dmslogs.awsdms_apply_exceptions) unterstützt. Weitere Informationen zu Steuerungstabellen finden Sie unter Kontrolltabellen-Aufgabeneinstellungen. AWS DMS unterstützt die Aufgabeneinstellung
TargetTablePrepMode=TRUNCATE_BEFORE_LOADfür DynamoDB als Ziel nicht.AWS DMS unterstützt die Aufgabeneinstellung
TaskRecoveryTableEnabledfür DynamoDB als Ziel nicht.
Verwenden der Objektzuordnung zum Migrieren von Daten zu DynamoDB
AWS DMS nutzt Tabellenzuweisungsregeln zum Zuweisen von Daten von der Quelle zur DynamoDB-Zieltabelle. Um Daten zu einem DynamoDB-Ziel zuzuweisen, verwenden Sie eine Art von Tabellenzuordnungsregel mit der Bezeichnung object-mapping. Mit Objektzuweisungen können Sie Attributnamen und die zu ihnen zu migrierenden Daten definieren. Bei der Verwendung der Objektzuweisung müssen Sie über Auswahlregeln verfügen.
DynamoDB hat keine voreingestellte Struktur, mit Ausnahme eines Partitionsschlüssels und eines optionalen Sortierschlüssels. Wenn Sie über einen nicht zusammengesetzten Primärschlüssel verfügen, wird dieser von AWS DMS verwendet. Wenn Sie über einen zusammengesetzten Primärschlüssel verfügen oder einen Sortierschlüssel verwenden möchten, müssen Sie diese Schlüssel und die anderen Attribute in Ihrer DynamoDB-Zieltabelle definieren.
Zum Erstellen einer Objektzuweisungsregel legen Sie rule-type als object-mapping fest. Diese Regel gibt an, welchen Objektzuweisungstyp Sie verwenden möchten.
Die Struktur für die Regel lautet wie folgt:
{ "rules": [ { "rule-type": "object-mapping", "rule-id": "<id>", "rule-name": "<name>", "rule-action": "<valid object-mapping rule action>", "object-locator": { "schema-name": "<case-sensitive schema name>", "table-name": "" }, "target-table-name": "<table_name>" } ] }
AWS DMS unterstützt derzeit map-record-to-record und map-record-to-document als einzige gültige Werte für den rule-action-Parameter. Diese Werte geben an, wie AWS DMS standardmäßig Datensätze handhabt, die als Teil der exclude-columns-Attributliste nicht ausgeschlossen sind. Diese Werte wirken sich in keiner Weise auf die Attributzuweisungen aus.
-
Sie können
map-record-to-recordbeim Migrieren aus einer relationalen Datenbank zu DynamoDB verwenden. Dabei wird der Primärschlüssel aus der relationalen Datenbank als Partitionsschlüssel in DynamoDB verwendet und für jede Spalte in der Quelldatenbank wird ein Attribut erstellt. Wenn Siemap-record-to-recordverwenden, erstellt AWS DMS für jede Spalte in der Quelltabelle, die nicht in der Attributlisteexclude-columnsaufgeführt ist, ein entsprechendes Attribut auf der DynamoDB-Ziel-Instance. Dies geschieht unabhängig davon, ob diese Quellspalte in einer Attributzuweisung verwendet wird oder nicht. -
Verwenden Sie
map-record-to-document, um Quellspalten mithilfe des Attributnamens „_doc“ in einer einzelnen, flachen DynamoDB-Zuordnung auf dem Ziel zu platzieren. Wenn Siemap-record-to-documentverwenden, platziert AWS DMS die Daten in einem einzigen, flachen DynamoDB-Zuordnungsattribut in der Quelle. Dieses Attribut hat den Namen "_doc". Diese Platzierung gilt für jede Spalte der Quelltabelle, die nicht in derexclude-columns-Attributliste aufgeführt ist.
Der Unterschied zwischen den rule-action-Parametern map-record-to-record und map-record-to-document lässt sich am besten verstehen, wenn Sie die beiden Parameter in Aktion erleben. In diesem Beispiel wird davon ausgegangen, dass Sie mit einer Tabellenzeile einer relationalen Datenbank beginnen, die die folgende Struktur aufweist und die folgenden Daten enthält:
Um diese Informationen zu DynamoDB zu migrieren, erstellen Sie Regeln zum Zuweisen der Daten in ein DynamoDB-Tabellenelement. Beachten Sie die für den exclude-columns-Parameter aufgeführten Spalten. Diese Spalten werden nicht direkt dem Ziel zugewiesen. Stattdessen werden die Daten mithilfe der Attributzuweisung in neue Elemente kombiniert, z. B. werden FirstName und LastName im DynamoDB-Ziel in CustomerName gruppiert. NickName und income sind nicht ausgeschlossen.
{ "rules": [ { "rule-type": "selection", "rule-id": "1", "rule-name": "1", "object-locator": { "schema-name": "test", "table-name": "%" }, "rule-action": "include" }, { "rule-type": "object-mapping", "rule-id": "2", "rule-name": "TransformToDDB", "rule-action": "map-record-to-record", "object-locator": { "schema-name": "test", "table-name": "customer" }, "target-table-name": "customer_t", "mapping-parameters": { "partition-key-name": "CustomerName", "exclude-columns": [ "FirstName", "LastName", "HomeAddress", "HomePhone", "WorkAddress", "WorkPhone" ], "attribute-mappings": [ { "target-attribute-name": "CustomerName", "attribute-type": "scalar", "attribute-sub-type": "string", "value": "${FirstName},${LastName}" }, { "target-attribute-name": "ContactDetails", "attribute-type": "document", "attribute-sub-type": "dynamodb-map", "value": { "M": { "Home": { "M": { "Address": { "S": "${HomeAddress}" }, "Phone": { "S": "${HomePhone}" } } }, "Work": { "M": { "Address": { "S": "${WorkAddress}" }, "Phone": { "S": "${WorkPhone}" } } } } } } ] } } ] }
Bei Verwendung des rule-action-Parameters map-record-to-record werden die Daten für NickName und income zu den Elementen mit demselben Namen im DynamoDB-Ziel zugewiesen.
Angenommen, Sie verwenden die gleichen Regeln, ändern aber den rule-action-Parameter in map-record-to-document. In diesem Fall werden die Spalten exclude-columnsNickName und income, die nicht im -Parameter aufgeführt sind, einem _doc-Element zugeordnet.
Verwenden von benutzerdefinierten Bedingungsausdrücken mit Objektzuweisung
Sie können das DynamoDB-Feature für Bedingungsausdrücke verwenden, um Daten zu bearbeiten, die in eine DynamoDB-Tabelle geschrieben werden. Weitere Informationen zu Bedingungsausdrücken in DynamoDB finden Sie unter Bedingungsausdrücke.
Ein Bedingungsausdruckselement besteht aus:
-
einem Ausdruck (erforderlich)
-
Ausdrucksattributwerten (optional). Gibt eine DynamoDB-JSON-Struktur des Attributwerts an.
-
Ausdrucksattributnamen (optional)
-
Optionen für die Verwendung des Bedingungsausdrucks (optional). Der Standardwert lautet "apply-during-cdc = false and apply-during-full-load = true".
Die Struktur für die Regel lautet wie folgt:
"target-table-name": "customer_t", "mapping-parameters": { "partition-key-name": "CustomerName", "condition-expression": { "expression":"<conditional expression>", "expression-attribute-values": [ { "name":"<attribute name>", "value":<attribute value> } ], "apply-during-cdc":<optional Boolean value>, "apply-during-full-load": <optional Boolean value> }
Im folgenden Beispiel werden die für den Bedingungsausdruck verwendeten Abschnitte hervorgehoben.
Verwenden der Attributzuweisung mit Objektzuweisung
Mit Attributzuweisungen können Sie eine Vorlagenzeichenfolge festlegen, indem Sie anhand von Quellspaltennamen Daten auf dem Ziel umstrukturieren. Es wird keine Formatierung vorgenommen, außer den Angaben, die der Benutzer für die Vorlage festlegt.
Das folgende Beispiel zeigt die Struktur der Quelldatenbank und die gewünschte Struktur des DynamoDB-Ziels. Zuerst wird die Struktur der Quelle dargestellt, in diesem Fall eine Oracle-Datenbank, und dann die gewünschte Struktur der Daten in DynamoDB. Am Ende des Beispiels ist das JSON-Format dargestellt, mit dem die gewünschte Zielstruktur erstellt wird.
Die Struktur der Oracle-Daten ist im Folgenden angegeben:
| FirstName | LastName | StoreId | HomeAddress | HomePhone | WorkAddress | WorkPhone | DateOfBirth |
|---|---|---|---|---|---|---|---|
| Primärschlüssel | N/A | ||||||
| Randy | Marsh | 5 | 221B Baker Street | 1234567890 | 31 Spooner Street, Quahog | 9876543210 | 02/29/1988 |
Die Struktur der DynamoDB-Daten ist im Folgenden angegeben:
| CustomerName | StoreId | ContactDetails | DateOfBirth |
|---|---|---|---|
| Partitionsschlüssel | Sortierschlüssel | N/A | |
|
|
|
|
Im folgenden JSON-Beispiel sind die Objekt- und Spaltenzuordnungen dargestellt, mit denen die DynamoDB-Struktur erzielt wird:
{ "rules": [ { "rule-type": "selection", "rule-id": "1", "rule-name": "1", "object-locator": { "schema-name": "test", "table-name": "%" }, "rule-action": "include" }, { "rule-type": "object-mapping", "rule-id": "2", "rule-name": "TransformToDDB", "rule-action": "map-record-to-record", "object-locator": { "schema-name": "test", "table-name": "customer" }, "target-table-name": "customer_t", "mapping-parameters": { "partition-key-name": "CustomerName", "sort-key-name": "StoreId", "exclude-columns": [ "FirstName", "LastName", "HomeAddress", "HomePhone", "WorkAddress", "WorkPhone" ], "attribute-mappings": [ { "target-attribute-name": "CustomerName", "attribute-type": "scalar", "attribute-sub-type": "string", "value": "${FirstName},${LastName}" }, { "target-attribute-name": "StoreId", "attribute-type": "scalar", "attribute-sub-type": "string", "value": "${StoreId}" }, { "target-attribute-name": "ContactDetails", "attribute-type": "scalar", "attribute-sub-type": "string", "value": "{\"Name\":\"${FirstName}\",\"Home\":{\"Address\":\"${HomeAddress}\",\"Phone\":\"${HomePhone}\"}, \"Work\":{\"Address\":\"${WorkAddress}\",\"Phone\":\"${WorkPhone}\"}}" } ] } } ] }
Alternativ kann bei der Spaltenzuordnung das DynamoDB-Format als Dokumenttyp verwendet werden. Im folgenden Codebeispiel wird dynamodb-map als attribute-sub-type für die Attributzuweisung verwendet.
{ "rules": [ { "rule-type": "selection", "rule-id": "1", "rule-name": "1", "object-locator": { "schema-name": "test", "table-name": "%" }, "rule-action": "include" }, { "rule-type": "object-mapping", "rule-id": "2", "rule-name": "TransformToDDB", "rule-action": "map-record-to-record", "object-locator": { "schema-name": "test", "table-name": "customer" }, "target-table-name": "customer_t", "mapping-parameters": { "partition-key-name": "CustomerName", "sort-key-name": "StoreId", "exclude-columns": [ "FirstName", "LastName", "HomeAddress", "HomePhone", "WorkAddress", "WorkPhone" ], "attribute-mappings": [ { "target-attribute-name": "CustomerName", "attribute-type": "scalar", "attribute-sub-type": "string", "value": "${FirstName},${LastName}" }, { "target-attribute-name": "StoreId", "attribute-type": "scalar", "attribute-sub-type": "string", "value": "${StoreId}" }, { "target-attribute-name": "ContactDetails", "attribute-type": "document", "attribute-sub-type": "dynamodb-map", "value": { "M": { "Name": { "S": "${FirstName}" }, "Home": { "M": { "Address": { "S": "${HomeAddress}" }, "Phone": { "S": "${HomePhone}" } } }, "Work": { "M": { "Address": { "S": "${WorkAddress}" }, "Phone": { "S": "${WorkPhone}" } } } } } } ] } } ] }
Alternativ zu dynamodb-map können Sie dynamodb-list als Attribut-Untertyp für die Attributzuordnung verwenden, wie im folgenden Beispiel gezeigt.
{ "target-attribute-name": "ContactDetailsList", "attribute-type": "document", "attribute-sub-type": "dynamodb-list", "value": { "L": [ { "N": "${FirstName}" }, { "N": "${HomeAddress}" }, { "N": "${HomePhone}" }, { "N": "${WorkAddress}" }, { "N": "${WorkPhone}" } ] } }
Beispiel 1: Verwenden der Attributzuweisung mit Objektzuweisung
Im folgenden Beispiel werden Daten aus den zwei MySQL-Datenbanktabellen nfl_data und sport_team in die zwei DynamoDB-Tabellen NFLTeams und SportTeams migriert. Unten stehend ist die Tabellenstruktur und das JSON-Format angegeben, das zum Zuweisen der Daten aus den MySQL-Datenbanktabellen zu den DynamoDB-Tabellen verwendet wird.
Die Struktur der MySQL-Datenbanktabelle nfl_data ist im Folgenden dargestellt:
mysql> desc nfl_data; +---------------+-------------+------+-----+---------+-------+ | Field | Type | Null | Key | Default | Extra | +---------------+-------------+------+-----+---------+-------+ | Position | varchar(5) | YES | | NULL | | | player_number | smallint(6) | YES | | NULL | | | Name | varchar(40) | YES | | NULL | | | status | varchar(10) | YES | | NULL | | | stat1 | varchar(10) | YES | | NULL | | | stat1_val | varchar(10) | YES | | NULL | | | stat2 | varchar(10) | YES | | NULL | | | stat2_val | varchar(10) | YES | | NULL | | | stat3 | varchar(10) | YES | | NULL | | | stat3_val | varchar(10) | YES | | NULL | | | stat4 | varchar(10) | YES | | NULL | | | stat4_val | varchar(10) | YES | | NULL | | | team | varchar(10) | YES | | NULL | | +---------------+-------------+------+-----+---------+-------+
Die Struktur der MySQL-Datenbanktabelle sport_team ist im Folgenden dargestellt:
mysql> desc sport_team; +---------------------------+--------------+------+-----+---------+----------------+ | Field | Type | Null | Key | Default | Extra | +---------------------------+--------------+------+-----+---------+----------------+ | id | mediumint(9) | NO | PRI | NULL | auto_increment | | name | varchar(30) | NO | | NULL | | | abbreviated_name | varchar(10) | YES | | NULL | | | home_field_id | smallint(6) | YES | MUL | NULL | | | sport_type_name | varchar(15) | NO | MUL | NULL | | | sport_league_short_name | varchar(10) | NO | | NULL | | | sport_division_short_name | varchar(10) | YES | | NULL | |
Im Folgenden sind die Tabellenzuordnungsregeln für die Zuordnung der zwei Tabellen zu den zwei DynamoDB-Tabellen aufgeführt:
{ "rules":[ { "rule-type": "selection", "rule-id": "1", "rule-name": "1", "object-locator": { "schema-name": "dms_sample", "table-name": "nfl_data" }, "rule-action": "include" }, { "rule-type": "selection", "rule-id": "2", "rule-name": "2", "object-locator": { "schema-name": "dms_sample", "table-name": "sport_team" }, "rule-action": "include" }, { "rule-type":"object-mapping", "rule-id":"3", "rule-name":"MapNFLData", "rule-action":"map-record-to-record", "object-locator":{ "schema-name":"dms_sample", "table-name":"nfl_data" }, "target-table-name":"NFLTeams", "mapping-parameters":{ "partition-key-name":"Team", "sort-key-name":"PlayerName", "exclude-columns": [ "player_number", "team", "name" ], "attribute-mappings":[ { "target-attribute-name":"Team", "attribute-type":"scalar", "attribute-sub-type":"string", "value":"${team}" }, { "target-attribute-name":"PlayerName", "attribute-type":"scalar", "attribute-sub-type":"string", "value":"${name}" }, { "target-attribute-name":"PlayerInfo", "attribute-type":"scalar", "attribute-sub-type":"string", "value":"{\"Number\": \"${player_number}\",\"Position\": \"${Position}\",\"Status\": \"${status}\",\"Stats\": {\"Stat1\": \"${stat1}:${stat1_val}\",\"Stat2\": \"${stat2}:${stat2_val}\",\"Stat3\": \"${stat3}:${ stat3_val}\",\"Stat4\": \"${stat4}:${stat4_val}\"}" } ] } }, { "rule-type":"object-mapping", "rule-id":"4", "rule-name":"MapSportTeam", "rule-action":"map-record-to-record", "object-locator":{ "schema-name":"dms_sample", "table-name":"sport_team" }, "target-table-name":"SportTeams", "mapping-parameters":{ "partition-key-name":"TeamName", "exclude-columns": [ "name", "id" ], "attribute-mappings":[ { "target-attribute-name":"TeamName", "attribute-type":"scalar", "attribute-sub-type":"string", "value":"${name}" }, { "target-attribute-name":"TeamInfo", "attribute-type":"scalar", "attribute-sub-type":"string", "value":"{\"League\": \"${sport_league_short_name}\",\"Division\": \"${sport_division_short_name}\"}" } ] } } ] }
Die Beispielausgabe für die DynamoDB-Tabelle NFLTeams ist im Folgenden dargestellt:
"PlayerInfo": "{\"Number\": \"6\",\"Position\": \"P\",\"Status\": \"ACT\",\"Stats\": {\"Stat1\": \"PUNTS:73\",\"Stat2\": \"AVG:46\",\"Stat3\": \"LNG:67\",\"Stat4\": \"IN 20:31\"}", "PlayerName": "Allen, Ryan", "Position": "P", "stat1": "PUNTS", "stat1_val": "73", "stat2": "AVG", "stat2_val": "46", "stat3": "LNG", "stat3_val": "67", "stat4": "IN 20", "stat4_val": "31", "status": "ACT", "Team": "NE" }
Die Beispielausgabe für die DynamoDB-Tabelle SportsTeams ist im Folgenden dargestellt:
{ "abbreviated_name": "IND", "home_field_id": 53, "sport_division_short_name": "AFC South", "sport_league_short_name": "NFL", "sport_type_name": "football", "TeamInfo": "{\"League\": \"NFL\",\"Division\": \"AFC South\"}", "TeamName": "Indianapolis Colts" }
Zieldatentypen für DynamoDB
Der DynamoDB-Endpunkt für AWS DMS unterstützt die meisten DynamoDB-Datentypen. In der folgenden Tabelle sind die Amazon AWS DMS-Zieldatentypen aufgeführt, die bei Verwendung von AWS DMS unterstützt werden, sowie deren Standardzuweisung von AWS DMS-Datentypen.
Weitere Informationen zu AWS DMS-Datentypen finden Sie unter Datentypen für den AWS Database Migration Service.
Wenn AWS DMS Daten aus heterogenen Datenbanken migriert, weisen wir Datentypen aus der Quelldatenbank zu Zwischendatentypen zu, die als AWS DMS-Datentypen bezeichnet werden. Wir weisen dann die Zwischendatentypen zu den Zieldatentypen zu. In der folgenden Tabelle sind die jeweiligen AWS DMS-Datentypen sowie der Datentyp aufgeführt, zu dem die Zuordnung in DynamoDB erfolgt:
| AWS DMS-Datentyp | DynamoDB-Datentyp |
|---|---|
|
String |
String |
|
WString |
String |
|
Boolesch |
Boolesch |
|
Datum |
String |
|
DateTime |
String |
|
INT1 |
Zahl |
|
INT2 |
Zahl |
|
INT4 |
Zahl |
|
INT8 |
Zahl |
|
Numerischer Wert |
Zahl |
|
Real4 |
Zahl |
|
Real8 |
Zahl |
|
UINT1 |
Zahl |
|
UINT2 |
Zahl |
|
UINT4 |
Zahl |
| UINT8 | Zahl |
| CLOB | String |
