

翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。

# のターゲットとしての Amazon DynamoDB データベースの使用 AWS Database Migration Service
<a name="CHAP_Target.DynamoDB"></a>

を使用して AWS DMS 、Amazon DynamoDB テーブルにデータを移行できます。Amazon DynamoDB は、高速で予測可能なパフォーマンスとシームレスなスケーラビリティを提供するフルマネージド NoSQL データベースサービスです。 は、リレーショナルデータベースまたは MongoDB をソースとして使用 AWS DMS します。

DynamoDB では、テーブル、項目、および属性が、操作するコアコンポーネントです。*[table]* (テーブル) とは項目の集合であり、各 *[item ]* (項目) は属性の集合です。DynamoDB は、テーブルの各項目を一意に識別するために、パーティションキーと呼ばれるプライマリキーを使用します。より柔軟なクエリを提供するために、キーおよびセカンダリインデックスを使用することもできます。

ソースのデータベースから、ターゲット DynamoDB テーブルにデータを移行するために、オブジェクトのマッピングを使用します。オブジェクトのマッピングを使用すると、ソースデータがターゲットのどこにあるか判定できます。

 AWS DMS が DynamoDB ターゲットエンドポイントにテーブルを作成すると、ソースデータベースエンドポイントと同じ数のテーブルが作成されます。 は複数の DynamoDB パラメータ値 AWS DMS も設定します。テーブル作成のコストは、データの量および移行するテーブルの数によって異なります。

**注記**  
 AWS DMS コンソールまたは API の **SSL モード**オプションは、Kinesis や DynamoDB などの一部のデータストリーミングや NoSQL サービスには適用されません。これらはデフォルトで安全であるため、SSL モードの設定が none (**SSL Mode=None**) と等しい AWS DMS ことを示しています。SSL を使用するために、エンドポイントに追加の設定は必要ありません。例えば、DynamoDB をターゲットエンドポイントとして使用する場合、デフォルトで保護されます。DynamoDB へのすべての API コールは SSL を使用するため、 AWS DMS エンドポイントに追加の SSL オプションは必要ありません。 AWS DMS が DynamoDB データベースへの接続時にデフォルトで使用する HTTPS プロトコルを使用して、SSL エンドポイント経由で安全にデータを保存して取得できます。

転送速度を上げるために、 は DynamoDB ターゲットインスタンスへのマルチスレッド全ロード AWS DMS をサポートします。DMS では、このマルチスレッドでのタスク設定を、以下でサポートします。
+ `MaxFullLoadSubTasks` - 並列ロードするソーステーブルの最大数を指定するにはこのオプションを使用します。DMS は、専用のサブタスクを使用して、対応する DynamoDB ターゲットテーブルに各テーブルをロードします。デフォルト値は 8 です。最大値は 49 です。
+ `ParallelLoadThreads` – このオプションを使用して、 AWS DMS が各テーブルを DynamoDB ターゲットテーブルにロードするために使用するスレッドの数を指定します。デフォルト値は 0 (シングルスレッド) です。最大値は 200 です。この上限を増やすよう依頼できます。
**注記**  
DMS は、テーブルの各セグメントを独自のスレッドに割り当てロードします。したがって、`ParallelLoadThreads` をソースのテーブルに指定するセグメントの最大数に設定します。
+ `ParallelLoadBufferSize` – DynamoDB ターゲットにデータをロードするために並列ロードスレッドが使用するバッファ内に保存するレコードの最大数を指定するには、このオプションを使用します。デフォルト値は 50 です。最大値は 1000 です。この設定は `ParallelLoadThreads` で使用します。`ParallelLoadBufferSize` は、複数のスレッドがある場合にのみ有効です。
+ 個々のテーブルのテーブルマッピング設定 - `table-settings` ルールを使用して、並列ロードするソースから個々のテーブルを識別します。また、これらのルールを使用して、各テーブルの行をマルチスレッドロード用にセグメント化する方法を指定します。詳細については、「[テーブルとコレクション設定のルールとオペレーション](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.md)」を参照してください。

**注記**  
が移行タスクの DynamoDB パラメータ値 AWS DMS を設定すると、デフォルトの読み込みキャパシティーユニット (RCU) パラメータ値は 200 に設定されます。  
書き込みキャパティティーユニット (WCU) のパラメータ値も設定されますが、その値は他のいくつかの設定によって異なります。  
WCU パラメータのデフォルト値は 200 です。
`ParallelLoadThreads` タスク設定が 1 より大きい値に設定された場合 (デフォルトは 0)、WCU パラメータは `ParallelLoadThreads` 値の 200 倍に設定されます。
使用するリソースには、標準 AWS DMS 使用料が適用されます。

## リレーショナルデータベースから DynamoDB テーブルへの移行
<a name="CHAP_Target.DynamoDB.RDBMS2DynamoDB"></a>

AWS DMS は、DynamoDB スカラーデータ型へのデータの移行をサポートしています。Oracle や MySQL などのリレーショナルデータベースから DynamoDB に移行する場合は、データを格納する方法を再編成が必要となる場合があります。

現在、 AWS DMS は DynamoDB スカラータイプの属性への単一テーブルから単一テーブルへの再構築をサポートしています。リレーショナルデータベースのテーブルから DynamoDB にデータを移行する場合、テーブルからデータを取得し、DynamoDB のスカラーデータ型属性に形式を変更します。これらの属性は複数の列からデータを受け入れることができるため、列を属性に直接マッピングすることができます。

AWS DMS は、次の DynamoDB スカラーデータ型をサポートしています。
+ String
+ Number
+ ブール値

**注記**  
ソースからの NULL データは、ターゲットで無視されます。

## のターゲットとして DynamoDB を使用するための前提条件 AWS Database Migration Service
<a name="CHAP_Target.DynamoDB.Prerequisites"></a>

のターゲットとして DynamoDB データベースの使用を開始する前に AWS DMS、必ず IAM ロールを作成してください。この IAM ロールでは AWS DMS 、移行先の DynamoDB テーブルへのアクセスを が引き受けて許可する必要があります。アクセス許可の最小設定は、次の IAM ポリシーで示します。

------
#### [ JSON ]

****  

```
{
   "Version":"2012-10-17",		 	 	 
   "Statement": [
      {
         "Sid": "",
         "Effect": "Allow",
         "Principal": {
            "Service": "dms.amazonaws.com"
         },
         "Action": "sts:AssumeRole"
      }
   ]
}
```

------

DynamoDB に移行する際使用するロールには、次のアクセス許可が必要です。

------
#### [ JSON ]

****  

```
{
    "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:111122223333:table/name1",
                "arn:aws:dynamodb:us-west-2:111122223333:table/OtherName*",
                "arn:aws:dynamodb:us-west-2:111122223333:table/awsdms_apply_exceptions",
                "arn:aws:dynamodb:us-west-2:111122223333:table/awsdms_full_load_exceptions"
            ]
        },
        {
            "Effect": "Allow",
            "Action": [
                "dynamodb:ListTables"
            ],
            "Resource": "*"
        }
    ]
}
```

------

## のターゲットとして DynamoDB を使用する場合の制限 AWS Database Migration Service
<a name="CHAP_Target.DynamoDB.Limitations"></a>

ターゲットとして DynamoDB を使用する場合、以下の制限が適用されます：
+ DynamoDB は、数値データ型の最大精度を 38 に制限します。文字列として高い精度のすべてのデータ型を保存します。オブジェクトマッピング機能を使用して、これを明示的に指定する必要があります。
+ DynamoDB に Date データ型がないため、Date データ型を使用しているデータは、文字列に変換されます。
+ DynamoDB はプライマリ キー属性の更新を許可しません。この制限は、ターゲットで不要なデータが発生する可能性があるため、変更データキャプチャ (CDC) で継続的なレプリケーションを使用する場合に重要です。オブジェクトのマッピング方法に応じて、プライマリキーを更新する CDC オペレーションは 2 つのうちのいずれかを実行できます。これは、更新されたプライマリキーおよび不完全なデータがある新しい項目を挿入できるか、あるいは失敗するかのいずれかです。
+ AWS DMS は、複合以外のプライマリキーを持つテーブルのレプリケーションのみをサポートします。例外は、カスタムパーティションキーまたはソートキー、あるいはその両方があるターゲットテーブルにオブジェクトマッピングを指定する場合です。
+ AWS DMS は、CLOB でない限り、LOB データをサポートしません。 は、CLOB データをデータの移行時に DynamoDB 文字列 AWS DMS に変換します。
+ ターゲットとして DynamoDB を使用する場合、例外適用制御テーブル (`dmslogs.awsdms_apply_exceptions`) のみがサポートされます。統制テーブルの詳細については、「[制御テーブルタスク設定](CHAP_Tasks.CustomizingTasks.TaskSettings.ControlTable.md)」をご参照ください。
+ AWS DMS は、DynamoDB `TargetTablePrepMode=TRUNCATE_BEFORE_LOAD` のタスク設定をターゲットとしてサポートしていません。
+ AWS DMS は、DynamoDB `TaskRecoveryTableEnabled` のタスク設定をターゲットとしてサポートしていません。
+ `BatchApply` は DynamoDB エンドポイントではサポートされていません。
+ AWS DMS は、名前が DynamoDB の予約語と一致する属性を移行できません。詳細については、「*Amazon DynamoDB ディベロッパーガイド*」の「[DynamoDB での予約語](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html)」を参照してください。

## DynamoDB にデータを移行するためのオブジェクトマッピングの使用
<a name="CHAP_Target.DynamoDB.ObjectMapping"></a>

AWS DMS はテーブルマッピングルールを使用して、ソースからターゲット DynamoDB テーブルにデータをマッピングします。DynamoDB ターゲットにデータをマッピングするために、*object-mapping* と呼ばれるテーブルマッピングルールのタイプを使用します。オブジェクトマッピングにより、移行するデータの属性名とデータを定義できます。オブジェクトマッピングを使用するときは選択ルールが必要です。

DynamoDB には、パーティションのキーとオプションのソートキー以外に、プリセット構造はありません。複合以外のプライマリキーがある場合、 はそれ AWS DMS を使用します。複合プライマリキーがある場合、またはソートキーを使用する必要がある場合は、ターゲット DynamoDB テーブルでそれらのキーと他の属性を定義します。

オブジェクトマッピングルールを作成するには、`rule-type` を *object-mapping* として指定します。このルールが、使用したいオブジェクトマッピングのタイプを指定します。

ルールの構造は次のとおりです。

```
{ "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 は現在、 `rule-action`パラメータの唯一の有効な値`map-record-to-document`として `map-record-to-record`と をサポートしています。これらの値は、`exclude-columns`属性リストの一部として除外されていないレコードに対してデフォルトで AWS DMS 何を行うかを指定します。これらの値は、どのような方法でも属性マッピングに影響しません。
+ リレーショナルデータベースから DynamoDB に移行するときに `map-record-to-record` を使用できます。DynamoDB のパーティションキーとしてリレーショナルデータベースからプライマリ キーを使用し、ソースデータベース内の各列の属性を作成します。を使用する場合`map-record-to-record`、`exclude-columns`属性リストにリストされていないソーステーブルの任意の列に対して、 はターゲット DynamoDB インスタンスで対応する属性 AWS DMS を作成します。これは、そのソース列が属性マッピングで使用されているかどうかにかかわらず作成されます。
+ `map-record-to-document` を使用して、ターゲットの 1 つのフラット DynamoDB マップに "\$1doc." 属性名でソース列を配置します。を使用する場合`map-record-to-document`、 はデータをソース上の単一のフラットな DynamoDB マップ属性 AWS DMS に配置します。この属性は "\$1doc." と呼ばれます。この配置は、`exclude-columns` 属性リストに含まれていないソーステーブル内のすべての列に適用されます。

`rule-action` パラメータの `map-record-to-record` と `map-record-to-document` の違いを理解する 1 つの方法は、この 2 つのパラメータの動作を確認することです。この例では、次の構造とデータを含むリレーショナルデータベースのテーブルから始めると想定してください。

![\[例のためのサンプルデータベース\]](http://docs.aws.amazon.com/ja_jp/dms/latest/userguide/images/datarep-dynamodb1.png)


この情報を DynamoDB に移行するには、データを DynamoDB テーブルにマッピングするルールを作成します。パラメータにリストされている `exclude-columns` 列を書き留めてください。これらの列はターゲットに直接マッピングされていません。その代わりに、データを組み合わせて新しい項目を作成するために、属性マッピングが使用されています。たとえば、*FirstName* と *LastName* を組み合わせると DynamoDB ターゲット上の *CustomerName* になります。*NickName* と *income* は除外されていません。

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

`rule-action` パラメータ *map-record-to-record*を使用することで、*NickName* および *income* のデータは、DynamoDB ターゲットで同じ名前の項目にマッピングされます。

![\[の使用を開始する AWS DMS\]](http://docs.aws.amazon.com/ja_jp/dms/latest/userguide/images/datarep-dynamodb2.png)


ただし、同じルールを使用しますが `rule-action` パラメータを *map-record-to-document* に変更するとします。この場合、`exclude-columns` パラメータ、 *NickName* および *income* にリストされない列は、*\$1doc* 項目にマッピングされます。

![\[の使用を開始する AWS DMS\]](http://docs.aws.amazon.com/ja_jp/dms/latest/userguide/images/datarep-dynamodb3.png)


### オブジェクトマッピングでのカスタム条件式の使用
<a name="CHAP_Target.DynamoDB.ObjectMapping.ConditionExpression"></a>

DynamoDB テーブルに書き込み中のデータを操作するための条件式と呼ばれる DynamoDB の機能を使用することができます。DynamoDB の条件式の詳細については、「[条件式](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.ConditionExpressions.html)」をご参照ください。

条件式のメンバーは次から構成されます。
+ 式 (必須) 
+ 式の属性値 (必須）。属性値の DynamoDB json 構造を指定します。これは、実行時まで不明な DynamoDB の値と属性を比較するのに役立ちます。式の属性値は、実際の値のプレースホルダーとして定義できます。
+ 式の属性名 (必須）。この値を使用すると、DynamoDB の予約語や特殊文字を含む属性名などとの競合が発生する可能性を回避できます。
+ 条件式をいつ使用するかを選ぶオプション (オプション) デフォルトは apply-during-cdc = false および apply-during-full-load = true

ルールの構造は次のとおりです。

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

次のサンプルは、条件式に使用されるセクションを主に示しています。

![\[の使用を開始する AWS DMS\]](http://docs.aws.amazon.com/ja_jp/dms/latest/userguide/images/datarep-Tasks-conditional1.png)


### オブジェクトマッピングで属性マッピングを使用する
<a name="CHAP_Target.DynamoDB.ObjectMapping.AttributeMapping"></a>

属性マッピングでは、ターゲット上のデータを再編成するために、ソース列名を使用してテンプレート文字列を指定することができます。ユーザーがテンプレートで指定する場合を除き、書式設定は行われません。

次の例は、ソースデータベースの構造と、DynamoDB ターゲットの必要とされる構造を示します。最初に示すのは、ソースの構造で、この場合は Oracle データベースです。次に DynamoDB 内のデータの必要とされる構造を示します。この例では最後に、必要なターゲット構造を作成するのに使用される JSON を示します。

Oracle データの構造は次のとおりです。


****  

| FirstName | LastName | StoreId | HomeAddress | HomePhone | WorkAddress | WorkPhone | DateOfBirth | 
| --- | --- | --- | --- | --- | --- | --- | --- | 
| プライマリキー | 該当なし |  | 
| Randy | Marsh | 5 | 221B Baker Street  | 1234567890 | 31 Spooner Street, Quahog  | 9876543210  | 02/29/1988  | 

DynamoDB データの構造は次のとおりです。


****  

| CustomerName | StoreId | ContactDetails | DateOfBirth | 
| --- | --- | --- | --- | 
| パーティションキー | ソートキー | 該当なし | 
| <pre>Randy,Marsh</pre> | <pre>5</pre> | <pre>{<br />    "Name": "Randy",<br />    "Home": {<br />        "Address": "221B Baker Street",<br />        "Phone": 1234567890<br />    },<br />    "Work": {<br />        "Address": "31 Spooner Street, Quahog",<br />        "Phone": 9876541230<br />    }<br />}</pre> | <pre>02/29/1988</pre> | 

次の JSON は、DynamoDB 構造を達成するために使用されるオブジェクトマッピングと列マッピングを示します。

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

列マッピングを使用するもう 1 つの方法は、ドキュメントタイプとして DynamoDB 形式を使用することです。次のコード例では、`attribute-sub-type` として *dynamodb map* を属性マッピングに使用します。

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

次の例のように、`dynamodb-map` の代わりに `dynamodb-list` を属性マッピングの属性サブタイプとして使用することもできます。

```
{
"target-attribute-name": "ContactDetailsList",
"attribute-type": "document",
"attribute-sub-type": "dynamodb-list",
"value": {
    "L": [
            {
                "N": "${FirstName}"
            },
            {   
                "N": "${HomeAddress}"
            },
            {   
                "N": "${HomePhone}"
            },
            {
                "N": "${WorkAddress}"
            },
            {
                "N": "${WorkPhone}"
            }
        ]   
    }
}
```

### 例1: オブジェクトマッピングで属性マッピングを使用する
<a name="CHAP_Target.DynamoDB.ColumnMappingExample1"></a>

次の例は、2 つの MySQL データベーステーブル *nfl\$1data* と *sport\$1team* のデータを、*NFLTeams* と *SportTeams* という 2 つの DynamoDB テーブルへ移行します。テーブルの構造、および MySQL データベーステーブルから DynamoDB テーブルへデータをマップするために使用される JSON は、次のとおりです。

MySQL データベース *nfl\$1data* の構造は次のとおりです。

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

MySQL データベーステーブル*sport\$1team* の構造は次のとおりです。

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

2 つのテーブルを 2 つの DynamoDB テーブルにマッピングするために使用されるテーブルマッピングルールは次のとおりです。

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

*NFLTeams* DynamoDB テーブルの出力例は次のとおりです。

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

SportsTeams *DynamoDB* テーブルの出力例は次のとおりです。

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

## DynamoDB のターゲットデータ型
<a name="CHAP_Target.DynamoDB.DataTypes"></a>

の DynamoDB エンドポイントは、ほとんどの DynamoDB データ型 AWS DMS をサポートしています。次の表は、 の使用時にサポートされる Amazon AWS DMS ターゲットデータ型 AWS DMS と AWS DMS 、データ型からのデフォルトのマッピングを示しています。

 AWS DMS データ型の詳細については、「」を参照してください[AWS Database Migration Service のデータ型](CHAP_Reference.DataTypes.md)。

が異種データベースからデータを AWS DMS 移行する場合、ソースデータベースのデータ型をデータ型と呼ばれる中間 AWS DMS データ型にマッピングします。その後、中間データ型をターゲットデータ型にマッピングします。次の表は、DynamoDB の各 AWS DMS データ型とマッピングされるデータ型を示しています。


| AWS DMS データ型 | DynamoDB データ型 | 
| --- | --- | 
|  String  |  String  | 
|  WString  |  String  | 
|  ブール値  |  ブール値  | 
|  日付  |  String  | 
|  DateTime  |  String  | 
|  INT1  |  Number  | 
|  INT2  |  Number  | 
|  INT4  |  Number  | 
|  INT8  |  Number  | 
|  数値  |  Number  | 
|  Real4  |  Number  | 
|  Real8  |  Number  | 
|  UINT1  |  Number  | 
|  UINT2  |  Number  | 
|  UINT4  |  Number  | 
| UINT8 | Number | 
| CLOB | String | 