Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Uso del mapeo de tablas para especificar la configuración de tareas
La correspondencia de tablas utiliza diversos tipos de reglas para especificar el origen de datos, el esquema origen, los datos y las transformaciones que deben producirse durante la tarea. Puede utilizar la correspondencia de tablas para especificar las tablas individuales en una base de datos que se van a migrar y el esquema que se va a utilizar en la migración.
Al trabajar con el mapeo de tablas, puede utilizar filtros para especificar los datos que desea replicar a partir de columnas de tabla. Además, puede utilizar transformaciones para modificar esquemas, tablas o vistas seleccionados antes de que se escriban en la base de datos de destino.
**Topics**
+ [
# Especificación de selección de tablas y reglas de transformaciones desde la consola
](CHAP_Tasks.CustomizingTasks.TableMapping.Console.md)
+ [
# Especificación de reglas de selección de tablas y transformaciones mediante JSON
](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.md)
+ [
# Reglas y acciones de selección
](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Selections.md)
+ [
# Comodines en la asignación de tablas
](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Wildcards.md)
+ [
# Reglas y acciones de transformación
](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Transformations.md)
+ [
# Uso de expresiones de regla de transformación para definir el contenido de columnas
](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions.md)
+ [
# Reglas y operaciones de configuración de tablas y recopilaciones
](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.md)
+ [
# Uso del enmascaramiento de datos para ocultar información confidencial
](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Masking.md)
**nota**
Al trabajar con la asignación de tablas para un punto de conexión de origen de MongoDB, puede usar filtros para especificar los datos que desea replicar y especificar un nombre de base de datos en lugar de `schema_name`. O puede usar el `"%"` predeterminado.
# Especificación de selección de tablas y reglas de transformaciones desde la consola
Puede usarlo Consola de administración de AWS para realizar el mapeo de tablas, incluida la especificación de la selección y las transformaciones de las tablas. En la consola, utilice la sección **Where (Dónde)** para especificar el esquema, la tabla y la acción (incluir o excluir). Utilice la sección **Filter (Filtro)** para especificar el nombre de la columna en una tabla y las condiciones que desea aplicar a una tarea de replicación. En su conjunto, estas dos acciones crean una regla de selección.
Puede incluir transformaciones en una correspondencia de tablas después de que haya especificado al menos una regla de selección. Puede utilizar transformaciones para cambiar el nombre de un esquema o tabla, añadir prefijos o sufijos a un esquema o tabla o eliminar una columna de la tabla.
**nota**
AWS DMS no admite más de una regla de transformación por nivel de esquema, nivel de tabla o nivel de columna.
El siguiente procedimiento muestra cómo configurar reglas de selección basadas en una tabla llamada **Customers** en un esquema llamado **EntertainmentAgencySample**.
**Para especificar una tabla de selección, filtre los criterios y las transformaciones con la consola**
1. Inicie sesión en la AWS DMS consola Consola de administración de AWS y ábrala en la versión [https://console.aws.amazon.com/dms/v2/](https://console.aws.amazon.com/dms/v2/).
Si ha iniciado sesión como usuario de IAM, asegúrese de que dispone de los permisos adecuados para acceder a AWS DMS. Para obtener más información sobre los permisos que se necesitan, consulte [Se necesitan permisos de IAM para utilizarlos AWS DMS](security-iam.md#CHAP_Security.IAMPermissions).
1. En la página del **panel**, elija **Tareas de migración de bases de datos**.
1. Seleccione **Create Task**.
1. En la sección **Configuración de tareas**, ingrese la información de la tarea, incluido el **Identificador de la tarea**, la **Instancia de replicación**, el **Punto de conexión de la base de datos de origen**, el **Punto de conexión de la base de datos de destino** y el **Tipo de migración**.
![\[Selección de esquemas y tablas\]](http://docs.aws.amazon.com/es_es/dms/latest/userguide/images/datarep-create-task-20.png)
1. En la sección **Asignación de tablas**, ingrese el nombre del esquema y el nombre de la tabla. Puede utilizar “%” como un valor comodín cuando especifique el nombre del esquema o el nombre de la tabla. Para obtener información sobre otros comodines que puede utilizar, consulte [Comodines en la asignación de tablas](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Wildcards.md). Especifique la acción que va a emprender, para incluir o excluir los datos que definió el filtro.
![\[Selección de esquemas y tablas\]](http://docs.aws.amazon.com/es_es/dms/latest/userguide/images/datarep-Tasks-selecttransfrm.png)
1. Especifique la información del filtro mediante los enlaces **Add column filter (Añadir filtro de columna)** y **Add condition (Añadir condición)**.
1. Elija **Add column filter (Añadir filtro de columna)** para especificar una columna y las condiciones.
1. Elija **Add condition (Añadir condición)** para añadir otras condiciones adicionales.
El siguiente ejemplo muestra un filtro para la tabla **Customers** que incluye **AgencyIDs** entre **01** y **85**.
![\[Selección de esquemas y tablas\]](http://docs.aws.amazon.com/es_es/dms/latest/userguide/images/datarep-Tasks-filter.png)
1. Cuando haya creado las selecciones que desee, elija **Agregar regla de selección nueva**.
1. Una vez que haya creado al menos una regla de selección, puede añadir una transformación a la tarea. Elija **Add transformation rule (Añadir regla de transformación)**.
![\[regla de transformación\]](http://docs.aws.amazon.com/es_es/dms/latest/userguide/images/datarep-Tasks-transform1.png)
1. Elija el destino que desea transformar e introduzca la información adicional solicitada. El siguiente ejemplo muestra una transformación que elimina la columna **AgencyStatus** de la tabla **Customer**.
![\[regla de transformación\]](http://docs.aws.amazon.com/es_es/dms/latest/userguide/images/datarep-Tasks-transform2.png)
1. Elija **Add transformation rule**.
1. Seleccione **Crear tarea**.
**nota**
AWS DMS no admite más de una regla de transformación por nivel de esquema, nivel de tabla o nivel de columna.
# Especificación de reglas de selección de tablas y transformaciones mediante JSON
Para especificar las asignaciones de tabla que desea aplicar durante la migración, puede crear un archivo JSON. Si crea una tarea de migración mediante la consola, puede buscar este archivo JSON o introducir el JSON directamente en el cuadro de asignación de tablas. Si utiliza la CLI o la API para realizar migraciones, puede especificar este archivo mediante el parámetro `TableMappings` de la operación `CreateReplicationTask` o `ModifyReplicationTask` de la API.
AWS DMS solo puede procesar archivos JSON de mapeo de tablas con un tamaño máximo de 2 MB. Le recomendamos que mantenga el tamaño del archivo JSON de la regla de asignación por debajo del límite de 2 MB mientras trabaja con tareas de DMS. Esto evita errores inesperados durante la creación o modificación de la tarea. Cuando un archivo de reglas de asignación supera el límite de 2 MB, le recomendamos que divida las tablas en varias tareas para reducir el tamaño del archivo de reglas de asignación de manera que se mantenga por debajo de este límite.
Puede especificar con qué tablas, vistas y esquemas desea trabajar. También puede realizar transformaciones de tablas, vistas y esquemas y especificar la configuración de cómo AWS DMS carga tablas y vistas individuales. Puede crear reglas de mapeo de tablas para estas opciones utilizando los siguientes tipos de reglas:
+ Reglas de `selection`: identifique los tipos y nombres de las tablas, vistas y esquemas de origen que se van a cargar. Para obtener más información, consulte [Reglas y acciones de selección](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Selections.md).
+ Reglas de `transformation`: especifique determinados cambios o adiciones en tablas y esquemas de origen concretos en el origen antes de cargarlos en el destino. Para obtener más información, consulte [Reglas y acciones de transformación](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Transformations.md).
Además, para definir el contenido de las columnas nuevas y existentes, puede utilizar una expresión dentro de una regla de transformación. Para obtener más información, consulte [Uso de expresiones de regla de transformación para definir el contenido de columnas](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions.md).
+ Reglas de `table-settings`: especifique cómo las tareas de DMS cargan los datos de tablas individuales. Para obtener más información, consulte [Reglas y operaciones de configuración de tablas y recopilaciones](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.md).
**nota**
Para destinos de Amazon S3, también puede etiquetar los objetos de S3 asignados a tablas y esquemas seleccionados utilizando el tipo de regla `post-processing` y la acción de regla `add-tag`. Para obtener más información, consulte [Etiquetado de objetos de Amazon S3](CHAP_Target.S3.md#CHAP_Target.S3.Tagging).
Para los siguientes destinos, puede especificar cómo y dónde se migran al destino los esquemas y las tablas seleccionados mediante el tipo de regla `object-mapping`:
Amazon DynamoDB: para obtener más información, consulte [Uso de la asignación de objetos para migrar datos a DynamoDB](CHAP_Target.DynamoDB.md#CHAP_Target.DynamoDB.ObjectMapping).
Amazon Kinesis: para obtener más información, consulte [Uso de la asignación de objetos para migrar datos a un flujo de datos de Kinesis](CHAP_Target.Kinesis.md#CHAP_Target.Kinesis.ObjectMapping).
Apache Kafka: para obtener más información, consulte [Uso de la asignación de objetos para migrar datos a un tema de Kafka](CHAP_Target.Kafka.md#CHAP_Target.Kafka.ObjectMapping).
# Reglas y acciones de selección
Si utiliza la correspondencia de tablas, vistas y esquemas puede especificar con qué tablas o esquemas desea trabajar mediante el uso de reglas de selección y acciones. Para las reglas de correspondencia de tablas utilice el tipo de regla de selección; puede aplicar los valores siguientes.
**aviso**
No incluya ningún dato confidencial en estas reglas.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/dms/latest/userguide/CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Selections.html)
**Example Migrar todas las tablas de un esquema**
El siguiente ejemplo migra todas las tablas desde un esquema denominado `Test` en el origen al punto de enlace de destino.
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "Test",
"table-name": "%"
},
"rule-action": "include"
}
]
}
```
**Example Migrar algunas tablas de un esquema**
En el siguiente ejemplo, se migran todas las tablas excepto aquellas que comienzan con `DMS` desde un esquema llamado `Test` en el origen hasta el punto de enlace de destino.
```
{
"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 Migrar una única tabla especificada de un solo esquema**
El siguiente ejemplo migra la tabla `Customer` desde el esquema `NewCust` en el origen al punto de enlace de destino.
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "NewCust",
"table-name": "Customer"
},
"rule-action": "explicit"
}
]
}
```
Puede seleccionar de forma explícita en varias tablas y esquemas especificando varias reglas de selección.
**Example Migrar tablas en un orden establecido**
Las tablas y vistas se migran según sus valores de orden de carga. Además, los valores más altos tienen prioridad en la secuencia de migración. En el siguiente ejemplo, se migran dos tablas: `loadfirst` con un valor de prioridad de 2 y `loadsecond` con un valor de prioridad de 1. La tarea de migración procesaría primero la tabla `loadfirst` antes de continuar con la tabla `loadsecond`. Este mecanismo de priorización garantiza que se respeten las dependencias entre los objetos de la base de datos durante el proceso de migración.
```
{
"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"
}
]
}
```
**nota**
`load-order` es aplicable para la inicialización de tablas. La carga de una tabla sucesiva no esperará a que se complete la carga de la tabla anterior si `MaxFullLoadSubTasks` es superior a 1.
**Example Migrar algunas vistas de un esquema**
En el siguiente ejemplo se migran algunas vistas de un esquema denominado `Test` en el origen a tablas equivalentes en el destino.
```
{
"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 Migrar todas las tablas y vistas de un esquema**
En el siguiente ejemplo se migran todas las tablas y vistas de un esquema denominado `report` en el origen a tablas equivalentes en el destino.
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "3",
"rule-name": "3",
"object-locator": {
"schema-name": "report",
"table-name": "%",
"table-type": "all"
},
"rule-action": "include"
}
]
}
```
# Comodines en la asignación de tablas
En esta sección se describen los comodines que puede utilizar al especificar los nombres de esquemas y tablas para la asignación de tablas.
| Comodín | Coincide |
| --- |--- |
| % | Cero o más personajes |
| \$1 | Un solo personaje |
| [\$1] | Un carácter de subrayado literal |
| [ab] | Un conjunto de personajes. Por ejemplo, [ab] coincide con 'a' o 'b'. |
| [a-d] | Variedad de personajes. Por ejemplo, [a-d] coincide con 'a', 'b', 'c' o 'd'. |
Para los puntos de conexión de origen y destino de Oracle, puede utilizar el atributo de conexión adicional `escapeCharacter` para especificar un carácter de escape. Un carácter de escape le permite utilizar un carácter comodín específico en las expresiones como si no fuera comodín. Por ejemplo, `escapeCharacter=#` le permite usar “\$1” para hacer que un carácter comodín actúe como un carácter normal en una expresión, como en este código de ejemplo.
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "542485267",
"rule-name": "542485267",
"object-locator": { "schema-name": "ROOT", "table-name": "TEST#_T%" },
"rule-action": "include",
"filters": []
}
]
}
```
En este caso, el carácter de escape «\$1» hace que el carácter comodín «\$1» actúe como un carácter normal. AWS DMS selecciona las tablas del esquema denominado`ROOT`, donde cada tabla tiene un nombre `TEST_T` como prefijo.
# Reglas y acciones de transformación
Puede utilizar las acciones de transformación para especificar las transformaciones que desea aplicar al esquema, la tabla o la vista seleccionados. Las reglas de transformación son opcionales.
## Limitaciones
+ No puede aplicar más de una acción de regla de transformación al mismo objeto (esquema, tabla, columna, tabla-espacio de tabla o índice-espacio de tabla). Puede aplicar varias acciones de reglas de transformación en cualquier nivel, siempre que cada acción de transformación se aplique a un objeto diferente. Sin embargo, esta restricción no se aplica cuando se utilizan reglas de transformación de enmascaramiento de datos en las que se puede realizar otra transformación como `ADD-COLUMN` o `CHANGE-DATA-TYPE` para la misma columna.
+ Los nombres de las tablas y los nombres de las columnas en las reglas de transformación distinguen entre mayúsculas y minúsculas. Por ejemplo, debe proporcionar los nombres de las tablas y los nombres de las columnas de una base de datos Oracle o Db2 en mayúsculas.
+ Los nombres de columnas con Right-to-Left idiomas no admiten transformaciones.
+ Las transformaciones no se pueden realizar en columnas que contengan caracteres especiales (por ejemplo, \$1, \$1, /, -) en el nombre.
+ La única transformación que se admite para las columnas asignadas a tipos de BLOB/CLOB datos es colocar la columna en el destino.
+ AWS DMS no admite la replicación de dos tablas de origen en una sola tabla de destino. AWS DMS replica los registros de una tabla a otra y de una columna a otra, de acuerdo con las reglas de transformación de la tarea de replicación. Los nombres de los objetos deben ser únicos para evitar que se superpongan.
Por ejemplo, una tabla de origen tiene una columna denominada `ID` y la tabla de destino correspondiente tiene una columna preexistente denominada `id`. Si una regla utiliza una `ADD-COLUMN` sentencia para añadir una nueva columna denominada `id` y otra para rellenar la columna con valores personalizados, se crea un objeto duplicado y ambiguo denominado `id` y no se admite. SQLite
+ Al crear una regla de transformación, se recomienda usar el parámetro `data-type` solo cuando las reglas de selección especifiquen varias columnas, por ejemplo, cuando establece `column-name` en `%`. No se recomienda usar `data-type` para seleccionar una sola columna.
+ AWS DMS no admite reglas de transformación en las que los objetos de origen y destino (tablas) se encuentran en la misma base de datos o esquema. Usar la misma tabla como origen y destino en una regla de transformación puede generar resultados inesperados y potencialmente perjudiciales, como, por ejemplo, alteraciones involuntarias de los datos de la tabla, modificaciones de las estructuras de tabla o incluso la eliminación de tablas.
## Valores
Para las reglas de correspondencia de tablas utilice el tipo de regla de transformación; se pueden aplicar los valores siguientes.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/dms/latest/userguide/CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Transformations.html)
## Ejemplos
**Example Cambiar el nombre a un esquema**
En el siguiente ejemplo, se cambia el nombre de un esquema de `Test` en el origen a `Test1` en el destino.
```
{
"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 Cambiar el nombre a una tabla**
En el siguiente ejemplo, se cambia el nombre de una tabla de `Actor` en el origen a `Actor1` en el destino.
```
{
"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 Cambiar el nombre de una columna**
En el siguiente ejemplo, se cambia el nombre de una columna en una tabla `Actor` de `first_name` en el origen a `fname` en el destino.
```
{
"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 Cambiar el nombre a un espacio de tabla de tabla de Oracle**
En el siguiente ejemplo se cambia el nombre del espacio de tabla de tabla denominado `SetSpace` para una tabla denominada `Actor` en su origen de Oracle a `SceneTblSpace` en su punto de enlace de destino de Oracle.
```
{
"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 Cambiar el nombre a un espacio de tabla de índice de Oracle**
En el siguiente ejemplo se cambia el nombre del espacio de tabla de índice denominado `SetISpace` para una tabla denominada `Actor` en su origen de Oracle a `SceneIdxSpace` en su punto de enlace de destino de Oracle.
```
{
"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 Agregar una columna**
En el ejemplo siguiente se agrega una columna `datetime` a la tabla `Actor` en el esquema `test`.
```
{
"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 Quitar una columna**
En el siguiente ejemplo, se transforma la tabla denominada `Actor` en el origen para que se quiten todas las columnas que empiecen por los caracteres `col` en el destino.
```
{
"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 Cambiar a minúsculas**
En el siguiente ejemplo, se convierte el nombre de una tabla de `ACTOR` en el origen a `actor` en el destino.
```
{
"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 Cambiar a mayúsculas**
En el siguiente ejemplo, se cambian todas las columnas de todas las tablas y todos los esquemas de minúsculas en el origen a mayúsculas en el destino.
```
{
"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 Agregar un prefijo**
En el siguiente ejemplo se transforman todas las tablas en el origen para añadirles el prefijo `DMS_` en el destino.
```
{
"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 Sustituir un prefijo**
En el siguiente ejemplo, se transforman todas las columnas que contienen el prefijo `Pre_` en el origen y se sustituye por `NewPre_` en el destino.
```
{
"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 Quitar un sufijo**
En el siguiente ejemplo, se transforman todas las tablas en el origen para quitarles el sufijo `_DMS` en el destino.
```
{
"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 Definir una clave principal**
En el siguiente ejemplo se define una clave principal denominada `ITEM-primary-key` en tres columnas de la tabla `ITEM` migrada a su punto de enlace de destino.
```
{
"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 Definir un índice único**
En el siguiente ejemplo se define un índice único denominado `ITEM-unique-idx` en tres columnas de la tabla `ITEM` migrada a su punto de enlace de destino.
```
{
"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 Cambiar el tipo de datos de la columna de destino**
En el ejemplo siguiente se cambia el tipo de datos de una columna de destino denominada `SALE_AMOUNT` de un tipo de datos existente a `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 Agregar una columna de imagen anterior**
En una columna de origen denominada `emp_no`, la regla de transformación del siguiente ejemplo agrega una nueva columna llamada `BI_emp_no` en el destino.
```
{
"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"
}
}
]
}
```
Aquí, la siguiente instrucción rellena una columna `BI_emp_no` de la fila correspondiente con 1.
```
UPDATE employees SET emp_no = 3 WHERE BI_emp_no = 1;
```
Al escribir las actualizaciones de los CDC sobre los AWS DMS objetivos admitidos, la `BI_emp_no` columna permite saber qué filas tienen valores actualizados en la `emp_no` columna.
# Uso de expresiones de regla de transformación para definir el contenido de columnas
Para definir contenido para columnas nuevas y existentes, puede utilizar una expresión dentro de una regla de transformación. Por ejemplo, mediante expresiones puede agregar una columna o replicar encabezados de tabla de origen a un destino. También puede utilizar expresiones para marcar registros en tablas de destino como insertados, actualizados o eliminados en el origen.
**Topics**
+ [
## Agregar una columna mediante una expresión
](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-adding)
+ [
## Marcar registros de destino mediante una expresión
](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-Flagging)
+ [
## Replicación de encabezados de tablas de origen mediante expresiones
](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-Headers)
+ [
## Uso de SQLite funciones para crear expresiones
](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-SQLite)
+ [
## Agregar metadatos a una tabla de destino mediante expresiones
](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-Metadata)
## Agregar una columna mediante una expresión
Para agregar columnas a tablas mediante una expresión en una regla de transformación, utilice una acción de regla `add-column` y un destino de regla `column`.
En el ejemplo siguiente se agrega una nueva columna a la tabla `ITEM`. Establece el nuevo nombre de columna en `FULL_NAME`, con un tipo de datos de `string`, 50 caracteres de longitud. La expresión concatena los valores de dos columnas existentes, `FIRST_NAME` y `LAST_NAME`, para evaluar `FULL_NAME`. Los parámetros `schema-name`, `table-name` y de expresión hacen referencia a los objetos de la tabla de la base de datos de origen. `Value` y el bloque `data-type` hacen referencia a los objetos en la tabla de la base de datos de destino.
```
{
"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
}
}
]
}
```
## Marcar registros de destino mediante una expresión
Para marcar los registros de las tablas de destino como insertados, actualizados o eliminados en la tabla de origen, utilice una expresión en una regla de transformación. La expresión utiliza una función `operation_indicator` para marcar registros. Los registros eliminados del origen no se eliminan del destino. En su lugar, el registro de destino se marca con un valor proporcionado por el usuario para indicar que se eliminó del origen.
**nota**
La función `operation_indicator` solo funciona en tablas que tienen una clave principal en la base de datos de origen y destino.
Por ejemplo, la siguiente regla de transformación agrega primero una nueva columna `Operation` a una tabla de destino. A continuación, actualiza la columna con el valor `D` cada vez que se elimina un registro de una tabla de origen.
```
{
"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
}
}
```
## Replicación de encabezados de tablas de origen mediante expresiones
De forma predeterminada, los encabezados de las tablas de origen no se replican en el destino. Para indicar qué encabezados replicar, utilice una regla de transformación con una expresión que incluya el encabezado de columna de tabla.
Puede utilizar los siguientes encabezados de columna en expresiones.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/dms/latest/userguide/CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions.html)
En el ejemplo siguiente se agrega una nueva columna al destino mediante el valor de posición de flujo del origen. Para SQL Server, el valor de posición de flujo es el LSN para el punto de conexión de origen. Para Oracle, el valor de posición de flujo es el SCN para el punto de conexión de origen.
```
{
"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
}
}
```
El siguiente ejemplo agrega una nueva columna al destino que tiene un número creciente único del origen. Este valor representa un número único de 35 dígitos en el nivel de tarea. Los primeros 16 dígitos forman parte de una marca temporal y los últimos 19 dígitos son el número record\$1id incrementado por DBMS.
```
{
"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
}
}
```
## Uso de SQLite funciones para crear expresiones
Puede utilizar table-settings para especificar cualquier configuración que desee aplicar a la tabla o vista seleccionada para una operación específica. Las reglas de table-settings son opcionales.
**nota**
En lugar del concepto de tablas y vistas, las bases de datos MongoDB y DocumentDB almacenan los registros de datos como documentos que se agrupan en *recopilaciones*. Por lo tanto, al migrar desde un origen de MongoDB o DocumentDB, considere el tipo de segmentación por rango de la configuración de carga paralela para *recopilaciones* seleccionadas en lugar de tablas y vistas.
**Topics**
+ [
### Uso de una expresión CASE
](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-SQLite.CASE)
+ [
### Ejemplos
](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-SQLite.Ex)
A continuación, encontrará funciones de cadena que puede utilizar para crear expresiones de reglas de transformación.
| Funciones de cadena | Description (Descripción) |
| --- | --- |
| `lower(x)` | La función `lower(x)` devuelve una copia de la cadena *`x`* con todos los caracteres convertidos a minúsculas. La función `lower` integrada de forma predeterminada solo funciona con caracteres ASCII. |
| `upper(x)` | La función `upper(x)` devuelve una copia de la cadena *`x`* con todos los caracteres convertidos a mayúsculas. La función `upper` integrada de forma predeterminada solo funciona con caracteres ASCII. |
| `ltrim(x,y)` | La función `ltrim(x,y)` devuelve una cadena formada al eliminar todos los caracteres que aparecen en y desde el lado izquierdo de x. Si no hay ningún valor para y, `ltrim(x)` elimina los espacios del lado izquierdo de x. |
| `replace(x,y,z)` | La función `replace(x,y,z)` devuelve una cadena formada al sustituir la cadena z por cada aparición de la cadena y en la cadena x. |
| `rtrim(x,y)` | La función `rtrim(x,y)` devuelve una cadena formada al eliminar todos los caracteres que aparecen en y desde el lado derecho de x. Si no hay ningún valor para y, `rtrim(x)` elimina los espacios del lado derecho de x. |
| `substr(x,y,z)` | La función `substr(x,y,z)` devuelve una subcadena de la cadena de entrada `x` que comienza con el carácter `y` y que tiene una longitud de *`z`* caracteres. Si *`z`* se omite, `substr(x,y)` devuelve todos los caracteres hasta el final de la cadena que `x` comienza por el carácter `y`. El carácter situado más a la izquierda de `x` es el número 1. Si *`y`* es negativo, el primer carácter de la subcadena se encuentra contando desde la derecha y no desde la izquierda. Si *`z`* es negativo, se devuelven los caracteres `abs(z)` que preceden al carácter `y`. Si `x` es una cadena, los índices de los caracteres se refieren a los caracteres UTF-8 reales. Si `x` es un BLOB, los índices se refieren a bytes. |
| trim(x,y) | La función `trim(x,y)` devuelve una cadena formada al eliminar todos los caracteres que aparecen en `y` desde ambos lados de `x`. Si no hay ningún valor para `y`, `trim(x)` elimina los espacios desde ambos lados de `x`. |
A continuación, puede encontrar funciones de LOB que puede utilizar para crear expresiones de reglas de transformación.
| Funciones de LOB | Description (Descripción) |
| --- | --- |
| `hex(x)` | La función `hex` recibe un BLOB como argumento y devuelve una versión de cadena hexadecimal en mayúscula del contenido del BLOB. |
| `randomblob (N)` | La función `randomblob(N)` devuelve un BLOB de `N` bytes que contiene bytes pseudoaleatorios. Si *N* es menor que 1, se devuelve un BLOB aleatorio de 1 byte. |
| `zeroblob(N)` | La función `zeroblob(N)` devuelve un BLOB que consta de `N` bytes de 0x00. |
A continuación, puede encontrar funciones numéricas que puede utilizar para crear expresiones de reglas de transformación.
| Funciones numéricas | Description (Descripción) |
| --- | --- |
| `abs(x)` | La función `abs(x)` devuelve el valor absoluto del argumento numérico `x`. La `abs(x)` función devuelve NULL si *x* es NULL. La `abs(x)` función devuelve 0.0 si **x** es una cadena o un BLOB que no se puede convertir en un valor numérico. |
| `random()` | La función `random` devuelve un entero pseudoaleatorio comprendido entre -9,223,372,036,854,775,808 y \$19,223,372,036,854,775,807. |
| `round (x,y)` | La `round (x,y)` función devuelve un valor de punto flotante *x* redondeado a *y* dígitos a la derecha de la coma decimal. Si no hay ningún valor para*y*, se supone que es 0. |
| `max (x,y...)` | La función `max` de multiargumento devuelve el argumento con el valor máximo o devuelve NULL si algún argumento es NULL. La función `max` busca en sus argumentos de izquierda a derecha un argumento que defina una función de clasificación. Si encuentra uno, utiliza esa función de clasificación para todas las comparaciones de cadenas. Si ninguno de los argumentos en `max` define una función de clasificación, se utiliza la función de clasificación `BINARY`. La función `max` es simple cuando tiene dos o más argumentos, pero funciona como una función agregada si tiene un solo argumento. |
| `min (x,y...)` | La función `min` multiargumento devuelve el argumento con el valor mínimo. La función `min` busca en sus argumentos de izquierda a derecha un argumento que defina una función de clasificación. Si encuentra uno, utiliza esa función de clasificación para todas las comparaciones de cadenas. Si ninguno de los argumentos en `min` define una función de clasificación, se utiliza la función de clasificación `BINARY`. La función `min` es simple cuando tiene dos o más argumentos, pero funciona como una función agregada si tiene un solo argumento. |
A continuación, puede encontrar funciones de comprobación NULL que puede utilizar para crear expresiones de reglas de transformación.
| Funciones de comprobación NULL | Description (Descripción) |
| --- | --- |
| `coalesce (x,y...)` | La función `coalesce` devuelve una copia de su primer argumento distinto de NULL, pero devuelve NULL si todos los argumentos son NULL. La función de unión tiene al menos dos argumentos. |
| `ifnull(x,y)` | La función `ifnull` devuelve una copia del primer argumento distinto de NULL, pero devuelve NULL si todos los argumentos son NULL. La función `ifnull` tiene exactamente dos argumentos. La función `ifnull` es la misma que `coalesce` con dos argumentos. |
| `nullif(x,y)` | La función `nullif(x,y)` devuelve una copia del primer argumento si los argumentos son diferentes, pero devuelve NULL si los argumentos son iguales. La función `nullif(x,y)` busca en sus argumentos de izquierda a derecha un argumento que defina una función de clasificación. Si encuentra uno, utiliza esa función de clasificación para todas las comparaciones de cadenas. Si ninguno de los argumentos en nullif define una función de clasificación, se utiliza la función de clasificación `BINARY`. |
A continuación, puede encontrar funciones de fecha y hora que puede utilizar para crear expresiones de reglas de transformación.
| Funciones de fecha y hora | Description (Descripción) |
| --- | --- |
| `date(timestring, modifier, modifier...)` | La `date` función devuelve la fecha en el formato YYYY-MM-DD. |
| `time(timestring, modifier, modifier...)` | La función `time` devuelve la hora en el formato HH:MM:SS. |
| `datetime(timestring, modifier, modifier...)` | La `datetime` función devuelve la fecha y la hora en el formato YYYY-MM-DD HH:MM:SS. |
| `julianday(timestring, modifier, modifier...)` | La función `julianday` devuelve el número de días transcurridos desde el mediodía en Greenwich el 24 de noviembre de 4714 a. C. |
| `strftime(format, timestring, modifier, modifier...)` | La función `strftime` devuelve la fecha según la cadena de formato especificada como primer argumento y utiliza una de las siguientes variables: `%d`: día del mes `%H`: hora 00-24 `%f`: \$1\$1 fracciones de segundo SS.SSS `%j`: día del año de 001 a 366 `%J`: \$1\$1 número de día juliano `%m`: mes 01-12 `%M`: minuto 00-59 `%s`: segundos desde 1970-01-01 `%S`: segundos 00-59 `%w`: día de la semana 0–6 domingo==0 `%W`: semana del año 00-53 `%Y`: año 0000-9999 `%%`: % |
A continuación, puede encontrar una función de inserción que puede utilizar para crear expresiones de reglas de transformación.
| Función de inserción | Description (Descripción) |
| --- | --- |
| `hash_sha256(x)` | La función `hash` genera un valor de inserción para una columna de entrada (mediante el algoritmo SHA-256) y devuelve el valor hexadecimal del valor de inserción generado. Para usar la función `hash` en una expresión, agregue `hash_sha256(x)` a la expresión y sustituya *`x`* por el nombre de la columna de origen. |
### Uso de una expresión CASE
La SQLite `CASE` expresión evalúa una lista de condiciones y devuelve una expresión basada en el resultado. La sintaxis se muestra a continuación.
```
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
```
### Ejemplos
**Example de agregar una nueva columna de cadenas a la tabla de destino mediante una condición que distingue entre mayúsculas y minúsculas**
La siguiente regla de transformación de ejemplo agrega una nueva columna de cadena, `emp_seniority`, a la tabla de destino, `employee`. Utiliza la SQLite `round` función de la columna de salarios, con una condición de mayúsculas y minúsculas para comprobar si el salario es igual o superior a 20 000. Si es así, la columna obtiene el valor `SENIOR` y cualquier otra columna tiene el valor `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 Ejemplo de agregación de una nueva columna de cadena a la tabla de destino mediante la función SUBSTR**
El siguiente ejemplo de regla de transformación agrega una nueva columna de cadena mediante SQLite operadores o funciones para definir los datos de una columna. Este enfoque implica el uso de SQLite funciones para transformar los datos GUID cargados desde Oracle al formato UUID antes de insertarlos en la tabla de destino de Postgresql.
La siguiente regla utiliza las funciones de SQLite subcadena (SUBSTR), función hexadecimal (HEX) y minúscula (LOWER) para dividir los datos GUID en varios grupos separados por guiones, específicamente un grupo de 8 dígitos seguido de tres grupos de 4 dígitos seguidos de un grupo de 12 dígitos, para un total de 32 dígitos que representan los 128 bits.
A continuación se muestra un ejemplo de datos de origen y salida en el procesamiento posterior de destino mediante la regla de transformación:
**Tabla de origen (formato GUID de Oracle)**
T\$1 COL2
```
06F6949D234911EE80670242AC120002
1A2B3C4D5E6F11EE80670242AC120003
F5E4D3C2B1A011EE80670242AC120004
```
**Tabla de destino (formato UUID de PostgreSQL)**
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 de agregar una nueva columna de fecha a la tabla de destino**
En el ejemplo siguiente se agrega una nueva columna de fecha, `createdate`, a la tabla de destino, `employee`. Al utilizar la función de SQLite fecha`datetime`, la fecha se añade a la tabla recién creada para cada fila insertada.
```
{
"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 de agregar una nueva columna numérica a la tabla de destino**
En el ejemplo siguiente se agrega una nueva columna numérica, `rounded_emp_salary`, a la tabla de destino, `employee`. Utiliza la SQLite `round` función para añadir el salario redondeado.
```
{
"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 de agregar una nueva columna de cadenas a la tabla de destino mediante la función de inserción**
En el ejemplo siguiente se agrega una nueva columna de cadena, `hashed_emp_number`, a la tabla de destino, `employee`. La SQLite `hash_sha256(x)` función crea valores cifrados en el destino de la columna de origen,`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
}
}
```
## Agregar metadatos a una tabla de destino mediante expresiones
Puede agregar la información de los metadatos a la tabla de destino mediante las siguientes expresiones:
+ `$AR_M_SOURCE_SCHEMA`: el nombre del esquema de origen.
+ `$AR_M_SOURCE_TABLE_NAME`: el nombre de la tabla de origen.
+ `$AR_M_SOURCE_COLUMN_NAME`: el nombre de una columna de la tabla de origen.
+ `$AR_M_SOURCE_COLUMN_DATATYPE`: el tipo de datos de una columna en la tabla de origen.
**Example de agregar una columna para un nombre de esquema mediante el nombre de esquema del origen**
En el ejemplo siguiente se agrega una nueva columna denominada `schema_name` al destino mediante el nombre de esquema del origen.
```
{
"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
}
}
```
# Reglas y operaciones de configuración de tablas y recopilaciones
Utilice la configuración de la tabla para especificar cualquier configuración que desee aplicar a una tabla o vista seleccionada para una operación específica. Las reglas de configuración de tablas son opcionales en función del punto de conexión y de los requisitos de migración.
En lugar de usar tablas y vistas, las bases de datos MongoDB y Amazon DocumentDB almacenan los registros de datos como documentos que se agrupan en *recopilaciones*. Una base de datos única para cualquier punto de conexión de MongoDB o Amazon DocumentDB es un conjunto específico de recopilaciones identificadas por el nombre de la base de datos.
Al migrar desde un origen de MongoDB o Amazon DocumentDB, se trabaja con la configuración de carga paralela de forma ligeramente diferente. En este caso, considere el tipo de segmentación automática o segmentación por rango de la configuración de carga paralela para recopilaciones seleccionadas en lugar de tablas y vistas.
**Topics**
+ [
## Los caracteres comodín en la configuración de las tablas están restringidos
](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.Wildcards)
+ [
## Uso de carga paralela para tablas, vistas y recopilaciones seleccionadas
](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.ParallelLoad)
+ [
## Especificación de la configuración de LOB para una tabla o vista seleccionada
](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.LOB)
+ [
## Ejemplos de configuración de tablas
](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.Examples)
Para las reglas de mapeo de tablas que utilizan el tipo de regla table-settings, puede aplicar los parámetros siguientes.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/dms/latest/userguide/CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.html)
## Los caracteres comodín en la configuración de las tablas están restringidos
No se admite el uso del carácter de comodín de porcentaje (`"%"`) en las reglas de `"table-settings"` para las bases de datos de origen, como se muestra a continuación.
```
{
"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
}
}
```
Si usa `"%"` las `"table-settings"` reglas como se muestra, AWS DMS devuelve la siguiente excepción.
```
Error in mapping rules. Rule with ruleId = x failed validation. Exact
schema and table name required when using table settings rule.
```
Además, AWS recomienda no cargar un gran número de colecciones grandes mediante una sola tarea con`parallel-load`. Tenga en cuenta que AWS DMS limita la contención de recursos, así como el número de segmentos cargados en paralelo, según el valor del parámetro de configuración de la tarea `MaxFullLoadSubTasks`, con un valor máximo de 49.
En su lugar, especifique todas las recopilaciones de la base de datos de origen para las recopilaciones más grandes especificando cada `"schema-name"` y `"table-name"` de forma individual. Además, escale verticalmente la migración de forma adecuada. Por ejemplo, ejecute varias tareas en un número suficiente de instancias de replicación para gestionar una gran cantidad de recopilaciones grandes de la base de datos.
## Uso de carga paralela para tablas, vistas y recopilaciones seleccionadas
Para acelerar la migración y hacerla más eficiente, puede utilizar la carga paralela para tablas, vistas y recopilaciones relacionales seleccionadas. En otras palabras, puede migrar una tabla, vista o recopilación de segmentación única con varios subprocesos en paralelo. Para ello, AWS DMS divide una tarea de carga completa en subprocesos, y cada segmento de la tabla se asigna a su propio subproceso.
Con este proceso de carga en paralelo, primero puede hacer que varios subprocesos descarguen diversas tablas, vistas y recopilaciones en paralelo desde el punto de conexión de origen. A continuación, puede hacer que varios subprocesos migren y carguen las mismas tablas, vistas y recopilaciones en paralelo al punto de conexión de destino. Para algunos motores de base de datos, puede segmentar las tablas y vistas por las particiones o subparticiones existentes. Para otros motores de bases de datos, puede segmentar AWS DMS automáticamente las colecciones según parámetros específicos (segmentación automática). De lo contrario, puede segmentar cualquier tabla, vista o recopilación por los rangos de valores de columna que especifique.
La carga en paralelo es compatible para los siguientes puntos de enlace de origen:
+ Oracle
+ Microsoft SQL Server
+ MySQL
+ PostgreSQL
+ IBM Db2 LUW
+ SAP Adaptive Server Enterprise (ASE)
+ MongoDB (solo admite las opciones de segmentación automática y segmentación por rango de una carga completa paralela)
+ Amazon DocumentDB (solo admite las opciones de segmentación automática y segmentación por rango de una carga completa paralela)
Para los puntos de enlace de MongoDB y Amazon DocumentDB AWS DMS , admite los siguientes tipos de datos para las columnas que son claves de partición para la opción de segmentación de rango de una carga completa paralela.
+ Double
+ Cadena
+ ObjectId
+ Entero de 32 bits
+ Entero de 64 bits
La carga paralela para su uso con reglas de configuración de tablas se admite para los siguientes puntos de enlace de destino:
+ Oracle
+ Microsoft SQL Server
+ MySQL
+ PostgreSQL
+ Amazon S3
+ SAP Adaptive Server Enterprise (ASE)
+ Amazon Redshift
+ MongoDB (solo admite las opciones de segmentación automática y segmentación por rango de una carga completa paralela)
+ Amazon DocumentDB (solo admite las opciones de segmentación automática y segmentación por rango de una carga completa paralela)
+ Db2 LUW
Para especificar el número máximo de tablas y vistas que se pueden cargar en paralelo, utilice el ajuste de tarea `MaxFullLoadSubTasks`.
Para especificar el número máximo de subprocesos por tabla o vista para los destinos admitidos de una tarea de carga paralela, defina más segmentos mediante los límites entre columnas y valores.
**importante**
`MaxFullLoadSubTasks` controla el número de tablas o segmentos de tabla que se van a cargar en paralelo. `ParallelLoadThreads` controla el número de subprocesos que utiliza una tarea de migración para ejecutar las cargas en paralelo. *Estos ajustes son multiplicativos*. Por lo tanto, el número total de subprocesos que se utilizan durante una tarea de carga completa es aproximadamente el resultado del valor de `ParallelLoadThreads ` multiplicado por el valor de `MaxFullLoadSubTasks` (`ParallelLoadThreads` **\$1** `MaxFullLoadSubtasks)`).
Si crea tareas con un número elevado de subtareas de carga completa y un número elevado de subprocesos de carga en paralelo, la tarea puede consumir demasiada memoria y producir un error.
Para especificar el número máximo de subprocesos por tabla para los destinos de Amazon DynamoDB, Amazon Kinesis Data Streams, Apache Kafka o Amazon Elasticsearch Service, utilice la configuración de tareas de metadatos de destino `ParallelLoadThreads`.
Para especificar el tamaño del búfer para una tarea de carga paralela cuando se use `ParallelLoadThreads`, use el ajuste de la tarea de metadatos de destino de `ParallelLoadBufferSize`.
La disponibilidad y configuración de `ParallelLoadThreads` y `ParallelLoadBufferSize` dependen del punto de conexión de destino.
Para obtener más información sobre los ajustes de `ParallelLoadThreads` y `ParallelLoadBufferSize`, consulte [Configuración de las tareas de los metadatos de destino](CHAP_Tasks.CustomizingTasks.TaskSettings.TargetMetadata.md). Para obtener más información acerca de la opción `MaxFullLoadSubTasks`, consulte [Configuración de tareas de carga completa](CHAP_Tasks.CustomizingTasks.TaskSettings.FullLoad.md). Para obtener información específica en puntos de enlace de destino, consulte los temas relacionados.
Para utilizar la carga en paralelo, cree una regla de mapeo de tablas de tipo `table-settings` con la opción `parallel-load`. Dentro de la regla `table-settings`, puede especificar los criterios de segmentación para una única tabla, vista o recopilación que desea cargar en paralelo. Para hacerlo, establezca el parámetro `type` de la opción `parallel-load` a una de varias opciones.
Cómo hacerlo depende de cómo desee segmentar la tabla, vista o recopilación para carga paralela:
+ Por particiones (o segmentos): cargue todas las particiones de tabla o vista (o segmentos) existentes con el tipo `partitions-auto`. También puede cargar solo las particiones seleccionadas con el tipo `partitions-list` y una matriz de particiones especificada.
Solo para los puntos de enlace de MongoDB y Amazon DocumentDB, cargue todas las colecciones o las especificadas por segmentos AWS DMS que se calculen automáticamente también con `partitions-auto` el tipo y los parámetros opcionales adicionales. `table-settings`
+ (Solo los puntos de conexión de Oracle) Por subparticiones: cargue todas las subparticiones de tablas o vistas existentes con el tipo `subpartitions-auto`. También puede cargar solamente las subparticiones seleccionadas con el tipo `partitions-list` y una matriz `subpartitions` especificada.
+ Por segmentos que defina, cargue los segmentos de tabla, vista o recopilación que defina mediante límites de valor de columna. Para ello, utilice el tipo `ranges` con las matrices `columns` y `boundaries` especificadas.
**nota**
Los puntos de conexión de PostgreSQL admiten solo este tipo de carga paralela. MongoDB y Amazon DocumentDB como puntos de conexión de origen admiten este tipo de segmentación por rango y el tipo de segmentación automática de una carga completa paralela (`partitions-auto`).
Para identificar otras tablas, vistas o recopilaciones que desee cargar en paralelo, especifique objetos de `table-settings` adicionales con las opciones `parallel-load`.
En los siguientes procedimientos, puede ver cómo programar el JSON para cada tipo de carga en paralelo, desde el más simple al más complejo.
**Especificación de todas las particiones de tabla, vista o recopilación o todas las subparticiones de tabla o vista**
+ Especifique `parallel-load` con el tipo `partitions-auto` o con el tipo `subpartitions-auto` (pero no ambos).
Cada tabla, vista o partición (o segmento) o subpartición de recopilación se asigna automáticamente a su propio subproceso.
Para algunos puntos de conexión, la carga en paralelo incluye particiones o subparticiones solo si ya están definidas para la tabla o vista. Para los puntos finales de origen de MongoDB y Amazon DocumentDB, puede hacer AWS DMS que calculen automáticamente las particiones (o segmentos) en función de parámetros adicionales opcionales. Incluyen `number-of-partitions`, `collection-count-from-metadata`, `max-records-skip-per-page` y `batch-size`.
**Para especificar particiones de tabla o vista, subparticiones o ambas**
1. Especifique `parallel-load` con el tipo `partitions-list`.
1. (Opcional) Para incluir particiones, especifique una matriz de nombres de partición como valor de `partitions`.
Cada partición especificada se asigna a continuación a su propio subproceso.
**importante**
Para los puntos de conexión de Oracle, asegúrese de que las particiones y subparticiones no se superpongan al elegirlas para carga paralela. Si utiliza particiones y subparticiones superpuestas para cargar datos en paralelo, se duplican las entradas o se produce un error debido a una infracción de duplicación de la clave principal.
1. (Opcional), solo para puntos de conexión de Oracle, incluir subparticiones mediante la especificación de una matriz de nombres de subpartición como valor de `subpartitions`.
Cada subpartición especificada se asigna a continuación a su propio subproceso.
**nota**
La carga en paralelo incluye particiones o subparticiones solo si ya están definidas para la tabla o vista.
Puede especificar segmentos de tabla o vista como rangos de valores de columna Al hacerlo, tenga en cuenta estas características de las columnas:
+ La especificación de columnas indexadas mejora de manera significativa el rendimiento.
+ Puede especificar hasta 10 columnas.
+ No puede usar columnas para definir los límites de los segmentos con los siguientes tipos de AWS DMS datos: DOUBLE, FLOAT, BLOB, CLOB y NCLOB
+ Los registros con valores nulos no se replican.
**Especificación de segmentos de tabla, vista o recopilación como rangos de valores de columna**
1. Especifique `parallel-load` con el tipo `ranges`.
1. Defina un límite entre los segmentos de tabla o vista; para ello, especifique una matriz de nombres de columnas como valor de `columns`. Repita esta operación con cada columna para la que desea definir un límite entre segmentos de tabla o vista.
El orden de las columnas es importante. La primera columna es la más importante y la última es la menos importante para definir cada límite, tal como se describe a continuación.
1. Para definir los rangos de datos de todos los segmentos de la tabla o vista, especifique una matriz de límites como valor de `boundaries`. Una *matriz de límite* es una matriz de matrices columna-valor. Para ello, siga estos pasos:
1. Especifique cada elemento de una matriz de valores de columna como un valor que corresponde a cada columna. Una *matriz columna-valor* representa el límite superior de cada segmento de tabla o vista que desea definir. Especifique cada columna en el mismo orden en el que la especificó en la matriz `columns`.
Introduzca valores para las columnas DATE en el formato admitido por el origen.
1. Especifique cada matriz de valores de columnas como el límite superior, en orden, de cada segmento desde la parte inferior hasta el segmento de la tabla o vista next-to-top. Si existe alguna fila sobre el límite superior que especifique, estas filas completan el segmento superior de la tabla o vista. De este modo, el número de segmentos basados en rango es potencialmente uno más que el número de límites de segmentos en la matriz de límites. Cada uno de estos segmentos basados en rango se asigna a su propio subproceso.
Todos los datos no nulos se replican, incluso si no define rangos de datos para todas las columnas de la tabla o vista.
Por ejemplo, supongamos que define tres matrices de valores de columnas para las columnas COL1 y de la siguiente manera. COL2 COL3
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/dms/latest/userguide/CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.html)
Ha definido tres límites de segmentos para un total posible de cuatro segmentos.
Para identificar los rangos de filas que se van a replicar para cada segmento, la instancia de replicación aplica una búsqueda a estas tres columnas para cada uno de los cuatro segmentos. La búsqueda es similar a la siguiente:
**Segmento 1**
Replique todas las filas en las que se cumpla lo siguiente: los primeros valores de dos columnas son inferiores o iguales a sus valores de límite superior de **Segmento 1** correspondientes. Además, los valores de la tercera columna son inferiores a su valor de límite superior de **Segmento 1**.
**Segmento 2**
Replique todas las filas (salvo el **Segmento 1**) en las que se cumpla lo siguiente: los primeros valores de dos columnas son inferiores o iguales a sus valores de límite superior de **Segmento 2** correspondientes. Además, los valores de la tercera columna son inferiores a su valor de límite superior de **Segmento 2**.
**Segmento 3**
Replique todas las filas (salvo el **Segmento 3**) en las que se cumpla lo siguiente: los primeros valores de dos columnas son inferiores o iguales a sus valores de límite superior de **Segmento 3** correspondientes. Además, los valores de la tercera columna son inferiores a su valor de límite superior de **Segmento 3**.
**Segmento 4**
Replique todas las filas restantes (excepto las filas **Segment 1, 2 y 3**).
En este caso, la instancia de replicación crea una cláusula `WHERE` para cargar cada segmento tal y como se indica a continuación:
**Segmento 1**
`((COL1 < 10) OR ((COL1 = 10) AND (COL2 < 30)) OR ((COL1 = 10) AND (COL2 = 30) AND (COL3 < 105)))`
**Segmento 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)))`
**Segmento 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)))`
**Segmento 4**
`NOT ((COL1 < 100) OR ((COL1 = 100) AND (COL2 < 12)) OR ((COL1 = 100) AND (COL2 = 12) AND (COL3 < 99)))`
## Especificación de la configuración de LOB para una tabla o vista seleccionada
Puede establecer la configuración de LOB de tareas para una o más tablas creando una regla de mapeo de tablas de tipo `table-settings` con la opción `lob-settings` para uno o más objetos `table-settings`.
La especificación de la configuración de LOB para tablas o vistas seleccionadas se admite para los siguientes puntos de enlace de origen:
+ Oracle
+ Microsoft SQL Server
+ MySQL
+ PostgreSQL
+ IBM Db2, en función de los ajustes `mode` y `bulk-max-size`, que se describen a continuación
+ SAP Adaptive Server Enterprise (ASE), en función de los ajustes `mode` y `bulk-max-size`, que se describen a continuación
La especificación de la configuración de LOB para tablas o vistas seleccionadas se admite para los siguientes puntos de enlace de destino:
+ Oracle
+ Microsoft SQL Server
+ MySQL
+ PostgreSQL
+ SAP ASE, en función de los ajustes `mode` y `bulk-max-size`, que se describen a continuación
**nota**
Solo puede utilizar tipos de datos BLOB en tablas y vistas que incluyan una clave principal.
Para utilizar la configuración de LOB para una tabla o vista seleccionada, debe crear una regla de mapeo de tablas de tipo `table-settings` con la opción `lob-settings`. Esto especifica la gestión de LOB para la tabla o vista identificada por la opción `object-locator`. En la regla `table-settings`, puede especificar un objeto `lob-settings` con los parámetros siguientes:
+ `mode`: especifica el mecanismo para la gestión de la migración de LOB para la tabla o vista seleccionada tal y como se indica a continuación:
+ `limited`: el modo de LOB limitado predeterminado es el modo más rápido y eficiente. Utilice este modo solo si todas LOBs son pequeñas (con un tamaño máximo de 100 MB) o si el punto final de destino no admite un tamaño de LOB ilimitado. Además, si lo usas`limited`, todos LOBs deben tener el tamaño que hayas establecido. `bulk-max-size`
En este modo, para una tarea de carga completa, la instancia de replicación migra todos los datos LOBs en línea junto con otros tipos de datos de columnas como parte del almacenamiento de la tabla o vista principal. Sin embargo, la instancia trunca al tamaño especificado cualquier LOB migrado con un tamaño superior al valor `bulk-max-size`. Para una tarea de carga de captura de datos de cambios (CDC), la instancia migra toda la instancia LOBs mediante una búsqueda en la tabla de origen, como en el modo LOB completo estándar (consulte lo siguiente).
**nota**
Solo puede migrar vistas para tareas de carga completa.
+ `unlimited`: el mecanismo de migración para el modo de LOB completo depende del valor que defina para `bulk-max-size` del modo siguiente:
+ **Modo LOB completo estándar**: si se establece en cero, la instancia de replicación `bulk-max-size` migra toda ella LOBs mediante el modo LOB completo estándar. Este modo requiere una búsqueda en la tabla o vista de origen para migrar cada LOB, con independencia del tamaño. Este enfoque suele dar como resultado una migración mucho más lenta que para el modo de LOB limitado. Utilice este modo solo si todas o la mayoría de las unidades LOBs son grandes (1 GB o más).
+ **Modo de LOB completo de combinación**: cuando se establece `bulk-max-size` en un valor distinto de cero, este modo de LOB completo utiliza una combinación de modo de LOB limitado y modo de LOB completo estándar. Es decir, para una tarea de carga completa, si el tamaño de LOB está dentro del valor `bulk-max-size`, la instancia migra el LOB en línea como en el modo de LOB limitado. Si el tamaño de LOB es superior a ese valor, la instancia migra el LOB mediante una búsqueda de tabla o vista de origen como en el modo de LOB completo estándar. Para una tarea de carga de captura de datos de cambios (CDC), la instancia migra toda la instancia LOBs mediante una búsqueda en la tabla fuente, como en el modo LOB completo estándar (consulta lo siguiente). Lo hace con independencia del tamaño de LOB.
**nota**
Solo puede migrar vistas para tareas de carga completa.
Este modo da lugar a una velocidad de migración que es un compromiso entre el modo de LOB limitado, más rápido y el modo de LOB completo estándar, más lento. Usa este modo solo cuando tengas una combinación de pequeños y grandes LOBs, y la mayoría de ellos LOBs sean pequeños.
Este modo LOB completo de combinación solo está disponible para los siguientes puntos de enlace:
+ IBM Db2 como origen
+ SAP ASE como origen o destino
Independientemente del mecanismo que especifiques para el `unlimited` modo, la instancia se migra LOBs completamente, sin truncarse.
+ `none`— La instancia de replicación se migra a la LOBs tabla o vista seleccionada utilizando la configuración del LOB de la tarea. Utilice esta opción para ayudar a comparar los resultados de migración con y sin la configuración de LOB para la tabla o vista seleccionada.
Si la tabla o vista especificada LOBs se ha incluido en la replicación, puede establecer la configuración de la `BatchApplyEnabled` tarea para que `true` solo utilice el modo `limited` LOB.
En algunos casos, puede establecer `BatchApplyEnabled` en `true` y `BatchApplyPreserveTransaction` en `false`. En estos casos, la instancia se establece `BatchApplyPreserveTransaction` en `true` si la tabla o vista tiene Oracle LOBs y los puntos finales de origen y destino son Oracle.
+ `bulk-max-size`: establezca este valor en un valor cero o no cero en kilobytes, en función del `mode`, tal como se ha descrito para los elementos anteriores. En modo `limited`, debe establecer un valor distinto de cero para este parámetro.
La instancia se convierte LOBs a formato binario. Por lo tanto, para especificar el LOB mayor que tiene que replicar, multiplique su tamaño por tres. Por ejemplo, si el LOB más grande tiene 2 MB, defina `bulk-max-size` en 6000 (6 MB).
## Ejemplos de configuración de tablas
A continuación, encontrará algunos ejemplos que muestran el uso de la configuración de tabla.
**Example Cargar una tabla segmentada por particiones**
En el siguiente ejemplo se carga una tabla `SALES` en el origen de manera más eficiente cargándola en paralelo en función de todas sus particiones.
```
{
"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 Cargar una tabla segmentada por subparticiones**
El ejemplo siguiente carga una tabla `SALES` en el origen de Oracle de forma más eficiente cargándola en paralelo en función de todas sus subparticiones.
```
{
"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 Cargar una tabla segmentada por una lista de particiones**
En el siguiente ejemplo se carga una tabla `SALES` en su origen cargándola en paralelo por medio de una lista de particiones particular. Aquí, las particiones especificadas se nombran según valores que empiezan por partes del alfabeto, por ejemplo, `ABCD`, `EFGH`, etc.
```
{
"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 Cargar una tabla de Oracle segmentada por una lista de particiones y subparticiones seleccionada**
En el siguiente ejemplo se carga una table `SALES` en su origen de Oracle cargándola en paralelo por una lista de particiones y subparticiones seleccionada. Aquí, las particiones especificadas se nombran según valores que empiezan por partes del alfabeto, por ejemplo, `ABCD`, `EFGH`, etc. Las subparticiones especificadas se nombran según valores que empiezan por numerales, por ejemplo, `01234` y `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 Cargar una tabla segmentada por intervalos de valores de columna**
En el siguiente ejemplo se carga una tabla `SALES` en el origen cargándola en paralelo por segmentos especificados por los rangos de los valores de columna `REGION` y `SALES_NO`.
```
{
"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"
]
]
}
}
]
}
```
Aquí, se especifican dos columnas por rangos de segmento con los nombres `SALES_NO` y `REGION`. Se especifican dos límites con dos conjuntos de valores de columna (`["1000","NORTH"]` y `["3000","WEST"]`).
Estos dos límites, por lo tanto, identifican los tres segmentos de tabla siguientes para cargarlos en paralelo:
Segmento 1
Las filas con `SALES_NO` menor o igual que 1000 y `REGION` menor que "NORTH". En otras palabras, cifras de ventas de hasta 1000 en la región EAST.
Segmento 2
Las filas distintas de **Segmento 1** con `SALES_NO` menor o igual que 3000 y `REGION` menor que "WEST". En otras palabras, las cifras de ventas de 1000 a 3000 en las regiones NORTH y SOUTH.
Segmento 3
Todas las filas restantes que no sean **Segment 1** y **Segment 2**. En otras palabras, los números de ventas superiores a 3000 en la región “WEST”.
**Example Cargar dos tablas: una segmentada por intervalos y otra segmentada por particiones**
En el siguiente ejemplo se carga una tabla `SALES` en paralelo por los límites de segmento que identifique. También se carga una tabla `ORDERS` en paralelo por todas sus particiones, como en ejemplos anteriores.
```
{
"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 Cargue una tabla LOBs utilizando la configuración de LOB de la tarea**
En el siguiente ejemplo, se carga una `ITEMS` tabla en la fuente, incluidas todas LOBs, utilizando la configuración de LOB de la tarea. La configuración de `bulk-max-size` de 100 MB se omite y se deja solo para un restablecimiento rápido al modo `limited` o `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 Carga una tabla LOBs utilizando el modo LOB limitado**
En el siguiente ejemplo, se carga una `ITEMS` tabla incluida LOBs en el código fuente mediante el modo LOB limitado (el predeterminado) con un tamaño máximo no truncado de 100 MB. Las LOBs que superen este tamaño se truncan a 100 MB. Todos LOBs se cargan en línea con los demás tipos de datos de columnas.
```
{
"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 Cargue una tabla LOBs utilizando el modo LOB completo estándar**
En el siguiente ejemplo, se carga una `ITEMS` tabla en la fuente, incluidas todas las tablas LOBs sin truncamiento, mediante el modo LOB completo estándar. Todos LOBs, independientemente del tamaño, se cargan por separado de los demás tipos de datos mediante una búsqueda de cada LOB en la tabla de origen.
```
{
"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 Cargue una tabla LOBs utilizando el modo LOB completo combinado**
En el siguiente ejemplo, se carga una `ITEMS` tabla en la fuente, incluidas todas las tablas LOBs sin truncamiento, mediante el modo LOB combinado completo. Todos los datos que tengan LOBs un tamaño inferior a 100 MB se cargan en línea junto con otros tipos de datos, como en el modo LOB limitado. Los datos LOBs de más de 100 MB se cargan por separado de los demás tipos de datos. Esta carga independiente utiliza una búsqueda para cada uno de estos LOB en la tabla de origen, como en el modo LOB completo estándar.
```
{
"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"
}
}
]
}
```
# Uso del enmascaramiento de datos para ocultar información confidencial
Para ocultar la información confidencial almacenada en una o más columnas de las tablas que se van a migrar, puede aprovechar las acciones de las reglas de transformación del enmascaramiento de datos. A partir de la versión 3.5.4, AWS DMS permite el uso de acciones de reglas de transformación del enmascaramiento de datos en la representación cartográfica de tablas, lo que permite modificar el contenido de una o más columnas durante el proceso de migración. AWS DMS carga los datos modificados en las tablas de destino.
AWS Database Migration Service proporciona tres opciones para las acciones de las reglas de transformación del enmascaramiento de datos:
+ Enmascaramiento de datos: máscara de dígitos
+ Enmascaramiento de datos: distribución aleatoria de dígitos
+ Enmascaramiento de datos: máscara de hash
Estas acciones de las reglas de transformación del enmascaramiento de datos se pueden configurar en la asignación de tablas de la tarea de replicación, de forma similar a otras reglas de transformación. El destino de la regla debe establecerse en la columna.
## Enmascaramiento de números en los datos de las columnas con un carácter de enmascaramiento
La acción de la regla de transformación Enmascaramiento de datos: máscara de dígitos le permite enmascarar los datos numéricos de una o más columnas sustituyendo los dígitos por un único carácter imprimible en formato ASCII que especifique (excluidos los caracteres vacíos o los espacios en blanco).
A continuación, se muestra un ejemplo en el que se enmascaran todos los dígitos de la columna `cust_passport_no` de la tabla `customer_master` con el carácter de enmascaramiento `'#'` y, luego, se cargan los datos enmascarados en la tabla de destino:
```
{
"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": "#"
}
]
}
```
Por ejemplo, si la columna de `cust_passport_no` la tabla de origen contiene el registro «C6 BGJ566669 K», la AWS DMS tarea escribirá estos datos en la tabla de destino como. `"C#BGJ######K"`
## Sustitución de los números de la columna por números aleatorios
La regla de transformación Enmascaramiento de datos: distribución aleatoria de dígitos le permite reemplazar cada dígito numérico de una o más columnas por un número aleatorio. En el siguiente ejemplo, AWS DMS reemplaza cada dígito de la `cust_passport_no` columna de la tabla `customer_master` de origen por un número aleatorio y escribe los datos modificados en la tabla de destino:
```
{
"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"
}
]
}
```
Por ejemplo, la AWS DMS tarea transformará el valor de la `cust_passport_no` columna de la tabla de origen `"C6BGJ566669K"` en la base de datos de destino `"C1BGJ842170K"` y lo escribirá en ella.
## Sustitución de los datos de la columna por un valor hash
La regla de transformación Enmascaramiento de datos: máscara de hash permite reemplazar los datos de la columna por un hash generado con el algoritmo `SHA256`. La longitud del hash siempre será de 64 caracteres, por lo que la longitud de la columna de la tabla de destino debe ser de 64 caracteres como mínimo. Como alternativa, puede añadir una acción de regla de transformación `change-data-type` a la columna para aumentar el ancho de la columna en la tabla de destino.
El siguiente ejemplo genera un valor hash de 64 caracteres para los datos de la columna `cust_passport_no` de la tabla de origen `customer_master` y carga los datos transformados en la tabla de destino tras aumentar la longitud de la columna:
```
{
"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"
}
]
}
```
Por ejemplo, si la columna `cust_passport_no` de la tabla de origen contiene un valor`“C6BGJ566669K”`, la AWS DMS tarea escribirá un hash `“7CB06784764C9030CCC41E25C15339FEB293FFE9B329A72B5FED564E99900C75”` en la tabla de destino.
## Limitaciones
+ Cada opción de regla de transformación de enmascaramiento de datos solo se admite para tipos AWS DMS de datos específicos:
+ El Enmascaramiento de datos: máscara de dígitos es compatible con las columnas de los tipos de datos `WSTRING` y `STRING`.
+ El Enmascaramiento de datos: distribución aleatoria de dígitos es compatible con las columnas de los tipos de datos: `WSTRING, STRING; NUMERIC, INT1, INT2, INT4, and INT8 ` con homólogos sin firmar.
+ El Enmascaramiento de datos: máscara de hash es compatible con las columnas de los tipos de datos `WSTRING` y `STRING`.
Para obtener más información sobre la asignación de AWS DMS los tipos de datos a los tipos de datos del motor de origen, consulte la asignación de tipos de datos del motor de origen con AWS DMS los tipos de datos. Consulte los tipos de datos de origen para [Tipos de datos de origen para Oracle](CHAP_Source.Oracle.md#CHAP_Source.Oracle.DataTypes), [Tipos de datos de origen para SQL Server](CHAP_Source.SQLServer.md#CHAP_Source.SQLServer.DataTypes), [Tipos de datos de origen para PostgreSQL](CHAP_Source.PostgreSQL.md#CHAP_Source-PostgreSQL-DataTypes) y [Tipos de datos de origen para MySQL](CHAP_Source.MySQL.md#CHAP_Source.MySQL.DataTypes).
+ Si se utiliza una acción de regla de enmascaramiento de datos para una columna con un tipo de datos incompatible, se producirá un error en la tarea de DMS. Consulte la sección Configuración DataMaskingErrorPolicy de tareas del DMS para especificar el comportamiento de la gestión de errores. Para obtener más información acerca de `DataMaskingErrorPolicy`, consulte [Configuración de las tareas de administración de errores](CHAP_Tasks.CustomizingTasks.TaskSettings.ErrorHandling.md).
+ Puede añadir una acción de regla de change-data-type transformación para cambiar el tipo de datos de la columna a un tipo compatible si el tipo de columna de origen no es compatible con la opción de enmascaramiento que va a utilizar. El `rule-id` de la transformación `change-data-type` debe ser un número menor que el rule-id de la transformación de enmascaramiento para que el cambio de tipo de datos se produzca antes del enmascaramiento.
+ Utilice la acción Enmascaramiento de datos: máscara de hash para enmascarar las columnas Clave principal, Clave única o Clave externa, ya que el valor hash generado será único y coherente. Las otras dos opciones de enmascaramiento no pueden garantizar la exclusividad.
+ Mientras que las acciones Enmascaramiento de datos: máscara de dígitos y Enmascaramiento de datos: distribución aleatoria de dígitos solo afectan a los dígitos de los datos de la columna y no a la longitud de los datos, la acción Enmascaramiento de datos: máscara de hash modifica toda la columna y la longitud de los datos cambia a 64 caracteres. Por lo tanto, se debe crear la tabla de destino en consecuencia o se debe añadir una regla de change-data-type transformación para la columna que se va a enmascarar.
+ Las columnas con la acción de la regla de transformación de enmascaramiento de datos especificada se excluyen de la validación de datos en AWS DMS. Si las columnas Clave principal o Clave única están enmascaradas, no se realizará la validación de datos de esta tabla; el estado de validación de dicha tabla será igual a `No Primary key`.