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

# 表和集合设置规则和操作
<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"
            }
        }
     ]
}
```