Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Utilisation du mappage de table pour spécifier des paramètres de tâche
Le mappage de table utilise différents types de règles pour spécifier la source de données, le schéma source, les données et toutes les transformations qui doivent se produire pendant la tâche. Vous pouvez utiliser le mappage de table pour spécifier des tables individuelles d'une base de données à migrer et le schéma à utiliser pour la migration.
Lorsque vous utilisez le mappage de table, vous pouvez utiliser des filtres pour spécifier les données à répliquer à partir des colonnes de table. De plus, vous pouvez utiliser des transformations pour modifier les schémas, tables ou vues sélectionnés avant qu'ils soient écrits dans la base de données cible.
**Topics**
+ [
# Spécification des règles de sélection de table et de transformation à partir de la console
](CHAP_Tasks.CustomizingTasks.TableMapping.Console.md)
+ [
# Spécification des règles de sélection de table et de transformation à l’aide de JSON
](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.md)
+ [
# Règles et actions de sélection
](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Selections.md)
+ [
# Caractères génériques dans le mappage de table
](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Wildcards.md)
+ [
# Règles et actions de transformation
](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Transformations.md)
+ [
# Utilisation d'expressions de règle de transformation pour définir le contenu d’une colonne
](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions.md)
+ [
# Règles des paramètres de table et de collection et opérations
](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.md)
+ [
# Utiliser le masquage des données pour masquer des informations sensibles
](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Masking.md)
**Note**
Lorsque vous utilisez le mappage de table pour un point de terminaison source MongoDB, vous pouvez utiliser des filtres pour spécifier les données que vous souhaitez répliquer, et spécifier un nom de base de données à la place de `schema_name`. Sinon, vous pouvez utiliser la valeur `"%"` par défaut.
# Spécification des règles de sélection de table et de transformation à partir de la console
Vous pouvez utiliser le AWS Management Console pour effectuer un mappage de table, notamment pour spécifier la sélection de tables et les transformations. Dans la console, utilisez la section **Where** pour spécifier le schéma, la table et l'action (include ou exclude). Utilisez la section **Filter** pour spécifier le nom de la colonne dans une table et les conditions que vous souhaitez appliquer à une tâche de réplication. Ensemble, ces deux actions créent une règle de sélection.
Vous pouvez inclure des transformations dans un mappage de table une fois que vous avez spécifié au moins une règle de sélection. Vous pouvez utiliser les transformations pour renommer un schéma ou une table, ajouter un préfixe ou un suffixe à un schéma ou une table ou supprimer une colonne d'une table.
**Note**
AWS DMS ne prend pas en charge plus d'une règle de transformation par niveau de schéma, de table ou de colonne.
La procédure suivante montre comment configurer des règles de sélection, basées sur une table appelée **Customers** dans un schéma appelé **EntertainmentAgencySample**.
**Pour spécifier une sélection de table, des critères de filtre et des transformations à l'aide de la console**
1. Connectez-vous à la AWS DMS console AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/dms/v2/](https://console.aws.amazon.com/dms/v2/).
Si vous êtes connecté en tant qu’utilisateur IAM, assurez-vous d’avoir les autorisations appropriées pour accéder à AWS DMS. Pour plus d'informations sur les autorisations requises, consultez [Autorisations IAM nécessaires pour utiliser AWS DMS](security-iam.md#CHAP_Security.IAMPermissions).
1. Sur la page **Tableau de bord**, choisissez **Tâches de migration de base de données**.
1. Choisissez **Créer une tâche**.
1. Dans la section **Configuration de la tâche**, entrez les informations relatives à la tâche, notamment l’**Identifiant de tâche**, l’**Instance de réplication**, le **Point de terminaison de base de données source**, le **Point de terminaison de base de données cible** et le **Type de migration**.
![\[Sélection de schéma et de table\]](http://docs.aws.amazon.com/fr_fr/dms/latest/userguide/images/datarep-create-task-20.png)
1. Dans la section **Mappage de table**, entrez le nom de schéma et le nom de table. Vous pouvez utiliser le signe « % » comme caractère générique lorsque vous spécifiez le nom de schéma ou le nom de table. Pour en savoir plus sur les autres caractères génériques que vous pouvez utiliser, consultez [Caractères génériques dans le mappage de table](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Wildcards.md). Spécifiez l'action à exécuter pour inclure ou exclure les données définies par le filtre.
![\[Sélection de schéma et de table\]](http://docs.aws.amazon.com/fr_fr/dms/latest/userguide/images/datarep-Tasks-selecttransfrm.png)
1. Spécifiez des informations de filtre à l'aide des liens **Ajouter un filtre de colonne** et **Ajouter une condition**.
1. Choisissez **Ajouter un filtre de colonne** pour spécifier une colonne et des conditions.
1. Choisissez **Ajouter une condition** pour ajouter des conditions supplémentaires.
L'exemple suivant montre un filtre pour la table **Customers** qui inclut les **AgencyIDs** entre **01** et **85**.
![\[Sélection de schéma et de table\]](http://docs.aws.amazon.com/fr_fr/dms/latest/userguide/images/datarep-Tasks-filter.png)
1. Lorsque vous avez créé vos sélections, choisissez **Ajouter une nouvelle règle de sélection**.
1. Une fois que vous avez créé au moins une règle de sélection, vous pouvez ajouter une transformation à la tâche. Choisissez **Ajouter une règle de transformation**.
![\[règle de transformation\]](http://docs.aws.amazon.com/fr_fr/dms/latest/userguide/images/datarep-Tasks-transform1.png)
1. Choisissez la cible que vous souhaitez transformer et saisissez les informations supplémentaires requises. L'exemple suivant montre une transformation qui supprime la colonne **AgencyStatus** de la table **Customer**.
![\[règle de transformation\]](http://docs.aws.amazon.com/fr_fr/dms/latest/userguide/images/datarep-Tasks-transform2.png)
1. Choisissez **Ajouter une règle de transformation**.
1. Choisissez **Créer tâche**.
**Note**
AWS DMS ne prend pas en charge plus d'une règle de transformation par niveau de schéma, de table ou de colonne.
# Spécification des règles de sélection de table et de transformation à l’aide de JSON
Pour spécifier les mappages de table à appliquer lors de la migration, vous pouvez créer un fichier JSON. Si vous créez une tâche de migration à l'aide de la console, vous pouvez rechercher ce fichier JSON ou entrer le JSON directement dans la zone de mappage de table. Si vous utilisez l’interface de ligne de commande ou l’API pour effectuer des migrations, vous pouvez spécifier ce fichier en utilisant le paramètre `TableMappings` de l’opération d’API `CreateReplicationTask` ou `ModifyReplicationTask`.
AWS DMS ne peut traiter que des fichiers JSON de mappage de tables d'une taille maximale de 2 Mo. Nous vous recommandons de maintenir la taille de fichier JSON de la règle de mappage au-dessous de la limite de 2 Mo lorsque vous travaillez avec des tâches DMS. Cela permet d’éviter les erreurs inattendues lors de la création ou de la modification des tâches. Lorsqu’un fichier de règle de mappage dépasse la limite de 2 Mo, nous vous recommandons de répartir les tables entre plusieurs tâches afin que la taille du fichier de règle de mappage reste inférieure à cette limite.
Vous pouvez spécifier les tables, les vues et les schémas que vous souhaitez utiliser. Vous pouvez également effectuer des transformations de tables, de vues et de schémas, et spécifier des paramètres définissant la façon dont AWS DMS charge des tables et des vues individuelles. Vous créez des règles de mappage de table pour ces options à l'aide des types de règles suivants :
+ Règles `selection` : identifiez les types et les noms des tables, des vues et des schémas sources à charger. Pour de plus amples informations, veuillez consulter [Règles et actions de sélection](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Selections.md).
+ Règles `transformation` : spécifiez certaines modifications ou certains ajouts apportés à des tables et des schémas sources particuliers dans la source avant qu’ils ne soient chargés dans la cible. Pour de plus amples informations, veuillez consulter [Règles et actions de transformation](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Transformations.md).
En outre, pour définir le contenu des colonnes nouvelles et existantes, vous pouvez utiliser une expression dans une règle de transformation. Pour de plus amples informations, veuillez consulter [Utilisation d'expressions de règle de transformation pour définir le contenu d’une colonne](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions.md).
+ Règles `table-settings` : spécifiez la façon dont les tâches DMS chargent les données des tables individuelles. Pour de plus amples informations, veuillez consulter [Règles des paramètres de table et de collection et opérations](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.md).
**Note**
Pour les cibles Amazon S3, vous pouvez également baliser les objets S3 mappés aux tables et aux schémas sélectionnés à l’aide du type de règle `post-processing` et de l’action de règle `add-tag`. Pour de plus amples informations, veuillez consulter [Balisage d’objets Amazon S3](CHAP_Target.S3.md#CHAP_Target.S3.Tagging).
Pour les cibles suivantes, vous pouvez spécifier comment et où migrer les schémas et les tables sélectionnés vers la cible à l’aide du type de règle `object-mapping` :
Amazon DynamoDB : pour plus d’informations, consultez [Utilisation du mappage d’objet pour migrer les données vers DynamoDB](CHAP_Target.DynamoDB.md#CHAP_Target.DynamoDB.ObjectMapping).
Amazon Kinesis : pour plus d’informations, consultez [Utilisation du mappage d’objet pour migrer les données vers un flux de données Kinesis](CHAP_Target.Kinesis.md#CHAP_Target.Kinesis.ObjectMapping).
Apache Kafka : pour plus d’informations, consultez [Utilisation du mappage d’objet pour migrer les données vers une rubrique Kafka](CHAP_Target.Kafka.md#CHAP_Target.Kafka.ObjectMapping).
# Règles et actions de sélection
Le mappage de tables vous permet de spécifier les tables, vues ou schémas que vous voulez utiliser grâce aux actions et règles de sélection. Pour les règles de mappage de tables qui utilisent le type de règle de sélection, vous pouvez appliquer les valeurs suivantes :
**Avertissement**
N'incluez aucune donnée sensible dans ces règles.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/dms/latest/userguide/CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Selections.html)
**Example Migrer toutes les tables dans un schéma**
L'exemple suivant migre toutes les tables d'un schéma nommé `Test` de la source vers votre point de terminaison cible.
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "Test",
"table-name": "%"
},
"rule-action": "include"
}
]
}
```
**Example Migrer certaines tables d'un schéma**
L'exemple suivant migre toutes les tables, sauf celles commençant par `DMS`, d'un schéma nommé `Test` de la source vers votre point de terminaison cible.
```
{
"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 Migration d'une table unique spécifiée dans un schéma unique**
L'exemple suivant migre la table `Customer` du schéma `NewCust` de votre source vers votre point de terminaison cible.
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "NewCust",
"table-name": "Customer"
},
"rule-action": "explicit"
}
]
}
```
Vous pouvez explicitement procéder à une sélection dans plusieurs tables et schémas en spécifiant plusieurs règles de sélection.
**Example Migration des tables dans un ordre défini**
Les tables et les vues sont migrées en fonction de leurs valeurs d'ordre de chargement, les valeurs les plus élevées étant prioritaires dans la séquence de migration. L'exemple suivant fait migrer deux tables, `loadfirst` avec une valeur de priorité de 2 et `loadsecond` une valeur de priorité de 1. La tâche de migration doit d'abord traiter la `loadfirst` table avant de passer à la `loadsecond` table. Ce mécanisme de priorisation garantit que les dépendances entre les objets de base de données sont respectées pendant le processus de migration.
```
{
"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"
}
]
}
```
**Note**
`load-order` s’applique à l’initialisation de la table. Le chargement d’une table successive n’attendra pas la fin du chargement d’une table précédente si `MaxFullLoadSubTasks` est supérieur à 1.
**Example Migrer certaines vues d'un schéma**
L'exemple suivant migre certaines vues d'un schéma nommé `Test` de votre source vers des tables équivalentes dans votre cible.
```
{
"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 Migrer toutes les tables et vues d'un schéma**
L'exemple suivant migre toutes les tables et vues d'un schéma nommé `report` de votre source vers des tables équivalentes dans votre cible.
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "3",
"rule-name": "3",
"object-locator": {
"schema-name": "report",
"table-name": "%",
"table-type": "all"
},
"rule-action": "include"
}
]
}
```
# Caractères génériques dans le mappage de table
Cette section décrit les caractères génériques que vous pouvez utiliser lorsque vous spécifiez les noms de schéma et de table pour le mappage de table.
| Caractère générique | Correspondance |
| --- |--- |
| % | Zéro ou plus de caractères |
| \$1 | Un seul personnage |
| [\$1] | Un caractère de soulignement littéral |
| [ab] | Un ensemble de personnages. Par exemple, [ab] correspond à « a » ou à « b ». |
| [a-d] | Une gamme de personnages. Par exemple, [a-d] correspond à « a », « b », « c » ou « d ». |
Pour les points de terminaison sources et cibles Oracle, vous pouvez utiliser l’attribut de connexion supplémentaire `escapeCharacter` pour spécifier un caractère d’échappement. Un caractère d’échappement vous permet d’utiliser un caractère générique spécifique dans les expressions comme s’il ne s’agissait pas d’un caractère générique. Par exemple, `escapeCharacter=#` vous permet d’utiliser « \$1 » pour faire en sorte qu’un caractère générique agisse comme un caractère ordinaire dans une expression, comme dans l’exemple de code suivant.
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "542485267",
"rule-name": "542485267",
"object-locator": { "schema-name": "ROOT", "table-name": "TEST#_T%" },
"rule-action": "include",
"filters": []
}
]
}
```
Ici, le caractère d'échappement « \$1 » fait en sorte que le caractère générique « \$1 » agisse comme un caractère normal. AWS DMS sélectionne les tables dans le schéma nommé`ROOT`, où chaque table a un nom avec `TEST_T` comme préfixe.
# Règles et actions de transformation
Les actions de transformation permettent de spécifier les transformations que vous souhaitez appliquer au schéma, à la table ou à la vue sélectionné(e). Les règles de transformation sont facultatives.
## Limitations
+ Vous ne pouvez pas appliquer plusieurs actions de règle de transformation au même objet (schéma, table, colonne, table-tablespace ou index-tablespace). Vous pouvez appliquer plusieurs actions de règle de transformation à n’importe quel niveau, à condition que chaque action de transformation soit appliquée à un objet différent. Toutefois, cette restriction n'est pas applicable lorsque vous utilisez des règles de transformation de masquage de données dans lesquelles vous pouvez avoir une autre transformation similaire `ADD-COLUMN` ou `CHANGE-DATA-TYPE` pour la même colonne.
+ Les noms de table et de colonne sont sensibles à la casse dans les règles de transformation. Par exemple, vous devez fournir les noms de table et de colonne d’une base de données Oracle ou Db2 en majuscules.
+ Les transformations ne sont pas prises en charge pour les noms de colonnes contenant des Right-to-Left langues.
+ Les transformations ne peuvent pas être effectuées sur des colonnes dont le nom contient des caractères spéciaux (par exemple, \$1, \$1, /, -).
+ La seule transformation prise en charge pour les colonnes mappées à BLOB/CLOB des types de données consiste à déposer la colonne sur la cible.
+ AWS DMS ne prend pas en charge la réplication de deux tables sources vers une seule table cible. AWS DMS réplique les enregistrements de table en table et de colonne en colonne, conformément aux règles de transformation de la tâche de réplication. Les noms des objets doivent être uniques pour éviter tout chevauchement.
Par exemple, une table source possède une colonne nommée `ID` et la table cible correspondante possède une colonne préexistante appelée `id`. Si une règle utilise une `ADD-COLUMN` instruction pour ajouter une nouvelle colonne appelée`id`, et une SQLite instruction pour remplir la colonne avec des valeurs personnalisées, cela crée un double nom `id` d'objet ambigu qui n'est pas pris en charge.
+ Lorsque vous créez une règle de transformation, nous vous recommandons d'utiliser le `data-type` paramètre uniquement lorsque les règles de sélection spécifient plusieurs colonnes, par exemple lorsque vous définissez `column-name` sur`%`. Nous vous déconseillons de l'utiliser `data-type` pour sélectionner une seule colonne.
+ AWS DMS ne prend pas en charge les règles de transformation dans lesquelles les objets source et cible (tables) se trouvent dans la même base de données/le même schéma. L'utilisation de la même table comme source et comme cible dans une règle de transformation peut entraîner des résultats inattendus et potentiellement dangereux, notamment des altérations involontaires des données de la table, une modification des structures de table ou même la suppression de tables.
## Valeurs
Pour les règles de mappage de tables qui utilisent le type de règle de transformation, vous pouvez appliquer les valeurs suivantes :
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/dms/latest/userguide/CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Transformations.html)
## Exemples
**Example Renommer un schéma**
L'exemple suivant renomme un schéma `Test` de votre source en `Test1` dans votre cible.
```
{
"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 Renommer une table**
L'exemple suivant renomme une table `Actor` de votre source en `Actor1` dans votre cible.
```
{
"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 Renommer une colonne**
L'exemple suivant renomme une colonne de la table `Actor` en remplaçant `first_name` dans votre source par `fname` dans votre cible.
```
{
"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 Renommer un espace de table de table Oracle**
L'exemple suivant renomme l'espace de table de table nommé `SetSpace` d'une table nommée `Actor` dans votre source Oracle en `SceneTblSpace` dans votre point de terminaison cible 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 Renommer un espace de table d'index Oracle**
L'exemple suivant renomme l'espace de table d'index nommé `SetISpace` d'une table nommée `Actor` dans votre source Oracle en `SceneIdxSpace` dans votre point de terminaison cible 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 Ajouter une colonne**
Dans l'exemple suivant une colonne `datetime` est ajoutée à la table `Actor` du schéma `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 Supprimer une colonne**
L'exemple suivant transforme la table nommée `Actor` dans votre source pour en supprimer toutes les colonnes commençant par les caractères `col` dans votre cible.
```
{
"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 Convertir en minuscules**
L'exemple suivant convertit un nom de table `ACTOR` dans votre source en `actor` dans votre cible.
```
{
"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 Convertir en majuscules**
L'exemple suivant convertit toutes les colonnes de toutes les tables et tous les schémas en les faisant passer de lettres minuscules dans votre source à des lettres majuscules dans votre cible.
```
{
"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 Ajouter un préfixe**
L'exemple suivant transforme toutes les tables de votre source en leur ajoutant le préfixe `DMS_` dans votre cible.
```
{
"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 Remplacer un préfixe**
L'exemple suivant transforme toutes les colonnes contenant le préfixe `Pre_` dans votre source en remplaçant le préfixe par `NewPre_` dans votre cible.
```
{
"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 Supprimer un suffixe**
L'exemple suivant transforme toutes les tables de votre source en leur supprimant le suffixe `_DMS` dans votre cible.
```
{
"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 Définir une clé primaire**
L'exemple suivant définit une clé primaire nommée `ITEM-primary-key` sur trois colonnes de la table `ITEM` migrée vers votre point de terminaison cible.
```
{
"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 Définir un index unique**
L'exemple suivant définit un index unique nommé `ITEM-unique-idx` sur trois colonnes de la table `ITEM` migrée vers votre point de terminaison cible.
```
{
"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 Modification du type de données de la colonne cible**
L'exemple suivant remplace le type de données d'une colonne cible nommée `SALE_AMOUNT` à partir d'un type de données existant par `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 Ajouter une colonne d'image antérieure**
Pour une colonne source appelée `emp_no`, la règle de transformation de l'exemple suivant ajoute une nouvelle colonne appelée `BI_emp_no` dans la cible.
```
{
"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"
}
}
]
}
```
Ici, l’instruction suivante remplit une colonne `BI_emp_no` dans la ligne correspondante avec 1.
```
UPDATE employees SET emp_no = 3 WHERE BI_emp_no = 1;
```
Lorsque vous écrivez des mises à jour CDC pour AWS DMS les cibles prises en charge, la `BI_emp_no` colonne permet de savoir quelles lignes contiennent des valeurs mises à jour dans la `emp_no` colonne.
# Utilisation d'expressions de règle de transformation pour définir le contenu d’une colonne
Pour définir le contenu de colonnes nouvelles et existantes, vous pouvez utiliser une expression dans une règle de transformation. Par exemple, des expressions peuvent vous permettre d’ajouter une colonne ou de répliquer des en-têtes de table source à une cible. Vous pouvez également utiliser des expressions pour signaler des enregistrements des tables cibles comme insérés, mis à jour ou supprimés à la source.
**Topics**
+ [
## Ajouter une colonne à l'aide d'une expression
](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-adding)
+ [
## Signalement d'enregistrements cibles à l'aide d'une expression
](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-Flagging)
+ [
## Réplication des en-têtes d’une table source à l'aide d'expressions
](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-Headers)
+ [
## Utilisation de SQLite fonctions pour créer des expressions
](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-SQLite)
+ [
## Ajout de métadonnées à une table cible à l’aide d’expressions
](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-Metadata)
## Ajouter une colonne à l'aide d'une expression
Pour ajouter des colonnes à des tables à l'aide d'une expression dans une règle de transformation, utilisez une action de règle `add-column` et une cible de règle `column`.
L'exemple suivant ajoute une nouvelle colonne à la table `ITEM`. Il définit le nouveau nom de colonne sur `FULL_NAME`, avec un type de données `string` de 50 caractères. L'expression concatène les valeurs de deux colonnes existantes, `FIRST_NAME` et `LAST_NAME`, pour les évaluer selon `FULL_NAME`. `schema-name`, `table-name` et les paramètres d’expression font référence aux objets de la table de base de données source. `Value` et le bloc `data-type` font référence aux objets de la table de base de données cible.
```
{
"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
}
}
]
}
```
## Signalement d'enregistrements cibles à l'aide d'une expression
Pour signaler des enregistrements dans des tables cibles comme insérés, mis à jour ou supprimés dans la table source, utilisez une expression dans une règle de transformation. L'expression utilise une fonction `operation_indicator` pour signaler les enregistrements. Les enregistrements supprimés de la source ne sont pas supprimés de la cible. Au lieu de cela, l'enregistrement cible est signalé avec une valeur fournie par l'utilisateur pour indiquer qu'il a été supprimé de la source.
**Note**
La fonction `operation_indicator` fonctionne uniquement sur les tables qui ont une clé primaire à la fois sur les bases de données sources et cibles.
Par exemple, la règle de transformation suivante ajoute d'abord une nouvelle colonne `Operation` à une table cible. Elle met ensuite à jour la colonne avec la valeur `D` chaque fois qu'un enregistrement est supprimé d'une table source.
```
{
"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
}
}
```
## Réplication des en-têtes d’une table source à l'aide d'expressions
Par défaut, les en-têtes des tables sources ne sont pas répliqués sur la cible. Pour indiquer les en-têtes à répliquer, utilisez une règle de transformation avec une expression qui inclut l'en-tête de colonne du tableau.
Vous pouvez utiliser les en-têtes de colonne suivants dans les expressions.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/dms/latest/userguide/CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions.html)
Dans l'exemple suivant, une nouvelle colonne est ajoutée à la cible en utilisant la valeur de position du flux à partir de la source. Pour SQL Server, la valeur de position de flux est le LSN du point de terminaison source. Pour Oracle, la valeur de position de flux est le SCN du point de terminaison source.
```
{
"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
}
}
```
L’exemple suivant ajoute une nouvelle colonne à la cible qui possède un nombre incrémentiel unique issu de la source. Cette valeur représente un nombre unique à 35 chiffres au niveau de la tâche. Les 16 premiers chiffres font partie d’un horodatage et les 19 derniers chiffres sont le numéro record\$1id incrémenté par le SGBD.
```
{
"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
}
}
```
## Utilisation de SQLite fonctions pour créer des expressions
Vous utilisez les paramètres de table pour spécifier les paramètres que vous souhaitez appliquer à la table ou à la vue sélectionnée pour une opération spécifiée. Les règles table-settings sont facultatives.
**Note**
Plutôt que d’utiliser des tables et des vues, les bases de données MongoDB et DocumentDB stockent les enregistrements de données sous forme de documents regroupés dans des *collections*. Ainsi, lors de la migration depuis une source MongoDB ou DocumentDB, prenez en compte le type de segmentation par plage des paramètres de chargement parallèle pour les *collections* sélectionnées plutôt que les tables et les vues.
**Topics**
+ [
### Utilisation d’une expression CASE
](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-SQLite.CASE)
+ [
### Exemples
](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-SQLite.Ex)
Vous trouverez ci-dessous les fonctions de chaîne que vous pouvez utiliser pour créer des expressions de règle de transformation.
| Fonctions de chaîne | Description |
| --- | --- |
| `lower(x)` | La fonction `lower(x)` renvoie une copie de la chaîne *`x`* avec tous les caractères convertis en minuscules. La fonction `lower` intégrée par défaut fonctionne uniquement pour les caractères ASCII. |
| `upper(x)` | La fonction `upper(x)` renvoie une copie de la chaîne *`x`* avec tous les caractères convertis en majuscules. La fonction `upper` intégrée par défaut fonctionne uniquement pour les caractères ASCII. |
| `ltrim(x,y)` | La fonction `ltrim(x,y)` renvoie une chaîne constituée en supprimant du côté gauche de x tous les caractères qui apparaissent dans y. S’il n’y a aucune valeur pour y, `ltrim(x)` supprime les espaces du côté gauche de x. |
| `replace(x,y,z)` | La fonction `replace(x,y,z)` renvoie une chaîne constituée en substituant la chaîne z pour chaque occurrence de la chaîne y dans la chaîne x. |
| `rtrim(x,y)` | La fonction `rtrim(x,y)` renvoie une chaîne constituée en supprimant du côté droit de x tous les caractères qui apparaissent dans y. S’il n’y a aucune valeur pour y, `rtrim(x)` supprime les espaces du côté droit de x. |
| `substr(x,y,z)` | La fonction `substr(x,y,z)` renvoie une sous-chaîne de la chaîne d’entrée `x` qui commence par le `y`ème caractère et qui comporte *`z`* caractères. Si *`z`* est omis, `substr(x,y)` renvoie tous les caractères jusqu’à la fin de la chaîne `x` en commençant par le `y`ème caractère. Le caractère le plus à gauche de `x` est le 1er caractère. Si *`y`* est négatif, le premier caractère de la sous-chaîne est trouvé en comptant à partir de la droite plutôt que de la gauche. Si *`z`* est négatif, les `abs(z)` caractères précédant le `y`ème caractère sont renvoyés. Si `x` est une chaîne, les index des caractères font référence aux caractères UTF-8 réels. Si `x` est un objet BLOB, les index font référence à des octets. |
| trim(x,y) | La fonction `trim(x,y)` renvoie une chaîne constituée en supprimant des deux côtés de `x` tous les caractères qui apparaissent dans `y`. Si `y` n’a pas de valeur, `trim(x)` supprime les espaces des deux côtés de `x`. |
Vous trouverez ci-dessous les fonctions LOB que vous pouvez utiliser pour créer des expressions de règle de transformation.
| Fonctions LOB | Description |
| --- | --- |
| `hex(x)` | La fonction `hex` reçoit un objet BLOB en tant qu’argument et renvoie une version en chaîne hexadécimale en majuscules du contenu BLOB. |
| `randomblob (N)` | La fonction `randomblob(N)` renvoie un objet BLOB de `N` octet(s) contenant des octets pseudo-aléatoires. S'il *N* est inférieur à 1, un BLOB aléatoire de 1 octet est renvoyé. |
| `zeroblob(N)` | La fonction `zeroblob(N)` renvoie un objet BLOB composé de `N` octet(s) de 0x00. |
Vous trouverez ci-dessous les fonctions numériques que vous pouvez utiliser pour créer des expressions de règle de transformation.
| Fonctions numériques | Description |
| --- | --- |
| `abs(x)` | La fonction `abs(x)` renvoie la valeur absolue de l’argument numérique `x`. La `abs(x)` fonction renvoie NULL si cette valeur *x* est NULL. La `abs(x)` fonction renvoie 0,0 s'il s'**x**agit d'une chaîne ou d'un BLOB qui ne peut pas être converti en valeur numérique. |
| `random()` | La fonction `random` renvoie un entier pseudo-aléatoire compris entre -9 223 372 036 854 775 808 et \$19 223 372 036 854 775 807. |
| `round (x,y)` | La `round (x,y)` fonction renvoie une valeur à virgule flottante *x* arrondie aux *y* chiffres situés à droite de la virgule décimale. S'il n'y a aucune valeur pour*y*, elle est supposée être 0. |
| `max (x,y...)` | La fonction `max` à plusieurs arguments renvoie l’argument avec la valeur maximale, ou renvoie NULL si l’un des arguments est NULL. La fonction `max` recherche dans ses arguments de gauche à droite un argument qui définit une fonction de classement. Si elle en trouve un, elle utilise cette fonction de classement pour toutes les comparaisons de chaînes. Si aucun des arguments de `max` ne définit une fonction de classement, la fonction de classement `BINARY` est utilisée. La fonction `max` est une fonction simple lorsqu’elle possède deux arguments ou plus, mais elle fonctionne comme une fonction d’agrégation si elle n’a qu’un seul argument. |
| `min (x,y...)` | La fonction `min` à plusieurs arguments renvoie l’argument avec la valeur minimale. La fonction `min` recherche dans ses arguments de gauche à droite un argument qui définit une fonction de classement. Si elle en trouve un, elle utilise cette fonction de classement pour toutes les comparaisons de chaînes. Si aucun des arguments de `min` ne définit une fonction de classement, la fonction de classement `BINARY` est utilisée. La fonction `min` est une fonction simple lorsqu’elle possède deux arguments ou plus, mais elle fonctionne comme une fonction d’agrégation si elle n’a qu’un seul argument. |
Vous trouverez ci-dessous les fonctions de vérification NULL que vous pouvez utiliser pour créer des expressions de règle de transformation.
| Fonctions de vérification NULL | Description |
| --- | --- |
| `coalesce (x,y...)` | La fonction `coalesce` renvoie une copie de son premier argument non NULL, mais elle renvoie NULL si tous les arguments sont NULL. La fonction coalesce comporte au moins deux arguments. |
| `ifnull(x,y)` | La fonction `ifnull` renvoie une copie de son premier argument non NULL, mais elle renvoie NULL si les deux arguments sont NULL. La fonction `ifnull` possède exactement deux arguments. La fonction `ifnull` est identique à `coalesce` avec deux arguments. |
| `nullif(x,y)` | La fonction `nullif(x,y)` renvoie une copie de son premier argument si les arguments sont différents, mais elle renvoie NULL si les arguments sont identiques. La fonction `nullif(x,y)` recherche dans ses arguments de gauche à droite un argument qui définit une fonction de classement. Si elle en trouve un, elle utilise cette fonction de classement pour toutes les comparaisons de chaînes. Si aucun des arguments NULLIF ne définit de fonction de classement, la fonction de classement `BINARY` est utilisée. |
Vous trouverez ci-dessous les fonctions de date/heure que vous pouvez utiliser pour créer des expressions de règle de transformation.
| Fonctions de date et d’heure | Description |
| --- | --- |
| `date(timestring, modifier, modifier...)` | La `date` fonction renvoie la date au format YYYY-MM-DD. |
| `time(timestring, modifier, modifier...)` | La fonction `time` renvoie l’heure au format HH:MM:SS. |
| `datetime(timestring, modifier, modifier...)` | La `datetime` fonction renvoie la date et l'heure au format YYYY-MM-DD HH:MM:SS. |
| `julianday(timestring, modifier, modifier...)` | La fonction `julianday` renvoie le nombre de jours écoulés depuis midi, heure de Greenwich, le 24 novembre 4714 av JC. |
| `strftime(format, timestring, modifier, modifier...)` | La fonction `strftime` renvoie la date conformément à la chaîne de format spécifiée comme premier argument, en utilisant l’une des variables suivantes : `%d` : jour du mois `%H` : heure entre 00 et 24 `%f` :\$1\$1 fractions de seconde SS.SSS `%j` : jour de l’année entre 001 et 366 `%J` :\$1\$1 numéro du jour julien `%m` : mois entre 01 et 12 `%M` : minute entre 00 et 59 `%s` : secondes depuis le 01/01/1970 `%S` : secondes entre 00 et 59 `%w` : jour de la semaine entre 0 et 6, dimanche = 0 `%W` : semaine de l’année entre 00 et 53 `%Y` : année entre 0000 et 9999 `%%`: % |
Vous trouverez ci-dessous une fonction de hachage que vous pouvez utiliser pour créer des expressions de règle de transformation.
| Fonction de hachage | Description |
| --- | --- |
| `hash_sha256(x)` | La fonction `hash` génère une valeur de hachage pour une colonne d’entrée (à l’aide de l’algorithme SHA-256) et renvoie la valeur hexadécimale de la valeur de hachage générée. Pour utiliser la fonction `hash` dans une expression, ajoutez `hash_sha256(x)` à l’expression et remplacez *`x`* par le nom de la colonne source. |
### Utilisation d’une expression CASE
L' SQLite `CASE`expression évalue une liste de conditions et renvoie une expression en fonction du résultat. La syntaxe est la suivante.
```
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
```
### Exemples
**Example d’ajout d’une nouvelle colonne de chaîne à la table cible en utilisant une condition de casse**
L’exemple de règle de transformation suivant ajoute une nouvelle colonne de chaîne `emp_seniority` à la table cible `employee`. Il utilise la SQLite `round` fonction de la colonne des salaires, avec une condition de cas pour vérifier si le salaire est égal ou supérieur à 20 000. Si c’est le cas, la colonne obtient la valeur `SENIOR` et tout le reste a la valeur `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 d'ajouter une nouvelle colonne de chaîne à la table cible à l'aide d'une fonction SUBSTR**
L'exemple de règle de transformation suivant ajoute une nouvelle colonne de chaîne à l'aide d' SQLite opérateurs ou de fonctions pour définir les données d'une colonne. Cette approche implique l'utilisation de SQLite fonctions pour transformer les données GUID chargées depuis Oracle au format UUID avant de les insérer dans la table cible de Postgresql.
La règle suivante utilise les fonctions de SQLite sous-chaîne (SUBSTR), de fonction hexadécimale (HEX) et de minuscule (LOWER) pour diviser les données du GUID en plusieurs groupes séparés par des traits d'union, en particulier un groupe de 8 chiffres suivi de trois groupes de 4 chiffres suivis d'un groupe de 12 chiffres, pour un total de 32 chiffres représentant les 128 bits.
Voici les exemples de données source et de sortie sur le post-traitement cible via la règle de transformation :
**Tableau source (format Oracle GUID)**
T\$1 COL2
```
06F6949D234911EE80670242AC120002
1A2B3C4D5E6F11EE80670242AC120003
F5E4D3C2B1A011EE80670242AC120004
```
**Table cible (format UUID 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 d’ajout d’une nouvelle colonne de date à la table cible**
L’exemple suivant ajoute une nouvelle colonne de date `createdate` à la table cible `employee`. Lorsque vous utilisez la fonction de SQLite date`datetime`, la date est ajoutée à la table nouvellement créée pour chaque ligne insérée.
```
{
"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 d’ajout d’une nouvelle colonne numérique à la table cible**
L’exemple suivant ajoute une nouvelle colonne numérique `rounded_emp_salary` à la table cible `employee`. Elle utilise la SQLite `round` fonction pour ajouter le salaire arrondi.
```
{
"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 d’ajout d’une nouvelle colonne de chaîne à la table cible en utilisant la fonction de hachage**
L’exemple suivant ajoute une nouvelle colonne de chaîne `hashed_emp_number` à la table cible `employee`. La SQLite `hash_sha256(x)` fonction crée des valeurs hachées sur la cible pour la colonne source,`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
}
}
```
## Ajout de métadonnées à une table cible à l’aide d’expressions
Vous pouvez ajouter les informations de métadonnées à la table cible en utilisant les expressions suivantes :
+ `$AR_M_SOURCE_SCHEMA` : nom du schéma source.
+ `$AR_M_SOURCE_TABLE_NAME` : nom de la table source.
+ `$AR_M_SOURCE_COLUMN_NAME` : nom d’une colonne de la table source.
+ `$AR_M_SOURCE_COLUMN_DATATYPE` : type de données d’une colonne de la table source.
**Example d’ajout d’une colonne pour un nom de schéma en utilisant le nom de schéma issu de la source**
L’exemple suivant ajoute une nouvelle colonne nommée `schema_name` à la cible en utilisant le nom de schéma issu de la source.
```
{
"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
}
}
```
# Règles des paramètres de table et de collection et opérations
Utilisez les paramètres de table pour spécifier les paramètres que vous souhaitez appliquer à une table ou une vue sélectionnée pour une opération spécifiée. Les règles des paramètres de table sont facultatives, en fonction des exigences en matière de point de terminaison et de migration.
Plutôt que d’utiliser des tables et des vues, les bases de données MongoDB et Amazon DocumentDB stockent les enregistrements de données sous forme de documents regroupés dans des *collections*. Pour n’importe quel point de terminaison MongoDB ou Amazon DocumentDB, une base de données unique est un ensemble spécifique de collections identifiées par le nom de la base de données.
Lorsque vous migrez à partir d’une source MongoDB ou Amazon DocumentDB, vous utilisez les paramètres de chargement parallèle de manière légèrement différente. Dans ce cas, prenez en compte le type de segmentation par plage ou de segmentation automatique des paramètres de chargement parallèle pour les collections sélectionnées plutôt que les tables et les vues.
**Topics**
+ [
## Les caractères génériques dans les paramètres de table sont limités
](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.Wildcards)
+ [
## Utilisation du chargement parallèle pour certaines tables, vues et collections
](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.ParallelLoad)
+ [
## Spécification des paramètres LOB pour une table ou une vue sélectionnée
](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.LOB)
+ [
## Exemples de paramètres de table
](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.Examples)
Pour les règles de mappage de tables qui utilisent le type de règle des paramètres de table (table-settings), vous pouvez appliquer les paramètres suivants.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/dms/latest/userguide/CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.html)
## Les caractères génériques dans les paramètres de table sont limités
L’utilisation du caractère générique de pourcentage (`"%"`) dans les règles `"table-settings"` n’est pas prise en charge pour les bases de données sources, comme indiqué ci-dessous.
```
{
"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 vous utilisez `"%"` les `"table-settings"` règles comme indiqué, AWS DMS renvoie alors l'exception suivante.
```
Error in mapping rules. Rule with ruleId = x failed validation. Exact
schema and table name required when using table settings rule.
```
En outre, il vous AWS recommande de ne pas charger un grand nombre de collections volumineuses à l'aide d'une seule tâche avec`parallel-load`. Notez que AWS DMS limite la contention des ressources ainsi que le nombre de segments chargés en parallèle par la valeur du paramètre de tâche `MaxFullLoadSubTasks`, avec une valeur maximale de 49.
Spécifiez plutôt toutes les collections de la base de données source pour les plus grandes collections en spécifiant individuellement chaque `"schema-name"` et `"table-name"`. Augmentez également votre migration de manière appropriée. Par exemple, exécutez plusieurs tâches sur un nombre suffisant d’instances de réplication pour gérer un grand nombre de collections volumineuses dans la base de données.
## Utilisation du chargement parallèle pour certaines tables, vues et collections
Pour accélérer la migration et la rendre plus efficace, vous pouvez utiliser le chargement parallèle pour certaines tables, vues et collections relationnelles. En d’autres termes, vous pouvez migrer une seule table, vue ou collection segmentée en utilisant plusieurs threads en parallèle. Pour ce faire, AWS DMS divisez une tâche à chargement complet en fils, chaque segment de table étant affecté à son propre fil.
À l’aide de ce processus de chargement parallèle, plusieurs threads peuvent décharger plusieurs tables, vues et collections en parallèle à partir du point de terminaison source. Ensuite, plusieurs threads peuvent migrer et charger les mêmes tables, vues et collections en parallèle vers le point de terminaison cible. Pour certains moteurs de base de données, vous pouvez segmenter les tables et vues par partitions ou sous-partitions existantes. Pour les autres moteurs de base de données, vous pouvez segmenter AWS DMS automatiquement les collections en fonction de paramètres spécifiques (autosegmentation). Sinon, vous pouvez segmenter n’importe quelle table, vue ou collection par des plages de valeurs de colonne que vous spécifiez.
Le chargement parallèle est pris en charge pour les points de terminaison source suivants :
+ Oracle
+ Microsoft SQL Server
+ MySQL
+ PostgreSQL
+ IBM Db2 LUW
+ SAP Adaptive Server Enterprise (ASE)
+ MongoDB (prend uniquement en charge les options de segmentation automatique et de segmentation par plage d’un chargement complet parallèle)
+ Amazon DocumentDB (prend uniquement en charge les options de segmentation automatique et de segmentation par plage d’un chargement complet parallèle)
Pour les points de terminaison MongoDB et Amazon DocumentDB AWS DMS , prend en charge les types de données suivants pour les colonnes qui sont des clés de partition pour l'option de segmentation de plage d'un chargement complet en parallèle.
+ Double
+ String
+ ObjectId
+ Entier 32 bits
+ Entier 64 bits
La charge parallèle à utiliser avec les règles de définition de table est prise en charge pour les points de terminaison cibles suivants :
+ Oracle
+ Microsoft SQL Server
+ MySQL
+ PostgreSQL
+ Amazon S3
+ SAP Adaptive Server Enterprise (ASE)
+ Amazon Redshift
+ MongoDB (prend uniquement en charge les options de segmentation automatique et de segmentation par plage d’un chargement complet parallèle)
+ Amazon DocumentDB (prend uniquement en charge les options de segmentation automatique et de segmentation par plage d’un chargement complet parallèle)
+ Db2 LUW
Pour spécifier le nombre maximal de tables et de vues à charger en parallèle, utilisez le paramètre de tâche `MaxFullLoadSubTasks`.
Pour spécifier le nombre maximal de threads par table ou vue pour les cibles prises en charge d’une tâche de chargement parallèle, définissez davantage de segments à l’aide de limites de valeurs de colonnes.
**Important**
`MaxFullLoadSubTasks` contrôle le nombre de tables ou de segments de table à charger en parallèle. `ParallelLoadThreads` contrôle le nombre de threads utilisés par une tâche de migration pour exécuter les chargements en parallèle. *Ces paramètres sont multiplicatifs*. Ainsi, le nombre total de threads utilisés lors d’une tâche de chargement complet correspond approximativement au résultat de la valeur de `ParallelLoadThreads ` multipliée par la valeur de `MaxFullLoadSubTasks` (`ParallelLoadThreads` **\$1** `MaxFullLoadSubtasks)`).
Si vous créez des tâches avec un grand nombre de sous-tâches de chargement complet et un grand nombre de threads de chargement parallèle, votre tâche peut consommer trop de mémoire et échouer.
Pour spécifier le nombre maximal de threads par table pour les cibles Amazon DynamoDB, Amazon Kinesis Data Streams, Apache Kafka ou Amazon Elasticsearch Service, utilisez le paramètre de tâche de métadonnées cible `ParallelLoadThreads`.
Pour spécifier la taille du tampon pour une tâche de chargement parallèle lorsque `ParallelLoadThreads` est utilisé, utilisez le paramètre de tâche de métadonnées cible `ParallelLoadBufferSize`.
La disponibilité et les paramètres de `ParallelLoadThreads` et `ParallelLoadBufferSize` dépendent du point de terminaison cible.
Pour plus d’informations sur les paramètres `ParallelLoadThreads` et `ParallelLoadBufferSize`, consultez [Paramètres de métadonnées des tâches cibles](CHAP_Tasks.CustomizingTasks.TaskSettings.TargetMetadata.md). Pour plus d'informations sur le paramètre `MaxFullLoadSubTasks`, consultez [Paramètres de tâche de chargement complet](CHAP_Tasks.CustomizingTasks.TaskSettings.FullLoad.md). Pour obtenir des informations spécifiques sur les points de terminaison cible, consultez les rubriques connexes.
Pour utiliser le chargement parallèle, créez une règle de mappage de table de type `table-settings` avec l'option `parallel-load`. Dans la règle `table-settings`, vous pouvez spécifier les critères de segmentation d’une table, d’une vue ou d’une collection unique que vous voulez charger en parallèle. Pour ce faire, définissez le paramètre `type` de l'option `parallel-load` sur l'une de plusieurs options.
Le choix effectué dépendra de la façon dont vous souhaitez segmenter la table, la vue ou la collection pour le chargement parallèle :
+ Par partitions (ou segments) : chargez toutes les partitions (ou segments) de table ou de vue existantes à l’aide du type `partitions-auto`. Sinon, chargez uniquement les partitions sélectionnées à l’aide du type `partitions-list` avec un tableau de partitions spécifié.
Pour les points de terminaison MongoDB et Amazon DocumentDB uniquement, chargez toutes les collections ou les collections spécifiées par segments AWS DMS qui calculent automatiquement également en utilisant `partitions-auto` le type et des paramètres facultatifs supplémentaires. `table-settings`
+ (Points de terminaison Oracle uniquement) Par sous-partitions : chargez toutes les sous-partitions de table ou de vue existantes à l’aide du type `subpartitions-auto`. Ou chargez uniquement les sous-partitions sélectionnées en utilisant le type `partitions-list` avec un tableau `subpartitions` spécifié.
+ Par segments que vous définissez : chargez les segments de table, de vue ou de collection que vous définissez à l’aide des limites de valeur de colonne. Pour ce faire, utilisez le type `ranges` avec les tableaux `columns` et `boundaries` spécifiés.
**Note**
Les points de terminaison PostgreSQL ne prennent en charge que ce type de chargement parallèle. MongoDB et Amazon DocumentDB en tant que points de terminaison sources prennent en charge à la fois ce type de segmentation par plage et le type de segmentation automatique d’un chargement complet parallèle (`partitions-auto`).
Pour identifier les tables, les vues ou les collections supplémentaires à charger en parallèle, spécifiez des objets `table-settings` supplémentaires avec les options `parallel-load`.
Les procédures suivantes décrivent comment coder le JSON pour chaque type de chargement parallèle, du plus simple au plus complexe.
**Pour spécifier toutes les partitions de table, de vue ou de collection, ou toutes les sous-partitions de table ou de vue**
+ Spécifiez `parallel-load` avec le type `partitions-auto` ou le type `subpartitions-auto` (mais pas les deux).
Chaque partition (ou segment) ou sous-partition de table, de vue ou de collection est alors allouée automatiquement à son propre thread.
Pour certains points de terminaison, le chargement parallèle comporte des partitions ou sous-partitions uniquement si elles sont déjà définies pour la table ou la vue. Pour les points de terminaison sources MongoDB et Amazon DocumentDB, vous pouvez calculer automatiquement AWS DMS les partitions (ou les segments) en fonction de paramètres supplémentaires facultatifs. Cela inclut `number-of-partitions`, `collection-count-from-metadata`, `max-records-skip-per-page` et `batch-size`.
**Pour spécifier des partitions ou des sous-partitions de table ou de vue sélectionnées, ou les deux**
1. Spécifiez `parallel-load` avec le type `partitions-list`.
1. (Facultatif) Incluez les partitions en spécifiant une liste de noms de partitions comme valeur de `partitions`.
Chaque partition spécifiée est alors allouée à son propre thread.
**Important**
Pour les points de terminaison Oracle, assurez-vous que les partitions et les sous-partitions ne se chevauchent pas lorsque vous les choisissez pour le chargement parallèle. Si vous utilisez des partitions et des sous-partitions qui se chevauchent pour charger des données en parallèle, les entrées sont dupliquées ou le chargement échoue en raison d’une violation de clé primaire en double.
1. (Facultatif) Pour les points de terminaison Oracle uniquement, incluez les sous-partitions en définissant un tableau de noms de sous-partitions comme valeur de `subpartitions`.
Chaque sous-partition spécifiée est alors allouée à son propre thread.
**Note**
Le chargement parallèle comporte des partitions ou sous-partitions uniquement si elles sont déjà définies pour la table ou la vue.
Vous pouvez spécifier des segments de table ou de vue en tant que plages de valeurs de colonne. Lorsque vous procédez ainsi, vous devez être conscient de ces caractéristiques de la colonne :
+ La spécification de colonnes indexées améliore considérablement les performances.
+ Vous pouvez spécifier jusqu'à 10 colonnes.
+ Vous ne pouvez pas utiliser de colonnes pour définir les limites des segments avec les types de AWS DMS données suivants : DOUBLE, FLOAT, BLOB, CLOB et NCLOB
+ Les enregistrements avec des valeurs null ne sont pas répliqués.
**Pour spécifier des segments de table, de vue ou de collection en tant que plages de valeurs de colonne**
1. Spécifiez `parallel-load` avec le type `ranges`.
1. Définissez une limite entre les segments de table ou de vue en spécifiant une liste de noms de colonne comme valeur de `columns`. Faites la même chose pour chaque colonne pour laquelle vous souhaitez définir une limite entre les segments de table ou de vue.
Notez que l'ordre des colonnes est significatif. Ici, la première colonne est la plus significative et la dernière colonne est la moins significative pour la définition de chaque limite, comme décrit ci-après.
1. Pour définir les plages de données pour tous les segments de table ou de vue, spécifiez un tableau de limites comme valeur pour `boundaries`. Un *tableau de limites* est un tableau de tableaux de valeurs de colonne. Pour ce faire, effectuez les étapes suivantes :
1. Spécifiez chaque élément d'un tableau de valeurs de colonne comme valeur qui correspond à chaque colonne. Un *tableau de valeurs de colonne* représente la limite supérieure de chaque segment de table ou de vue que vous souhaitez définir. Spécifiez chaque colonne dans le même ordre que celui où vous avez spécifié cette colonne dans le tableau `columns`.
Entrez les valeurs des colonnes DATE au format pris en charge par la source.
1. Spécifiez chaque tableau de valeurs de colonne comme limite supérieure, dans l'ordre, de chaque segment depuis le bas jusqu'au next-to-top segment de la table ou de la vue. S'il existe des lignes au-dessus de la limite supérieure que vous spécifiez, ces lignes complètent le segment supérieur de la table ou de la vue. Par conséquent, le nombre de segments basés sur une plage est potentiellement supérieur au nombre de limites de segment dans le tableau de limites. Chaque segment basé sur une plage de ce type est alloué à son propre thread.
Toutes les données non null sont répliquées, même si vous ne définissez pas de plages de données pour toutes les colonnes de la table ou de la vue.
Supposons, par exemple, que vous définissiez trois tableaux de valeurs de colonne pour les colonnes COL1 COL2, et COL3 comme suit.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/dms/latest/userguide/CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.html)
Vous avez défini trois limites de segment pour un total possible de quatre segments.
Pour identifier les plages de lignes à répliquer pour chaque segment, l'instance de réplication applique une recherche à ces trois colonnes pour chacun des quatre segments : La recherche est similaire à ce qui suit :
**Segment 1**
Répliquez toutes les lignes où les conditions suivantes sont réunies : les valeurs des deux premières colonnes sont inférieures ou égales aux valeurs de limite supérieure de **segment 1** correspondantes. En outre, les valeurs de la troisième colonne sont inférieures aux valeurs de limite supérieure de **segment 1**.
**Segment 2**
Répliquez toutes les lignes (sauf les lignes **segment 1**) où les conditions suivantes sont réunies : les valeurs des deux premières colonnes sont inférieures ou égales aux valeurs de limite supérieure de **segment 2** correspondantes. En outre, les valeurs de la troisième colonne sont inférieures aux valeurs de limite supérieure de **segment 2**.
**Segment 3**
Répliquez toutes les lignes (sauf les lignes **segment 2**) où les conditions suivantes sont réunies : les valeurs des deux premières colonnes sont inférieures ou égales aux valeurs de limite supérieure de **segment 3** correspondantes. En outre, les valeurs de la troisième colonne sont inférieures aux valeurs de limite supérieure de **segment 3** .
**Segment 4**
Répliquer toutes les lignes restantes (sauf les lignes de **Segment 1, 2 et 3**).
Dans ce cas, l'instance de réplication crée une clause `WHERE` pour charger chaque segment comme suit :
**Segment 1**
`((COL1 < 10) OR ((COL1 = 10) AND (COL2 < 30)) OR ((COL1 = 10) AND (COL2 = 30) AND (COL3 < 105)))`
**Segment 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)))`
**Segment 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)))`
**Segment 4**
`NOT ((COL1 < 100) OR ((COL1 = 100) AND (COL2 < 12)) OR ((COL1 = 100) AND (COL2 = 12) AND (COL3 < 99)))`
## Spécification des paramètres LOB pour une table ou une vue sélectionnée
Vous pouvez définir des paramètres LOB de tâche pour une ou plusieurs tables en créant une règle de mappage de table de type `table-settings` avec l'option `lob-settings` pour un ou plusieurs objets `table-settings`.
La spécification des paramètres LOB pour les tables ou vues sélectionnées est prise en charge pour les points de terminaison source suivants :
+ Oracle
+ Microsoft SQL Server
+ MySQL
+ PostgreSQL
+ IBM Db2, selon les paramètres `mode` et `bulk-max-size`, décrits ci-après
+ SAP Adaptive Server Enterprise (ASE), selon les paramètres `mode` et `bulk-max-size`, comme décrit ci-après.
La spécification des paramètres LOB pour les tables ou vues sélectionnées est prise en charge pour les points de terminaison cible suivants :
+ Oracle
+ Microsoft SQL Server
+ MySQL
+ PostgreSQL
+ SAP ASE, selon les paramètres `mode` et `bulk-max-size`, comme décrit ci-après.
**Note**
Vous ne pouvez utiliser les types de données LOB qu'avec les tables et les vues qui incluent une clé primaire.
Pour utiliser des paramètres LOB pour une table ou une vue sélectionnée, créez une règle de mappage de table de type `table-settings` avec l'option `lob-settings`. Cette option indique le traitement des LOB pour la table ou la vue identifiée par l'option `object-locator`. Dans la règle `table-settings`, vous pouvez spécifier un objet `lob-settings` avec les paramètres suivants :
+ `mode` : spécifie le mécanisme de traitement de la migration des objets LOB pour la table ou la vue sélectionnée, comme suit :
+ `limited` : le mode LOB limité par défaut est le plus rapide et le plus efficace. Utilisez ce mode uniquement si vous LOBs êtes tous de petite taille (moins de 100 Mo) ou si le point de terminaison cible ne prend pas en charge une taille LOB illimitée. De plus`limited`, si vous en utilisez, tous LOBs doivent respecter la taille que vous avez définie`bulk-max-size`.
Dans ce mode, pour une tâche de chargement complet, l'instance de réplication migre entièrement LOBs en ligne avec d'autres types de données de colonne dans le cadre du stockage de la table ou de la vue principale. Toutefois, l'instance tronque les LOB supérieurs à votre valeur `bulk-max-size` à la taille spécifiée. Pour une tâche de chargement de capture des données de modification (CDC), l'instance migre toutes à LOBs l'aide d'une recherche dans la table source, comme dans le mode LOB complet standard (voir ci-dessous).
**Note**
Vous ne pouvez migrer des vues que pour les tâches de chargement complet.
+ `unlimited` : le mécanisme de migration pour le mode LOB complet dépend de la valeur que vous définissez pour `bulk-max-size`, comme suit :
+ **Mode LOB complet standard** : lorsque vous définissez `bulk-max-size` la valeur sur zéro, l'instance de réplication migre entièrement LOBs en utilisant le mode LOB complet standard. Ce mode nécessite une recherche dans la table ou la vue source afin de migrer tous les LOB, quelle que soit leur taille. Cela entraîne généralement une migration un peu plus lente que pour le mode LOB limité. N'utilisez ce mode que si la totalité ou la plupart de vos fichiers LOBs sont volumineux (1 Go ou plus).
+ **Mode LOB complet avec combinaison** : lorsque vous définissez `bulk-max-size` sur une valeur différente de zéro, ce mode LOB complet utilise une combinaison du mode LOB limité et du mode LOB complet standard. En d'autres termes, si une taille de LOB est incluse dans votre valeur `bulk-max-size`, l'instance migre le LOB en ligne comme dans le mode LOB limité. Si la taille de LOB est supérieure à cette valeur, l’instance migre le LOB à l'aide d'une recherche dans la table ou la vue source comme dans le mode LOB complet standard. Pour une tâche de chargement de capture des données de modification (CDC), l'instance migre toutes à LOBs l'aide d'une recherche dans la table source, comme dans le mode LOB complet standard (voir ci-dessous). Il procède ainsi quelle que soit la taille du LOB.
**Note**
Vous ne pouvez migrer des vues que pour les tâches de chargement complet.
Ce mode entraîne une vitesse de migration constituant un compromis entre le mode LOB limité plus rapide et le mode LOB complet standard plus lent. Utilisez ce mode uniquement lorsque vous avez un mélange de petits et de grands LOBs, et que la plupart d'entre eux LOBs sont petits.
Ce mode LOB complet avec combinaison n'est disponible que pour les points de terminaison suivants :
+ IBM Db2 en tant que source
+ SAP ASE comme source ou cible
Quel que soit le mécanisme que vous spécifiez pour le `unlimited` mode, l'instance migre LOBs entièrement, sans troncature.
+ `none`— L'instance de réplication migre LOBs dans la table ou la vue sélectionnée à l'aide de vos paramètres LOB de tâches. Vous pouvez utiliser cette option pour comparer les résultats de la migration avec et sans paramètres LOB pour la table ou la vue sélectionnée.
Si la table ou la vue spécifiée est LOBs incluse dans la réplication, vous pouvez définir le paramètre de `BatchApplyEnabled` tâche sur `true` uniquement lorsque vous utilisez le mode `limited` LOB.
Dans certains cas, il se peut que vous définissiez `BatchApplyEnabled` sur `true` et `BatchApplyPreserveTransaction` sur `false`. Dans ces cas, l'instance définit `BatchApplyPreserveTransaction` `true` si la table ou la vue possède LOBs et si les points de terminaison source et cible sont Oracle.
+ `bulk-max-size` : définissez cette valeur sur zéro ou sur une valeur différente de zéro en kilo-octets, selon le `mode`, comme décrit dans les éléments précédents. En mode `limited`, vous devez définir une valeur différente de zéro pour ce paramètre.
L'instance est convertie LOBs au format binaire. Par conséquent, pour spécifier le LOB de plus grande taille que vous devez répliquer, multipliez sa taille par trois. Par exemple, si la taille du LOB le plus grand est de 2 Mo, définissez `bulk-max-size` sur 6 000 (6 Mo).
## Exemples de paramètres de table
Vous trouverez ci-dessous des exemples qui illustrent l'utilisation des paramètres de table.
**Example Charger une table segmentée par partitions**
L'exemple suivant charge une table `SALES` de votre source plus efficacement en la chargeant en parallèle sur la base de toutes ses partitions.
```
{
"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 Charger une table segmentée par sous-partitions**
L'exemple suivant charge une table `SALES` dans votre source Oracle plus efficacement en la chargeant en parallèle sur la base de toutes ses sous-partitions.
```
{
"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 Charger une table segmentée par une liste de partitions**
L'exemple suivant charge une table `SALES` de votre source en la chargeant en parallèle sur la base d’une liste de partitions particulière. Ici, les partitions spécifiées sont nommées à partir de valeurs commençant par des parties de l'alphabet, par exemple, `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 Charger une table Oracle segmentée par une liste sélectionnée de partitions et sous-partitions**
L'exemple suivant charge une table `SALES` de votre source Oracle en la chargeant en parallèle sur la base d’une liste sélectionnée de partitions et sous-partitions. Ici, les partitions spécifiées sont nommées à partir de valeurs commençant par des parties de l'alphabet, par exemple, `ABCD`, `EFGH`, etc. Les sous-partitions spécifiées sont nommés à partir de valeurs commençant par des chiffres, par exemple, `01234` et `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 Charger une table segmentée par des plages de valeurs de colonne**
L'exemple suivant charge une table `SALES` de votre source en la chargeant en parallèle par les segments spécifiés par les plages de valeurs de colonne `SALES_NO` et `REGION`.
```
{
"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"
]
]
}
}
]
}
```
Ici, deux colonnes sont spécifiées pour les plages de segment avec les noms `SALES_NO` et `REGION`. Deux limites sont spécifiées avec deux ensembles de valeurs de colonne (`["1000","NORTH"]` et `["3000","WEST"]`).
Ces deux limites identifient donc les trois segments de table suivants à charger en parallèle :
Segment 1
Lignes avec des valeurs `SALES_NO` inférieures ou égales à 1 000 et `REGION` inférieures à « NORTH ». En d'autres termes, les chiffres de vente jusqu'à 1 000 dans la région EAST.
Segment 2
Lignes autres que **Segment 1** avec des valeurs `SALES_NO` inférieures ou égales à 3 000 et `REGION` inférieures à « WEST ». En d'autres termes, les chiffres de vente compris entre 1 000 et 3 000 dans les régions NORTH et SOUTH.
Segment 3
Toutes les lignes restantes autres que **Segment 1** et **Segment 2**. En d'autres termes, les chiffres de vente supérieurs à 3 000 dans la région WEST.
**Example Charger deux tables : une segmentée par plages et une autre segmentée par partitions**
L'exemple suivant charge une table `SALES` en parallèle par les limites de segment que vous identifiez. Il charge également une table `ORDERS` en parallèle par l'ensemble de ses partitions, comme avec les exemples précédents.
```
{
"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 Charger un tableau en LOBs utilisant les paramètres LOB des tâches**
L'exemple suivant charge une `ITEMS` table dans votre source, y compris toutes LOBs, à l'aide de ses paramètres LOB de tâches. Le paramètre `bulk-max-size` avec la valeur 100 Mo est ignoré et conservé uniquement pour une réinitialisation rapide au mode `limited` ou `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 Charger une table en LOBs utilisant le mode LOB limité**
L'exemple suivant charge une `ITEMS` table incluse LOBs dans votre source en utilisant le mode LOB limité (par défaut) avec une taille maximale non tronquée de 100 Mo. Toutes celles LOBs dont la taille est supérieure à cette taille sont tronquées à 100 Mo. Tous LOBs sont chargés en ligne avec tous les autres types de données de colonne.
```
{
"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 Charger une table en LOBs utilisant le mode LOB complet standard**
L'exemple suivant charge une `ITEMS` table dans votre source, y compris toutes ses tables LOBs sans troncature, en utilisant le mode LOB complet standard. Toutes LOBs, quelle que soit leur taille, sont chargées séparément des autres types de données à l'aide d'une recherche pour chaque LOB dans la table source.
```
{
"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 Charger une table en LOBs utilisant le mode LOB complet combiné**
L'exemple suivant charge une `ITEMS` table dans votre source, y compris toutes ses tables LOBs sans troncature, en utilisant le mode LOB complet combiné. Tous les LOBs fichiers d'une taille inférieure à 100 Mo sont chargés en ligne avec d'autres types de données, comme en mode LOB limité. Tous les LOBs fichiers d'une taille supérieure à 100 Mo sont chargés séparément des autres types de données. Ce chargement distinct utilise une recherche pour chaque LOB dans la table source, comme dans le mode LOB complet standard.
```
{
"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"
}
}
]
}
```
# Utiliser le masquage des données pour masquer des informations sensibles
Pour masquer les données sensibles stockées dans une ou plusieurs colonnes des tables en cours de migration, vous pouvez utiliser les actions des règles de transformation du masquage des données. À partir de la version 3.5.4, AWS DMS vous pouvez utiliser des actions de règles de transformation de masquage des données dans le mappage des tables, ce qui vous permet de modifier le contenu d'une ou plusieurs colonnes pendant le processus de migration. AWS DMS charge les données modifiées dans les tables cibles.
AWS Database Migration Service propose trois options pour les actions relatives aux règles de transformation du masquage des données :
+ Masquage des données : masque à chiffres
+ Masquage des données : chiffres aléatoires
+ Masquage des données : masque de hachage
Ces actions de règles de transformation de masquage des données peuvent être configurées dans le mappage des tables de votre tâche de réplication, comme pour les autres règles de transformation. La cible de la règle doit être définie au niveau de la colonne.
## Masquage de nombres dans les données de colonne à l'aide d'un caractère de masquage
L'action de règle de transformation « Masquage des données : masque de chiffres » vous permet de masquer les données numériques dans une ou plusieurs colonnes en remplaçant les chiffres par un seul caractère imprimable ASCII que vous spécifiez (à l'exception des caractères vides ou des espaces).
Voici un exemple qui masque tous les chiffres de la `cust_passport_no` colonne de la `customer_master` table avec le caractère de masquage `'#'` et charge les données masquées dans la table cible :
```
{
"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": "#"
}
]
}
```
Par exemple, si la colonne `cust_passport_no` de la table source contient l'enregistrement « C6 BGJ566669 K », la AWS DMS tâche écrira ces données dans la table cible sous `"C#BGJ######K"` le format.
## Remplacement des nombres de la colonne par des nombres aléatoires
La règle de transformation « Masquage des données : randomisation des chiffres » vous permet de remplacer chaque chiffre numérique d'une ou de plusieurs colonnes par un nombre aléatoire. Dans l'exemple suivant, AWS DMS remplace chaque chiffre de la `cust_passport_no` colonne de la table source `customer_master` par un nombre aléatoire et écrit les données modifiées dans la table cible :
```
{
"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"
}
]
}
```
Par exemple, la AWS DMS tâche transformera la valeur de la `cust_passport_no` colonne de la table source `"C6BGJ566669K"` en `"C1BGJ842170K"` et l'écrira dans la base de données cible.
## Remplacement des données de colonne par une valeur de hachage
La règle de transformation « Masquage des données : masque de hachage » permet de remplacer les données de colonne par un hachage généré à l'aide de l'algorithme. `SHA256` La longueur du hachage sera toujours de 64 caractères. Par conséquent, la longueur de colonne de la table cible doit être de 64 caractères au minimum. Vous pouvez également ajouter une action de règle de `change-data-type` transformation à la colonne pour augmenter la largeur de la colonne dans la table cible.
L'exemple suivant génère une valeur de hachage de 64 caractères pour les données de la `cust_passport_no` colonne de la table source `customer_master` et charge les données transformées dans la table cible après avoir augmenté la longueur de la colonne :
```
{
"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"
}
]
}
```
Par exemple, si la colonne `cust_passport_no` de la table source contient une valeur`“C6BGJ566669K”`, AWS DMS task écrira un hachage dans `“7CB06784764C9030CCC41E25C15339FEB293FFE9B329A72B5FED564E99900C75”` la table cible.
## Limitations
+ Chaque option de règle de transformation de masquage des données est prise en charge pour des types de AWS DMS données spécifiques uniquement :
+ Masquage des données : le masque numérique est pris en charge pour les colonnes de types de données : `WSTRING` et`STRING`.
+ Masquage des données : Digits Randomize est pris en charge pour les colonnes de types de données : `WSTRING, STRING; NUMERIC, INT1, INT2, INT4, and INT8 ` avec des contreparties non signées.
+ Masquage des données : le masque de hachage est pris en charge pour les colonnes de types de données : `WSTRING` et. `STRING`
Pour en savoir plus sur le mappage des types de AWS DMS données avec les types de données de votre moteur source, reportez-vous au mappage des types de données de votre moteur source avec AWS DMS les types de données. Consultez les types de données source pour [Types de données sources pour Oracle](CHAP_Source.Oracle.md#CHAP_Source.Oracle.DataTypes)[Types de données sources pour SQL Server](CHAP_Source.SQLServer.md#CHAP_Source.SQLServer.DataTypes),[Types de données sources pour PostgreSQL](CHAP_Source.PostgreSQL.md#CHAP_Source-PostgreSQL-DataTypes), et[Types de données sources pour MySQL](CHAP_Source.MySQL.md#CHAP_Source.MySQL.DataTypes).
+ L'utilisation d'une action de règle de masquage des données pour une colonne dont le type de données est incompatible provoquera une erreur dans la tâche DMS. Reportez-vous DataMaskingErrorPolicy aux paramètres des tâches DMS pour spécifier le comportement de gestion des erreurs. Pour plus d’informations sur `DataMaskingErrorPolicy`, consultez [Paramètres de traitement des erreurs pour une tâche](CHAP_Tasks.CustomizingTasks.TaskSettings.ErrorHandling.md).
+ Vous pouvez ajouter une action de règle de change-data-type transformation pour remplacer le type de données de la colonne par un type compatible si le type de colonne source n'est pas pris en charge pour l'option de masquage que vous prévoyez d'utiliser. Le nombre `rule-id` de la `change-data-type` transformation doit être inférieur à l'identifiant de règle de la transformation de masquage afin que le changement de type de données se produise avant le masquage.
+ Utiliser le masquage des données : action de masque de hachage pour masquer les colonnes clé primaire/clé unique/clé étrangère, car la valeur de hachage générée sera unique et cohérente. Les deux autres options de masquage ne peuvent garantir l'unicité.
+ Alors que le masquage des données : masque de chiffres et masquage des données : le masquage aléatoire des chiffres n'affectent que les chiffres des données de la colonne et n'affecte pas la longueur des données, le masquage des données : masque de hachage modifie la colonne entière, la longueur des données passe à 64 caractères. Par conséquent, la table cible à créer en conséquence ou une règle de change-data-type transformation doit être ajoutée pour la colonne masquée.
+ Les colonnes pour lesquelles une action de règle de transformation de masquage des données est spécifiée sont exclues de la validation des données dans AWS DMS. Si les colonnes Clé primaire/Clé unique sont masquées, la validation des données ne sera pas exécutée pour cette table ; le statut de validation de cette table sera égal à. `No Primary key`