本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。

# 使用表映射指定任务设置
<a name="CHAP_Tasks.CustomizingTasks.TableMapping"></a>

表映射使用多个类型的规则来指定数据源、源架构、数据以及任务期间将发生的任何转换。可以使用表映射指定数据库中要迁移的单个表和要用于迁移的架构。

使用表映射时，可以使用筛选器指定要从表列复制的数据。此外，您还可以使用转换来修改选定的架构、表或视图，然后再将其写入目标数据库。

**Topics**
+ [通过控制台指定表选择和转换规则](CHAP_Tasks.CustomizingTasks.TableMapping.Console.md)
+ [使用 JSON 指定表选择和转换规则](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.md)
+ [选择规则和操作](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Selections.md)
+ [表映射中的通配符](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Wildcards.md)
+ [转换规则和操作](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Transformations.md)
+ [使用转换规则表达式定义列内容](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions.md)
+ [表和集合设置规则和操作](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.md)
+ [使用数据掩蔽隐藏敏感信息](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Masking.md)

**注意**  
在将表映射用于 MongoDB 源端点时，可以使用筛选器指定要复制的数据，然后指定一个数据库名称来替代 `schema_name`。或者，可以使用默认的 `"%"`。

# 通过控制台指定表选择和转换规则
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.Console"></a>

您可以使用 AWS 管理控制台 来执行表映射，包括指定表选择和转换。在控制台上，您可以使用**位置**部分指定架构、表和操作（包括或排除）。使用**筛选器**部分指定表中的列名称以及要应用于复制任务的条件。这两个操作共同创建选择规则。

在指定至少一个选择规则后，可以在表映射中包含转换。可以使用转换重命名架构或表，为架构或表添加前缀或后缀，或者删除表列。

**注意**  
AWS DMS 不支持每个架构级别、表级别或列级别的多个转换规则。

以下过程演示了如何根据名为 **EntertainmentAgencySample** 的架构中名为 **Customers** 的表来设置选择规则。

**使用控制台指定表选择、筛选条件和转换**

1. 登录 AWS 管理控制台 并在 [https://console.aws.amazon.com/dms/v2](https://console.aws.amazon.com/dms/v2/)/上打开 AWS DMS 控制台。

   如果以 IAM 用户身份登录，请确保具有适当的 AWS DMS访问权限。有关所需权限的更多信息，请参阅[使用所需的 IAM 权限 AWS DMS](security-iam.md#CHAP_Security.IAMPermissions)。

1. 在**控制面板**页面上，选择**数据库迁移任务**。

1. 选择**创建任务**。

1. 在**任务配置**部分中，输入任务信息，包括**任务标识符**、**复制实例**、**源数据库端点**、**目标数据库端点**和**迁移类型**。  
![\[架构和表选择\]](http://docs.aws.amazon.com/zh_cn/dms/latest/userguide/images/datarep-create-task-20.png)

1. 在**表映射**部分中，选择架构名称和表名称。在指定架构名称或表名称时，可以使用“%”作为通配符值。有关可使用的其他通配符的信息，请参阅[表映射中的通配符](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Wildcards.md)。指定包括或排除由筛选器定义的数据所需执行的操作。  
![\[架构和表选择\]](http://docs.aws.amazon.com/zh_cn/dms/latest/userguide/images/datarep-Tasks-selecttransfrm.png)

1. 使用**添加列筛选器**和**添加条件**链接指定筛选器信息。

   1. 选择**添加列筛选器**以指定列和条件。

   1. 选择**添加条件**以添加其他条件。

    以下示例介绍 **Customers** 表的筛选器，包含介于 **01** 和 **85** 之间的 **AgencyIDs**。  
![\[架构和表选择\]](http://docs.aws.amazon.com/zh_cn/dms/latest/userguide/images/datarep-Tasks-filter.png)

1. 在创建所需的选择后，选择**添加新的选择规则**。

1. 创建至少一个选择规则后，可以向任务添加转换。选择**添加转换规则**。  
![\[转换规则\]](http://docs.aws.amazon.com/zh_cn/dms/latest/userguide/images/datarep-Tasks-transform1.png)

1. 选择要转换的目标，然后输入请求的其他信息。以下示例介绍从 **Customer** 表中删除 **AgencyStatus** 列的转换。  
![\[转换规则\]](http://docs.aws.amazon.com/zh_cn/dms/latest/userguide/images/datarep-Tasks-transform2.png)

1. 选择**添加转换规则**。

1. 选择**创建任务**。

**注意**  
AWS DMS 不支持每个架构级别、表级别或列级别的多个转换规则。

# 使用 JSON 指定表选择和转换规则
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation"></a>

要指定在迁移过程中要应用的表映射，可以创建 JSON 文件。如果使用控制台创建迁移任务，则可浏览此 JSON 文件或在表映射框中直接输入 JSON。如果使用 CLI 或 API 执行迁移，那么可以使用 `CreateReplicationTask` 或 `ModifyReplicationTask` API 操作的 `TableMappings` 参数指定此文件。

AWS DMS 只能处理大小不超过 2 MB 的表映射 JSON 文件。我们建议您在处理 DMS 任务时，将映射规则 JSON 文件大小保持在 2 MB 限制以下。这样可防止在创建或修改任务过程中出现意外错误。如果映射规则文件超过 2 MB 限制，我们建议您将表拆分为多个任务，以减小映射规则文件的大小，使其保持在该限制以下。

您可以指定要处理哪些表、视图和架构。您还可以执行表、视图和架构转换，并指定 AWS DMS 如何加载单独的表和视图。您使用以下规则类型为这些选项创建表映射规则：
+ `selection` 规则 – 确定要加载的源表、视图和架构的类型和名称。有关更多信息，请参阅 [选择规则和操作](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Selections.md)。
+ `transformation` 规则 – 指定在将源中的特定源表和架构加载到目标之前，对其所做某些更改或添加。有关更多信息，请参阅 [转换规则和操作](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Transformations.md)。

  此外，要定义新列和现有列的内容，可以在转换规则中使用表达式。有关更多信息，请参阅 [使用转换规则表达式定义列内容](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions.md)。
+ `table-settings` 规则 – 指定 DMS 任务为各个表加载数据的方式。有关更多信息，请参阅 [表和集合设置规则和操作](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.md)。

**注意**  
对于 Amazon S3 目标，也可以使用 `post-processing` 规则类型和 `add-tag` 规则操作，标记映射到所选表和架构的 S3 对象。有关更多信息，请参阅 [Amazon S3 对象标记](CHAP_Target.S3.md#CHAP_Target.S3.Tagging)。  
对于以下目标，可以使用 `object-mapping` 规则类型，指定将所选架构和表迁移到目标的方式和位置：  
Amazon DynamoDB – 有关更多信息，请参阅[使用对象映射将数据迁移到 DynamoDB](CHAP_Target.DynamoDB.md#CHAP_Target.DynamoDB.ObjectMapping)。
Amazon Kinesis – 有关更多信息，请参阅[使用对象映射将数据迁移到 Kinesis 数据流](CHAP_Target.Kinesis.md#CHAP_Target.Kinesis.ObjectMapping)。
Apache Kafka – 有关更多信息，请参阅[使用对象映射将数据迁移到 Kafka 主题](CHAP_Target.Kafka.md#CHAP_Target.Kafka.ObjectMapping)。

# 选择规则和操作
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Selections"></a>

通过使用表映射，可通过选择规则和操作来指定要使用的表、视图和架构。对于使用选择规则类型的表映射规则，您可应用以下值。

**警告**  
请勿在这些规则中包含任何敏感数据。

[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/dms/latest/userguide/CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Selections.html)

**Example 迁移架构中的所有表**  
以下示例将所有表从源中名为 `Test` 的架构中迁移到目标端点。  

```
{
    "rules": [
        {
            "rule-type": "selection",
            "rule-id": "1",
            "rule-name": "1",
            "object-locator": {
                "schema-name": "Test",
                "table-name": "%"
            },
            "rule-action": "include"
        }
    ]
}
```

**Example 迁移架构中的一些表**  
以下示例将所有表（以 `DMS` 开头的表除外）从源中名为 `Test` 的架构中迁移到目标端点。  

```
{
    "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 在单个架构中迁移指定的单个表**  
以下示例将源中 `NewCust` 架构中的 `Customer` 表迁移到目标端点。  

```
{
    "rules": [
        {
            "rule-type": "selection",
            "rule-id": "1",
            "rule-name": "1",
            "object-locator": {
                "schema-name": "NewCust",
                "table-name": "Customer"
            },
            "rule-action": "explicit"
        }
    ]
}
```
您可以通过指定多个选择规则在多个表和架构上显式选择。

**Example 按设定顺序迁移表**  
表和视图根据其加载顺序值进行迁移，较高的值在迁移序列中获得优先级。以下示例会迁移两个表，`loadfirst`（优先级值为 2）和 `loadsecond`（优先级值为 1），迁移任务将首先处理 `loadfirst` 表，然后再继续处理 `loadsecond` 表。这种优先级划分机制可确保在迁移过程中遵循数据库对象之间的依赖关系。  

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

**注意**  
`load-order` 适用于表初始化。如果 `MaxFullLoadSubTasks` 大于 1，则连续表的加载不会等待上一个表的加载完成。

**Example 迁移架构中的部分视图**  
以下示例将部分视图从源中名为 `Test` 的架构迁移到目标中等同的表。  

```
{
   "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 迁移架构中的所有表和视图**  
以下示例将所有表和视图从源中名为 `report` 的架构迁移到目标中等同的表。  

```
{
   "rules": [
        {
           "rule-type": "selection",
           "rule-id": "3",
           "rule-name": "3",
           "object-locator": {
               "schema-name": "report",
               "table-name": "%",
               "table-type": "all"
            },
           "rule-action": "include"
        }
    ]
}
```

# 表映射中的通配符
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Wildcards"></a>

本节介绍在为表映射指定架构和表名称时可以使用的通配符。


| 通配符 | Matches | 
| --- |--- |
| % | 零个或多个字符 | 
| \$1 | 单个字符 | 
| [\$1] | 字面下划线字符 | 
| [ab] | 一组字符。例如，[ab] 匹配'a'或'b'。 | 
| [a-d] | 一系列字符。例如，[a-d] 匹配 'a'、'b'、'c' 或 'd'。 | 

对于 Oracle 源端点和目标端点，可以使用 `escapeCharacter` 额外的连接属性指定转义字符。转义字符允许在表达式中使用指定的通配符，就好像它不是通配符一样。例如，`escapeCharacter=#` 允许使用“\$1”，使通配符在表达式中充当普通字符，如本示例代码中所示。

```
{
    "rules": [
        {
            "rule-type": "selection",
            "rule-id": "542485267",
            "rule-name": "542485267",
            "object-locator": { "schema-name": "ROOT", "table-name": "TEST#_T%" },
            "rule-action": "include",
            "filters": []
        }
    ]
}
```

在这里，'\$1' 转义字符使 '\$1' 通配符充当普通字符。 AWS DMS 在名为的架构中选择表`ROOT`，其中每个表都有一个名字`TEST_T`作为其前缀。

# 转换规则和操作
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Transformations"></a>

可使用转换操作指定要应用于所选架构、表或视图的任何转换。转换规则是可选的。

## 限制
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Transformations.Limitations"></a>
+ 不能对同一个对象（架构、表、列、表-表空间或索引-表空间）应用多个转换规则操作。只要每个转换操作应用于不同的对象，那么可以在任何级别应用多个转换规则操作。但是，当使用数据掩蔽转换规则时，此限制不适用。在这种规则中，您可以对同一列进行其他转换，例如 `ADD-COLUMN` 或 `CHANGE-DATA-TYPE`。
+ 转换规则中的表名称和列名称是区分大小写的。例如，Oracle 或 Db2 数据库的表名称和列名称必须以大写形式提供。
+ 不支持使用 Right-to-Left语言的列名进行转换。
+ 对于名称中包含特殊字符（如 \$1、\$1、/、-）的列，无法执行转换。
+ 对于映射到 BLOB/CLOB 数据类型的列，唯一支持的转换是将该列放在目标上。
+ AWS DMS 不支持将两个源表复制到单个目标表。 AWS DMS 根据复制任务的转换规则，将记录从一个表复制到另一个表以及从一个列复制到另一个列。对象名称必须唯一，以防止重叠。

  例如，源表包含名为 `ID` 的列，而对应的目标表预先存在名为 `id` 的列。如果规则使用`ADD-COLUMN`语句添加名为的新列`id`，并使用 SQLite 语句在列中填充自定义值，则会创建一个名为但不支持的重复的`id`、模棱两可的对象。
+ 创建转换规则时，建议仅在选择规则指定多列时（例如，当您将 `column-name` 设置为 `%` 时）才使用 `data-type` 参数。建议不要使用 `data-type` 选择单列。
+ AWS DMS 不支持源对象和目标对象（表）位于同一数据库/架构上的转换规则。在转换规则中同时使用同一个表作为源表和目标表可能会导致意外且可能有害的结果，包括但不限于表数据的意外更改、表结构的修改甚至表被删除。

## 值
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Transformations.Values"></a>

对于使用转换规则类型的表映射规则，可应用以下值。

[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/dms/latest/userguide/CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Transformations.html)

## 示例
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Transformations.Examples"></a>

**Example 重命名架构**  
以下示例将架构从 `Test`（源中）重命名为 `Test1`（目标中）。  

```
{

    "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 重命名表**  
以下示例将表从 `Actor`（源中）重命名为 `Actor1`（目标中）。  

```
{
    "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 重命名列**  
以下示例将列从 `first_name` 中的表 `Actor`（源中）重命名为 `fname`（目标中）。  

```
{
    "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 重命名 Oracle 表表空间**  
以下示例将 Oracle 源中名为 `Actor` 的表的名为 `SetSpace` 的表空间重命名为 Oracle 目标端点中的 `SceneTblSpace`。  

```
{
    "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 重命名 Oracle 索引表空间**  
以下示例将 Oracle 源中名为 `Actor` 的表的名为 `SetISpace` 的索引表空间重命名为 Oracle 目标端点中的 `SceneIdxSpace`。  

```
{
    "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 添加列**  
以下示例将 `datetime` 列添加到架构 `test` 的表 `Actor` 中。  

```
{
    "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 删除列**  
以下示例将转换源中名为 `Actor` 的表，以从目标中删除以字符 `col` 开头的所有列。  

```
{
 	"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 转换为小写形式**  
以下示例将表名从 `ACTOR`（源中）转换为 `actor`（目标中）。  

```
{
	"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 转换为大写形式**  
以下示例将所有表和所有架构的所有列从小写形式（源中）转换为大写形式（目标中）。  

```
{
    "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 添加前缀**  
以下示例转换源中的所有表，以便在目标中向这些表添加前缀 `DMS_`。  

```
{
 	"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 替换前缀**  
以下示例将转换源中包含前缀 `Pre_` 的所有列，以在目标中将前缀替换为 `NewPre_`。  

```
{
    "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 删除后缀**  
以下示例转换源中的所有表，以从目标中删除这些表的后缀 `_DMS`。  

```
{
	"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 定义主键**  
以下示例在迁移到目标端点的 `ITEM` 表的三个列上定义一个名为 `ITEM-primary-key` 的主键。  

```
{
	"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 定义唯一索引**  
以下示例在迁移到目标端点的 `ITEM` 表的三个列上定义一个名为 `ITEM-unique-idx` 的唯一索引。  

```
{
	"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 更改目标列的数据类型**  
以下示例将名为 `SALE_AMOUNT` 的目标列的数据类型从现有数据类型更改为 `int8`。  

```
{
    "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 添加之前映像列**  
对于名为 `emp_no` 的源列，下面示例中的转换规则会在目标中添加名为 `BI_emp_no` 的新列。  

```
{
	"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"
			}
		}
	]
}
```
在此，下面的语句用 1 填充相应行中的 `BI_emp_no` 列。  

```
UPDATE employees SET emp_no = 3 WHERE BI_emp_no = 1;
```
在向支持的 AWS DMS 目标写入 CDC 更新时，该`BI_emp_no`列可以判断`emp_no`列中哪些行有更新的值。

# 使用转换规则表达式定义列内容
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions"></a>

要定义新列和现有列的内容，可以在转换规则中使用表达式。例如，使用表达式，您可以添加列或将源表标头复制到目标。您还可以使用表达式将目标表上的记录标记为在源中插入、更新或删除。

**Topics**
+ [使用表达式添加列](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-adding)
+ [使用表达式标记目标记录](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-Flagging)
+ [使用表达式复制源表标头](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-Headers)
+ [使用 SQLite 函数构建表达式](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-SQLite)
+ [使用表达式向目标表添加元数据](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-Metadata)

## 使用表达式添加列
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-adding"></a>

要使用转换规则中的表达式向表添加列，请使用 `add-column` 规则操作和 `column` 规则目标。

以下示例将新列添加到 `ITEM` 表中。它将新列名称设置为 `FULL_NAME`，数据类型为 `string`，长度为 50 个字符。此表达式连接两个现有列 `LAST_NAME` 和 `FIRST_NAME` 的值，以便计算结果为 `FULL_NAME`。`schema-name`、`table-name` 和表达式参数引用的是源数据库表中的对象。`Value` 和 `data-type` 块引用的是目标数据库表中的对象。

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

## 使用表达式标记目标记录
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-Flagging"></a>

要将目标表中的记录标记为在源表中插入、更新或删除，请在转换规则中使用表达式。表达式使用 `operation_indicator` 函数来标记记录。从源中删除的记录不会从目标中删除。而是使用用户提供的值标记目标记录，以指示该记录已从源中删除。

**注意**  
`operation_indicator` 函数仅适用于源数据库和目标数据库中具有主键的表。

例如，以下转换规则首先将新的 `Operation` 列添加到目标表中。然后，只要从源表中删除记录，它就会更新具有值 `D` 的列。

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

## 使用表达式复制源表标头
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-Headers"></a>

默认情况下，源表的标头不会复制到目标。要指示要复制哪些标头，请将转换规则与包含表列标头的表达式结合使用。

您可以在表达式中使用以下列标头。

[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/dms/latest/userguide/CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions.html)

以下示例通过使用源中的流位置值向目标添加新列。对于 SQL Server，流位置值是源端点的 LSN。对于 Oracle，流位置值是源端点的 SCN。

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

以下示例向目标添加了一个新列，该列具有来自源的唯一递增数字。此值表示任务级别的 35 位唯一数字。前 16 位数字是时间戳的一部分，后 19 位是由 DBMS 递增的 record\$1id 数字。

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

## 使用 SQLite 函数构建表达式
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-SQLite"></a>

您可以使用表设置指定要应用于指定操作的选定表或视图的任何设置。表设置规则是可选的。

**注意**  
MongoDB 和 DocumentDB 数据库没有表和视图的概念，而是将数据记录存储为文档，这些文档聚集在*集合*中。因此，从 MongoDB 或 DocumentDB 源迁移时，对于所选*集合*（而不是表和视图），请考虑范围分段类型的并行加载设置。

**Topics**
+ [使用 CASE 表达式](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-SQLite.CASE)
+ [示例](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-SQLite.Ex)

接下来，您可以找到可用于构建转换规则表达式的字符串函数。


| 字符串函数 | 说明 | 
| --- | --- | 
|  `lower(x)`  |  `lower(x)` 函数返回字符串 *`x`* 的副本，且所有字符都转换为小写。默认情况下，内置的 `lower` 函数仅适用于 ASCII 字符。  | 
|  `upper(x)`  |  `upper(x)` 函数返回字符串 *`x`* 的副本，且所有字符都转换为大写。默认情况下，内置的 `upper` 函数仅适用于 ASCII 字符。  | 
|  `ltrim(x,y)`  |  `ltrim(x,y)` 函数返回一个字符串，删除了 y 中出现的 x 左侧的所有字符。如果 y 没有值，则 `ltrim(x)` 删除 x 左侧的空格。  | 
|  `replace(x,y,z)`  |  `replace(x,y,z)` 函数返回一个字符串，将字符串 x 中每次出现的字符串 y 替换为字符串 z。  | 
| `rtrim(x,y)` |  `rtrim(x,y)` 函数返回一个字符串，删除了 y 中出现的 x 右侧的所有字符。如果 y 没有值，则 `rtrim(x)` 删除 x 右侧的空格。  | 
| `substr(x,y,z)` |  `substr(x,y,z)` 函数返回输入字符串 `x` 的子字符串，该子字符串从第 `y` 个字符开始，长度为 *`z`* 个字符。 如果省略 *`z`*，则 `substr(x,y)` 返回字符串 `x` 中从第 `y` 个字符到结尾的全部字符。`x` 最左侧的字符为数字 1。如果 *`y`* 为负数，则子字符串的第一个字符将从右侧，而不是左侧开始计数。如果 *`z`* 为负数，则返回第 `y` 个字符之前的 `abs(z)` 个字符。如果 `x` 是字符串，则字符索引指向实际的 UTF-8 字符。如果 `x` 是 BLOB，则索引指向字节。  | 
| trim(x,y) |  `trim(x,y)` 函数返回一个字符串，删除了 `y` 中出现的 `x` 两侧的所有字符。如果 `y` 没有值，则 `trim(x)` 删除 `x` 两侧的空格。  | 

接下来，您可以找到可用于构建转换规则表达式的 LOB 函数。


| LOB 函数 | 说明 | 
| --- | --- | 
|  `hex(x)`  |  `hex` 函数接收 BLOB 作为参数，并返回 BLOB 内容的大写十六进制字符串版本。  | 
|  `randomblob (N)`  |  `randomblob(N)` 函数返回包含伪随机字节的 `N` 字节 BLOB。如果小*N*于 1，则返回一个 1 字节的随机 BLOB。  | 
|  `zeroblob(N)`  |  `zeroblob(N)` 函数返回由 `N` 个字节 0x00 组成的 BLOB。  | 

接下来，您可以找到可用于构建转换规则表达式的数字函数。


| 数字函数 | 说明 | 
| --- | --- | 
|  `abs(x)`  |  `abs(x)` 函数返回数字参数 `x` 的绝对值。如果为空，则该`abs(x)`函数返回 N *x* ULL。如果**x**是无法转换为数值的字符串或 BLOB，则该`abs(x)`函数返回 0.0。  | 
|  `random()`  |  `random` 函数返回介于 -9,223,372,036,854,775,808 与 \$19,223,372,036,854,775,807 之间的伪随机整数。  | 
|  `round (x,y)`  |  该`round (x,y)`函数返回一个浮点值，*x*四舍五入到*y*小数点右边的数字。如果没有的值*y*，则假定为 0。  | 
|  `max (x,y...)`  |  多参数 `max` 函数返回具最大值的参数，如果任何参数均为 NULL，则返回 NULL。 `max` 函数从左到右搜索其参数，以寻找定义排序函数的参数。如果找到一个，则使用该排序函数对所有字符串进行比较。如果 `max` 没有任何参数定义排序函数，则使用 `BINARY` 排序函数。当具有两个或更多参数时，`max` 函数是一个简单的函数，但如果只有一个参数，则该函数作为聚合函数运行。  | 
|  `min (x,y...)`  |  多参数 `min` 函数返回具有最小值的参数。 `min` 函数从左到右搜索其参数，以寻找定义排序函数的参数。如果找到一个，则使用该排序函数对所有字符串进行比较。如果 `min` 没有任何参数定义排序函数，则使用 `BINARY` 排序函数。当具有两个或更多参数时，`min` 函数是一个简单的函数，但如果只有一个参数，则该函数作为聚合函数运行。  | 

接下来，您可以找到可用于构建转换规则表达式的 NULL 校验函数。


| NULL 校验函数 | 说明 | 
| --- | --- | 
|  `coalesce (x,y...)`  |  `coalesce` 函数返回其第一个非 NULL 参数的副本，但如果所有参数均为 NULL，则返回 NULL。coalesce 函数至少具有两个参数。  | 
|  `ifnull(x,y)`  |  `ifnull` 函数返回其第一个非 NULL 参数的副本，但如果两个参数均为 NULL，则返回 NULL。`ifnull` 函数只有两个参数。`ifnull` 函数与具有两个参数的 `coalesce` 函数相同。  | 
|  `nullif(x,y)`  |  如果参数不同，则 `nullif(x,y)` 函数返回其第一个参数的副本，但如果参数相同，则返回 NULL。 `nullif(x,y)` 函数从左到右搜索其参数，以寻找定义排序函数的参数。如果找到一个，则使用该排序函数对所有字符串进行比较。如果两个参数都没有定义排序函数，则使用 `BINARY` 排序函数。  | 

接下来，您可以找到可用于构建转换规则表达式的日期和时间函数。


| 日期和时间函数 | 说明 | 
| --- | --- | 
|  `date(timestring, modifier, modifier...)`  |  该`date`函数以格式返回日期 YYYY-MM-DD。  | 
|  `time(timestring, modifier, modifier...)`  |  `time` 函数以 HH:MM:SS 格式返回时间。  | 
|  `datetime(timestring, modifier, modifier...)`  |  该`datetime`函数以 YYYY-MM-DD HH: MM: SS 格式返回日期和时间。  | 
|  `julianday(timestring, modifier, modifier...)`  |  `julianday` 函数返回自公元前 4714 年 11 月 24 日格林威治中午以来的天数。  | 
|  `strftime(format, timestring, modifier, modifier...)`  |  `strftime` 函数使用以下变量之一，按照第一个参数指定的格式字符串返回日期： `%d`：一月中的第几天 `%H`：小时（00–24） `%f`:\$1\$1 小数形式的秒数 SS.SSS `%j`：一年中的第几天（001–366） `%J`：\$1\$1 Julian 天数 `%m`：月（01–12） `%M`：分钟（00–59） `%s`：自 1970 年 1 月 1 日以来的秒数 `%S`：秒（00–59） `%w`：一周中的第几天（0–6，星期日 = 0） `%W`：一年中的第几周（00–53） `%Y`：年（0000–9999） `%%`: %  | 

接下来，您可以找到可用于构建转换规则表达式的哈希函数。


| 哈希函数 | 说明 | 
| --- | --- | 
|  `hash_sha256(x)`  |  `hash` 函数为输入列生成哈希值（使用 SHA-256 算法），并返回生成的哈希值的十六进制值。 要在表达式中使用 `hash` 函数，可将 `hash_sha256(x)` 添加到表达式中，并将 *`x`* 替换为源列名。  | 

### 使用 CASE 表达式
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-SQLite.CASE"></a>

 SQLite `CASE`表达式计算条件列表并根据结果返回表达式。语法如下所示。

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

### 示例
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-SQLite.Ex"></a>

**Example 使用 case 条件向目标表添加新的字符串列**  
以下示例转换规则将新的字符串列 `emp_seniority` 添加到目标表 `employee`。它使用薪金列上的 SQLite `round`函数，并使用案例条件来检查工资是否等于或超过 20,000。如果条件满足，则该列获得值 `SENIOR`，而其他任何列获得值 `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 使用 SUBSTR 函数向目标表添加新的字符串列**  
以下示例转换规则使用 SQLite 运算符或函数添加新的字符串列，以定义列中的数据。这种方法涉及使用 SQLite 函数将从 Oracle 加载的 GUID 数据转换为 UUID 格式，然后再将其插入 Postgresql 目标表。  
以下规则使用 SQLite 子字符串 (SUBSTR)、十六进制函数 (HEX) 和小写 (LOWER) 函数将 GUID 数据分成由连字符分隔的几组，具体来说是一组 8 位数字，后面是三组 4 位数字，然后是一组 12 位数字，总共有 32 位表示 128 位。  
以下是源数据和经过转换规则处理后目标端输出的示例：  
**源表（Oracle GUID 格式）**    
T\$1 COL2  

```
06F6949D234911EE80670242AC120002
1A2B3C4D5E6F11EE80670242AC120003
F5E4D3C2B1A011EE80670242AC120004
```
**目标表（PostgreSQL UUID 格式）**    
T\$1 \$1TMP COL2  

```
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 向目标表添加新的日期列**  
以下示例将新的日期列 `createdate` 添加到目标表 `employee`。使用 SQLite 日期函数时`datetime`，会为插入的每一行将日期添加到新创建的表中。  

```
  {
      "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 向目标表添加新的数字列**  
以下示例将新的数字列 `rounded_emp_salary` 添加到目标表 `employee`。它使用 SQLite `round`函数将四舍五入的工资相加。  

```
  {
      "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 使用哈希函数向目标表添加新的字符串列**  
以下示例将新的字符串列 `hashed_emp_number` 添加到目标表 `employee`。该 SQLite`hash_sha256(x)`函数在目标上为源列创建哈希值。`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
      }
  }
```

## 使用表达式向目标表添加元数据
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-Metadata"></a>

可以使用以下表达式，将元数据信息添加到目标表：
+ `$AR_M_SOURCE_SCHEMA` – 源架构的名称。
+ `$AR_M_SOURCE_TABLE_NAME` – 源表的名称。
+ `$AR_M_SOURCE_COLUMN_NAME` – 源表中的列的名称。
+ `$AR_M_SOURCE_COLUMN_DATATYPE` – 源表中列的数据类型。

**Example 使用源的架构名称为架构名称添加列**  
以下示例使用源的架构名称，将名为 `schema_name` 的新列添加到目标。  

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

# 表和集合设置规则和操作
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings"></a>

可以使用表设置，指定要应用于指定操作的选定表或视图的任何设置。表设置规则是可选的，具体取决于端点和迁移要求。

MongoDB 和 Amazon DocumentDB 数据库不使用表和视图，而是将数据记录存储为文档，这些文档聚集在*集合*中。任何 MongoDB 或 Amazon DocumentDB 端点的单个数据库都是由数据库名称标识的一组特定集合。

从 MongoDB 或 Amazon DocumentDB 源迁移时，使用并行加载设置的方式略有不同。在这种情况下，对于所选集合（而不是表和视图），请考虑自动分段或范围分段类型的并行加载设置。

**Topics**
+ [表格设置中的通配符受到限制](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.Wildcards)
+ [对所选表、视图和集合使用并行加载](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.ParallelLoad)
+ [为所选表或视图指定 LOB 设置](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.LOB)
+ [表设置示例](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.Examples)

对于使用表设置规则类型的表映射规则，您可以应用以下参数。

[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/dms/latest/userguide/CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.html)

## 表格设置中的通配符受到限制
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.Wildcards"></a>

源数据库不支持在 `"table-settings"` 规则中使用百分比通配符（`"%"`），如下所示。

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

如果您在`"table-settings"`规则`"%"`中使用如图所示，则 AWS DMS 返回以下异常。

```
Error in mapping rules. Rule with ruleId = x failed validation. Exact 
schema and table name required when using table settings rule.
```

此外， AWS 建议您不要使用单个任务加载大量的大型集合`parallel-load`。请注意， AWS DMS 通过 `MaxFullLoadSubTasks` 任务设置参数值（最大值为 49），限制资源争用以及并行加载的段数。

相反，可通过分别指定每个 `"schema-name"` 和 `"table-name"`，为最大的集合指定源数据库的所有集合。此外，可适当扩大迁移规模。例如，在足够数量的复制实例上运行多个任务，以处理数据库中的大量大型集合。

## 对所选表、视图和集合使用并行加载
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.ParallelLoad"></a>

要加速迁移并提高其效率，可以对选定的表、视图和集合使用并行加载。换而言之，可以并行使用多个线程迁移单个分段的表、视图或集合。为此，将满负荷 AWS DMS 任务拆分为线程，并将每个表段分配给自己的线程。

使用此并行加载过程，您可以首先让多个线程从源端点并行卸载多个表、视图和集合。然后，可以迁移多个线程，并将相同的表、视图和集合并行加载到目标端点。对于某些数据库引擎，可以按现有分区或子分区对表和视图进行分段。对于其他数据库引擎，您可以根据特定参数 AWS DMS 自动对集合进行细分（自动分段）。除此之外，可以按指定的列值范围，对任何表、视图或集合进行分段。

以下源端点支持并行加载：
+ Oracle
+ Microsoft SQL Server
+ MySQL
+ PostgreSQL
+ IBM Db2 LUW
+ SAP Adaptive Server Enterprise（ASE）
+ MongoDB（仅支持并行完全加载的自动分段和范围分段选项）
+ Amazon DocumentDB（仅支持并行完全加载的自动分段和范围分段选项）

对于 MongoDB 和 Amazon DocumentDB 终端节点 AWS DMS ，支持以下数据类型，这些列是并行满载的范围分割选项的分区键。
+ 双精度
+ String
+ ObjectId
+ 32 位整数
+ 64 位整数

以下目标端点支持用于表设置规则的并行加载：
+ Oracle
+ Microsoft SQL Server
+ MySQL
+ PostgreSQL
+ Amazon S3
+ SAP Adaptive Server Enterprise（ASE）
+ Amazon Redshift
+ MongoDB（仅支持并行完全加载的自动分段和范围分段选项）
+ Amazon DocumentDB（仅支持并行完全加载的自动分段和范围分段选项）
+ Db2 LUW

要指定并行加载的表和视图的最大数，请使用 `MaxFullLoadSubTasks` 任务设置。

要为并行加载任务的支持目标指定每个表或视图的最大线程数，可使用列值边界定义更多的段。

**重要**  
`MaxFullLoadSubTasks` 控制要并行加载的表或表段的数量。`ParallelLoadThreads` 控制迁移任务用于执行并行加载的线程数。*这些设置为相乘关系*。因此，完全加载任务期间使用的线程总数大约为 `ParallelLoadThreads `的值乘以 `MaxFullLoadSubTasks` 的值（`ParallelLoadThreads` **\$1** `MaxFullLoadSubtasks)`）。  
如果您创建的任务包含大量完全加载子任务和大量并行加载线程，则任务可能会消耗过多的内存并失败。

要为 Amazon DynamoDB、Amazon Kinesis Data Streams、Apache Kafka 或 Amazon Elasticsearch Service 目标指定每个表的最大线程数，可使用 `ParallelLoadThreads` 目标元数据任务设置。

要指定使用 `ParallelLoadThreads` 时并行加载任务的缓冲区大小，可使用 `ParallelLoadBufferSize` 目标元数据任务设置。

`ParallelLoadThreads` 和 `ParallelLoadBufferSize` 的可用性和设置取决于目标端点。

有关 `ParallelLoadThreads` 和 `ParallelLoadBufferSize` 设置的更多信息，请参阅[目标元数据任务设置](CHAP_Tasks.CustomizingTasks.TaskSettings.TargetMetadata.md)。有关 `MaxFullLoadSubTasks` 设置的更多信息，请参阅[完全加载任务设置](CHAP_Tasks.CustomizingTasks.TaskSettings.FullLoad.md)。有关特定于目标端点的信息，请参阅相关主题。

要使用并行加载，您可以使用 `parallel-load` 选项创建一个类型为 `table-settings` 的表映射规则。在 `table-settings` 规则中，您可以为要并行加载的单个表、视图或集合指定分段条件。要执行此操作，请将 `parallel-load` 选项的 `type` 参数设置为多个选项之一。

如何执行此操作取决于您希望如何为并行加载分段表、视图或集合：
+ 按分区（或段）– 使用 `partitions-auto` 类型加载所有现有表或视图分区（或段）。或者使用具指定分区数组的 `partitions-list` 类型，仅加载选定的分区。

  仅适用于 MongoDB 和 Amazon DocumentDB 终端节点，按区段加载所有或指定的集合 AWS DMS ，这些集合也使用`partitions-auto`类型和其他可选参数自动计算。`table-settings`
+ （仅限 Oracle 端点）按子分区 – 使用 `subpartitions-auto` 类型加载所有现有的表或视图子分区。或者使用具指定 `subpartitions` 数组的 `partitions-list` 类型，仅加载选定的子分区。
+ 按您定义的段 – 加载使用列值边界定义的表、视图或集合段。为此，请使用具有指定 `columns` 和 `boundaries` 数组的 `ranges` 类型。
**注意**  
PostgreSQL 端点仅支持此类型的并行加载。作为源端点的 MongoDB 和 Amazon DocumentDB 既支持此范围分段类型，也支持并行完全加载的自动分段类型（`partitions-auto`）。

要标识要并行加载的其他表、视图或集合，请使用 `parallel-load` 选项指定其他 `table-settings` 对象。

在以下过程中，您可以了解如何为每种并行加载类型编写 JSON 代码（从最简单到最复杂）。

**指定所有表、视图或集合分区，或所有表或视图子分区**
+ 使用 `partitions-auto` 类型或 `subpartitions-auto` 类型（但不能同时使用二者）指定 `parallel-load`。

  然后，每个表、视图或集合分区（或段）或子分区会自动分配到自己的线程。

  对于某些端点，并行加载仅包括已为表或视图定义的分区或子分区。对于 MongoDB 和 Amazon DocumentDB 源终端节点，您可以 AWS DMS 根据可选的附加参数自动计算分区（或分段）。这包括 `number-of-partitions`、`collection-count-from-metadata`、`max-records-skip-per-page` 和 `batch-size`。

**指定选定表或视图的分区和/或子分区**

1. 使用 `partitions-list` 类型指定 `parallel-load`。

1. （可选）通过将分区名称数组指定为 `partitions` 的值来包含分区。

   然后，每个指定的分区将分配到自己的线程。
**重要**  
对于 Oracle 端点，在选择分区和子分区进行并行加载时，请确保分区和子分区不重叠。如果使用重叠的分区和子分区并行加载数据，则会复制条目，或者由于主键重复冲突而失败。

1. （可选）仅限 Oracle 端点，可通过将子分区名称数组指定为 `subpartitions` 的值来包含子分区。

   然后，每个指定的子分区将分配到自己的线程。
**注意**  
并行加载仅包括已为表或视图定义的分区或子分区。

您可以指定表或视图段作为列值范围。执行此操作时，请注意以下列特征：
+ 指定索引列可显著提高性能。
+ 您可以指定最多 10 个列。
+ 您不能使用列来定义具有以下 AWS DMS 数据类型的分段边界：DOUBLE、FLOAT、BLOB、CLOB 和 NCLOB
+ 不会复制具有 null 值的记录。

**指定表、视图或集合段作为列值范围**

1. 使用 `ranges` 类型指定 `parallel-load`。

1. 通过列名数组指定为 `columns` 的值来定义表或视图段之间的边界。对要为其定义表或视图段之间边界的每个列执行此操作。

   列的顺序很重要。在定义每个边界时，第一列是最重要的，最后一列最不重要，如下所述。

1. 通过将边界数组指定为 `boundaries` 值来定义所有表或视图段的数据范围。*边界数组*是一个列值数组的数组。要实现此目的，请执行以下步骤：

   1. 将列值数组的每个元素指定为与每个列对应的值。*列值数组* 代表您要定义的每个表或视图段的上边界。按照您在 `columns` 数组中指定该列的顺序指定每个列。

      以源支持的格式输入 DATE 列的值。

   1. 按顺序将每个列值数组指定为从表或视图的底部到各 next-to-top段的上边界。如果您指定的顶部边界上方存在任何行，则这些行将填充表或视图的顶部段。因此，基于范围的段的数量可能比边界数组中的段边界的数量多一个。每个这样的基于范围的段被分配到自己的线程。

      将会复制所有非 null 数据，即使您没有为表或视图中的所有列定义数据范围也是如此。

   例如，假设您为列、和定义了三个列值数组 COL1 COL2，如下 COL3 所示。    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/dms/latest/userguide/CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.html)

   您就可能为总共四个段定义了三个段边界。

   为了标识要为每个段复制的行范围，复制实例会对以下四个段中的每个段的这三个列应用搜索。搜索类似于以下内容：  
**段 1**  
在以下情况下复制所有行：前两列值小于或等于其对应**段 1** 上边界值。此外，第三列的值小于其**段 1** 上边界值。  
**段 2**  
在以下情况下复制所有行（**段 1**行除外）：前两列值小于或等于其对应**段 2 上边界值**。此外，第三列的值小于其**段 2** 上边界值。  
**段 3**  
在以下情况下复制所有行（**段 2**行除外）：前两列值小于或等于其对应**段 3 上边界值**。此外，第三列的值小于其**段 3** 上边界值。  
**段 4**  
复制所有剩余的行（除了**段 1、2 和 3** 行）。

   在这种情况下，复制实例会创建一个 `WHERE` 子句来加载每个段，如下所示：  
**段 1**  
`((COL1 < 10) OR ((COL1 = 10) AND (COL2 < 30)) OR ((COL1 = 10) AND (COL2 = 30) AND (COL3 < 105)))`  
**段 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)))`  
**段 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)))`  
**段 4**  
`NOT ((COL1 < 100) OR ((COL1 = 100) AND (COL2 < 12)) OR ((COL1 = 100) AND (COL2 = 12) AND (COL3 < 99)))`

## 为所选表或视图指定 LOB 设置
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.LOB"></a>

您可以通过使用一个或多个 `table-settings` 对象的 `lob-settings` 选项创建 `table-settings` 类型的表映射规则来为一个或多个表设置任务 LOB 设置。

以下源端点支持为所选表或视图指定 LOB 设置：
+ Oracle
+ Microsoft SQL Server
+ MySQL
+ PostgreSQL
+ IBM Db2，具体取决于 `mode` 和 `bulk-max-size` 设置，如下所述
+ SAP Adaptive Server Enterprise (ASE)，具体取决于 `mode` 和 `bulk-max-size` 设置，如下所述

以下目标端点支持为所选表或视图指定 LOB 设置：
+ Oracle
+ Microsoft SQL Server
+ MySQL
+ PostgreSQL
+ SAP ASE，具体取决于 `mode` 和 `bulk-max-size` 设置，如下所述

**注意**  
您只能将 LOB 数据类型用于包含主键的表或视图。

要对选定的表或视图使用 LOB 设置，请使用 `lob-settings` 选项创建类型为 `table-settings` 的表映射规则。这样做会指定由 `object-locator` 选项标识的表或视图的 LOB 处理。在 `table-settings` 规则中，您可以指定一个具有以下参数的 `lob-settings` 对象：
+ `mode` – 指定处理所选表或视图的 LOB 迁移的机制，如下所示：
  + `limited` – 此默认受限 LOB 模式是最快且最有效的模式。仅当您的所有端点 LOBs 都很小（大小在 100 MB 以内）或目标端点不支持无限的 LOB 大小时，才使用此模式。另外，如果您使用`limited`，则所有尺寸都 LOBs 需要在您设置的范围内`bulk-max-size`。

    在此模式下，对于满载任务，复制实例会将所有列数据类型与其他列数据类型一起以 LOBs 内联方式迁移，作为主表或视图存储的一部分。但是，实例会将大于您的 `bulk-max-size` 值的任何迁移 LOB 截断为指定的大小。对于变更数据捕获 (CDC) 加载任务，实例 LOBs 使用源表查找迁移所有内容，就像在标准的完整 LOB 模式下一样（参见以下内容）。
**注意**  
您只能为完全加载任务迁移视图。
  + `unlimited` – 完整 LOB 模式的迁移机制取决于您为 `bulk-max-size` 设置的值，如下所示：
    + **标准完整 LOB 模式** — 设置`bulk-max-size`为零时，复制实例将 LOBs 使用标准完整 LOB 模式全部迁移。此模式需要在源表或视图中进行查找，以便迁移每个 LOB，无论大小如何都是如此。此方法通常会比对于有限 LOB 模式迁移慢得多。仅当全部或大部分 LOBs 都很大（1 GB 或更大）时才使用此模式。
    + **组合完整 LOB 模式** – 如果将 `bulk-max-size` 设置为非零值，则此完整 LOB 模式使用有限 LOB 模式和标准完整 LOB 模式的组合。这适用于完全加载任务，如果 LOB 大小在您的 `bulk-max-size` 值范围内，则实例会在有限 LOB 模式下内联迁移 LOB。如果 LOB 大小大于此值，则实例使用源表或视图查找迁移 LOB，就像在标准完整 LOB 模式下一样。对于变更数据捕获 (CDC) 加载任务，实例 LOBs 使用源表查找迁移所有内容，就像在标准的完整 LOB 模式下一样（参见以下内容）。无论 LOB 大小如何，它都会这样做。
**注意**  
您只能为完全加载任务迁移视图。

      此模式导致迁移速度处于更快的有限 LOB 模式和更慢的标准完整 LOB 模式之间。只有当你混合了小号和大号并且大多数 LOBs 都很小时 LOBs，才使用此模式。

      此组合完整 LOB 模式仅适用于以下端点：
      + IBM Db2 作为源 
      + SAP ASE 作为源或目标

    无论您为`unlimited`模式指定哪种机制，实例都会 LOBs完全迁移，不会被截断。
  + `none`— 复制实例使用您的任务 LOB 设置迁移 LOBs 到选定的表或视图中。使用此选项来帮助比较对于所选表或视图，在具有和不具有 LOB 设置时的迁移结果。

  如果复制中 LOBs 包含指定的表或视图，则`true`只能在使用 `limited` LOB 模式时将`BatchApplyEnabled`任务设置设置设置为。

  在某些情况下，您可以将 `true` 设置为 `BatchApplyEnabled`，将 `BatchApplyPreserveTransaction` 设置为 `false`。在这些情况下，`true`如果表或视图有，并且源端点 LOBs 和目标终端节点都是 Oracle，则实例会设置`BatchApplyPreserveTransaction`为。
+ `bulk-max-size` – 将此值设置为零或非零值（以 KB 为单位），具体取决于 `mode`，如之前几项所述。在 `limited` 模式中，您必须为此参数设置非零值。

  实例将 LOBs 转换为二进制格式。因此，要指定需要复制的最大 LOB，请将其大小乘以 3。例如，如果您的最大 LOB 为 2 MB，请将 `bulk-max-size` 设置为 6,000 (6 MB)。

## 表设置示例
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.Examples"></a>

下面，您可以找到一些演示如何使用表设置的示例。

**Example 加载按分区分段的表**  
以下示例通过基于其所有分区并行加载源中的 `SALES` 表来更有效地加载它。  

```
{
   "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 加载按子分区分段的表**  
以下示例通过基于其所有子分区并行加载 Oracle 源中的 `SALES` 表来更有效地加载它。  

```
{
   "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 加载按分区列表分段的表**  
以下示例通过按特定分区列表并行加载源中的 `SALES` 表来加载它。在此，指定的分区以用字母的部分开头的值命名，例如 `ABCD`、`EFGH` 等等。  

```
{
    "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 加载按选定的分区和子分区列表分段的 Oracle 表**  
以下示例通过按选定分区和子分区列表并行加载 Oracle 源中的 `SALES` 表来加载它。在此，指定的分区以用字母的部分开头的值命名，例如 `ABCD`、`EFGH` 等等。指定的子分区用以数字开头的值命名，例如 `01234` 和 `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 加载按列值范围分段的表**  
以下示例通过按 `SALES_NO` 和 `REGION` 值的范围指定的段并行加载源中的 `SALES` 表来加载它。  

```
{
    "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"
                    ]
                ]
            }
        }
    ]
}
```
在此，为具有名称 `SALES_NO` 和 `REGION` 的段范围指定了两列。使用两组列值（`["1000","NORTH"]` 和 `["3000","WEST"]`）指定两个边界。  
因此，这两个边界标识要并行加载的以下三个表段：    
段 1  
`SALES_NO` 小于或等于 1000 且 `REGION` 小于“NORTH”的行。换句话说， EAST 区域最高为 1,000 的销售数量。  
段 2  
**段 1** 以外 `SALES_NO` 小于或等于 3000 且 `REGION` 小于“WEST”的行。换句话说，NORTH 和 SOUTH 区域超过 1,000 且不超过 3,000 的销售数量。  
段 3  
**段 1 ** 和**段 2** 以外的所有剩余行。换句话说，WEST 区域超过 3000 的销售数量。

**Example 加载两个表：一个按范围分段，另一个按分区分段**  
以下示例按您标识的段边界并行加载 `SALES` 表。它还通过所有分区并行加载 `ORDERS` 表，如前面的示例所示。  

```
{
    "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 LOBs 使用任务 LOB 设置加载表**  
以下示例使用其任务 LOB 设置在源代码中加载一个`ITEMS`表（包括所有 LOBs表）。100 MB 的 `bulk-max-size` 设置会被忽略，仅用于快速重置为 `limited` 或 `unlimited` 模式。  

```
{
   "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 LOBs 使用受限 LOB 模式加载表**  
以下示例使用受限 LOB 模式（默认）加载源 LOBs中包含的`ITEMS`表，最大未截断大小为 100 MB。任何 LOBs 大于此大小的内容都将被截断为 100 MB。所有列数据类型 LOBs 都与所有其他列数据类型一起内联加载。  

```
{
   "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 LOBs 使用标准完整 LOB 模式加载表**  
以下示例使用标准的完整 LOB 模式在源代码中加载一个`ITEMS`表，包括所有 LOBs 没有截断的表。无论大小如何 LOBs，都与其他数据类型分开加载，使用对源表中的每个 LOB 进行查找。  

```
{
   "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 LOBs 使用组合完整 LOB 模式加载表格**  
以下示例使用组合完整 LOB 模式在源代码中加载一个`ITEMS`表，包括所有 LOBs 没有截断的表。所有大小 LOBs 在 100 MB 以内的数据都与其他数据类型一起以内联方式加载，就像在有限的 LOB 模式下一样。所有大小 LOBs 超过 100 MB 的数据都是与其他数据类型分开加载的。此单独加载为源表中的每个此类 LOB 使用一个查找，类似于标准的完整 LOB 模式中。  

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

# 使用数据掩蔽隐藏敏感信息
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Masking"></a>

要隐藏存储在所迁移的表的一列或多列中的敏感数据，可以利用数据掩蔽转换规则操作。从 3.5.4 版本开始， AWS DMS 允许在表映射中使用数据屏蔽转换规则操作，使您能够在迁移过程中更改一列或多列的内容。 AWS DMS 将修改后的数据加载到目标表中。

AWS Database Migration Service 为数据屏蔽转换规则操作提供了三个选项：
+ 数据掩蔽：数字掩码
+ 数据掩蔽：数字随机化
+ 数据掩蔽：哈希掩码

与其他转换规则类似，可以在复制任务的表映射中配置这些数据掩蔽转换规则操作。规则目标应设置为列级别。

## 使用掩码字符掩盖列数据中的数字
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Masking.Numbers"></a>

“数据掩蔽：数字掩码”转换规则操作允许您使用所指定的单个 ASCII 可打印字符（不包括空字符或空格字符）替换数字，从而掩盖一列或多列中的数值数据。

以下示例使用掩码字符 `'#'` 掩盖 `customer_master` 表 `cust_passport_no` 列中的所有数字，并将掩蔽的数据加载到目标表中：

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

例如，如果源表`cust_passport_no`中的列包含记录 “C6 BGJ566669 K”，则 AWS DMS 任务会将此数据写入目标表。`"C#BGJ######K"`

## 用随机数字替换列中的数字
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Masking.Random"></a>

转换规则“数据掩蔽：数字随机化”允许您将一列或多列中的每个数字替换为随机数字。在以下示例中， AWS DMS 用随机数替换源表`cust_passport_no``customer_master`列中的每个数字，并将修改后的数据写入目标表：

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

例如，该 AWS DMS 任务会将源表`cust_passport_no`列`"C6BGJ566669K"`中的值转换为目标数据库`"C1BGJ842170K"`并将其写入目标数据库。

## 用哈希值替换列数据
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Masking.Hash"></a>

转换规则“数据掩蔽：哈希掩码”允许您将列数据替换为使用 `SHA256` 算法生成的哈希值。哈希值的长度将始终为 64 个字符，因此目标表列的长度应至少为 64 个字符。或者，您可以向列添加 `change-data-type` 转换规则操作，以增加目标表中列的长度。

以下示例为源表 `customer_master` `cust_passport_no` 列中的数据生成一个 64 个字符长的哈希值，并在增加列长后将转换后的数据加载到目标表：

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

例如，如果源表`cust_passport_no`的列包含值`“C6BGJ566669K”`，则 t AWS DMS ask 将`“7CB06784764C9030CCC41E25C15339FEB293FFE9B329A72B5FED564E99900C75”`向目标表写入哈希。

## 限制
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Masking.Limitations"></a>
+ 每个数据屏蔽转换规则选项仅支持特定 AWS DMS 数据类型：
  + 数据掩蔽：数字掩码支持 `WSTRING` 和 `STRING` 数据类型的列。
  + 数据掩蔽：数字随机化支持 `WSTRING, STRING; NUMERIC, INT1, INT2, INT4, and INT8 ` 数据类型及其对应的无符号数据类型的列。
  + 数据掩蔽：哈希掩码支持 `WSTRING` 和 `STRING` 数据类型的列。

  要详细了解如何将 AWS DMS 数据类型映射到源引擎的数据类型，请参阅源引擎与数据类型的 AWS DMS 数据类型映射。请参阅 [Oracle 的源数据类型](CHAP_Source.Oracle.md#CHAP_Source.Oracle.DataTypes)、[SQL Server 的源数据类型](CHAP_Source.SQLServer.md#CHAP_Source.SQLServer.DataTypes)、[PostgreSQL 的源数据类型](CHAP_Source.PostgreSQL.md#CHAP_Source-PostgreSQL-DataTypes) 和 [MySQL 的源数据类型](CHAP_Source.MySQL.md#CHAP_Source.MySQL.DataTypes) 的源数据类型。
+ 对数据类型不兼容的列使用数据掩蔽规则操作会导致 DMS 任务出错。要 DataMaskingErrorPolicy 指定错误处理行为，请参阅 DMS 任务设置。有关 `DataMaskingErrorPolicy`的更多信息，请参阅[错误处理任务设置](CHAP_Tasks.CustomizingTasks.TaskSettings.ErrorHandling.md)。
+ 如果您计划使用的掩码选项不支持您的源列类型，则可以添加 change-data-type转换规则操作，将列的数据类型更改为兼容类型。`change-data-type` 转换的 `rule-id` 数字应该是一个比掩码转换的规则 ID 更小的数字，以便在掩蔽之前进行数据类型更改。
+ 建议对主键/唯一键/外键列使用“数据掩蔽：哈希掩码”操作，因为生成的哈希值将是唯一且一致的。其他两个掩码选项不能保证唯一性。
+ 虽然“数据掩蔽：数字掩码”和“数据掩蔽：数字随机化”仅影响列数据中的数字，而不影响数据长度，但“数据掩蔽：哈希掩码”会修改整列，数据长度更改为 64 个字符。因此，应相应地创建要创建的目标表或为被屏蔽的列添加 change-data-type转换规则。
+ 在 AWS DMS中，指定了数据掩蔽转换规则操作的列将从数据验证中排除。如果主键/唯一键列被掩码，则此表的数据验证将不会运行；此类表的验证状态将显示为 `No Primary key`。