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.

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.

Paramètre	Valeurs possibles	Description
rule-type	table-settings	Valeur qui applique la règle à une table, une vue ou une collection spécifiée par la règle de sélection.
rule-id	Valeur numérique.	Valeur numérique unique pour identifier la règle.
rule-name	Valeur alphanumérique.	Nom unique pour identifier la règle.
object-locator	Objet avec les paramètres suivants : schema-name : nom du schéma. Pour les points de terminaison MongoDB et Amazon DocumentDB, il s’agit du nom de la base de données contenant un ensemble de collections. table-name : nom de la table, de la vue ou de la collection.	Le nom d’un schéma et d’une table ou d’une vue spécifiques ou le nom d’une base de données et d’une collection spécifiques (pas de caractères génériques).
parallel-load	Objet avec les paramètres suivants : type : indique si le chargement parallèle est activé. Si c'est le cas, ce paramètre spécifie également le mécanisme permettant d'identifier les partitions de table ou de vue, les sous-partitions ou d'autres segments à charger en parallèle. Les partitions sont des segments qui sont déjà définis et identifiés par le nom dans la table ou la vue source. Pour les points de terminaison MongoDB et Amazon DocumentDB, les partitions sont des segments. AWS DMS peut calculer ces paramètres d'autosegmentation automatiquement en fonction des paramètres d'autosegmentation associés. Vous pouvez également les spécifier manuellement à l’aide des paramètres de segmentation par plage. Pour les points de terminaison Oracle uniquement, les sous-partitions sont un niveau supplémentaire de segments qui sont déjà définis et identifiés par le nom dans la table ou la vue source. Vous pouvez identifier d'autres segments dans la règle table-settings en spécifiant des limites dans la plage de valeurs pour une ou plusieurs colonnes de la table ou de la vue. partitions : si type est défini sur partitions-list, cette valeur spécifie toutes les partitions à charger en parallèle. subpartitions : pour les points de terminaison Oracle uniquement, si type est défini sur partitions-list, cette valeur spécifie toutes les sous-partitions à charger en parallèle. columns : si type est défini sur ranges, cette valeur spécifie les noms des colonnes utilisés pour identifier les segments basés sur une plage à charger en parallèle. boundaries : si type est défini sur ranges, cette valeur spécifie les valeurs de columns utilisées pour identifier les segments basés sur une plage à charger en parallèle.	Spécifie une opération de chargement parallèle (multithread) dans la table ou la vue identifiée par l'option object-locator. Dans ce cas, vous pouvez charger en parallèle selon l'une de ces méthodes : À l'aide des segments spécifiés par toutes les partitions ou sous-partitions disponibles. À l'aide des partitions et sous-partitions sélectionnées. À l’aide de la segmentation automatique ou des segments basés sur une plage que vous spécifiez. Pour plus d’informations sur le chargement parallèle, consultez Utilisation du chargement parallèle pour certaines tables, vues et collections.
type	L’une des options suivantes pour parallel-load : partitions-auto : toutes les partitions de la table ou de la vue sont chargées en parallèle. Chaque partition est allouée à son propre thread. Ce paramètre est obligatoire pour que les points de terminaison sources MongoDB et Amazon DocumentDB puissent utiliser l’option de segmentation automatique d’un chargement complet parallèle. subpartitions-auto : (points de terminaison Oracle uniquement) Toutes les sous-partitions de la table ou de la vue sont chargées en parallèle. Chaque sous-partition est allouée à son propre thread. partitions-list : toutes les partitions spécifiées de la table ou de la vue sont chargées en parallèle. Pour les points de terminaison Oracle uniquement, toutes les sous-partitions spécifiées de la table ou de la vue sont chargées en parallèle. Chaque partition et sous-partition que vous spécifiez sont allouées à son propre thread. Vous identifiez les partitions et les sous-partitions à charger en parallèle par noms de partition (partitions) et noms de sous-partition (subpartitions). ranges : tous les segments spécifiés par plage de la table, de la vue ou de la collection sont chargés en parallèle. Chaque segment de table, de vue ou de collection que vous identifiez est alloué à son propre thread. Vous spécifiez ces segments par noms de colonne (columns) et valeurs de colonne (boundaries). 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). none : la table, la vue ou la collection est chargée dans une tâche à thread unique (valeur par défaut), quelles que soient ses partitions ou sous-partitions. Pour plus d’informations, consultez Création d’une tâche.	Mécanisme permettant d’identifier les partitions, les sous-partitions ou les segments de table, de vue ou de collection à charger en parallèle.
number-of-partitions	(Facultatif) Lorsque type est défini sur partitions-auto pour les collections spécifiées d’un point de terminaison MongoDB ou Amazon DocumentDB, ce paramètre indique le nombre total de partitions (segments) utilisées pour la migration. La valeur par défaut est 16.	Spécifie le nombre exact de partitions à charger en parallèle.
collection-count-from-metadata	(Facultatif) Lorsqu'il type s'agit partitions-auto de collections spécifiées d'un point de terminaison MongoDB ou Amazon DocumentDB et que ce paramètre est défini sur true AWS DMS , utilise un nombre de collections estimé pour déterminer le nombre de partitions. Si ce paramètre est défini surfalse, AWS DMS utilise le nombre réel de collectes. L’argument par défaut est true.	Indique s’il convient d’utiliser une estimation du nombre de collections ou le nombre réel de collections pour calculer le nombre de partitions à charger en parallèle.
max-records-skip-per-page	(Facultatif) Lorsque type est défini sur partitions-auto pour les collections spécifiées d’un point de terminaison MongoDB ou Amazon DocumentDB, il s’agit du nombre d’enregistrements à ignorer simultanément lors de la détermination des limites pour chaque partition. AWS DMS ignore un certain nombre d’enregistrements par page pour déterminer la limite minimale d’une partition. La valeur par défaut est 10 000.	Spécifie le nombre d’enregistrements à ignorer simultanément lors de la détermination des limites de chaque partition. La définition d’une valeur relativement élevée à partir de la valeur par défaut peut entraîner des délais d’expiration du curseur et des échecs de tâche. La définition d’une valeur relativement faible à partir de la valeur par défaut entraîne un plus grand nombre d’opérations par page et ralentit le chargement complet.
batch-size	(Facultatif) Lorsque type est défini sur partitions-auto pour les collections spécifiées d’un point de terminaison MongoDB ou Amazon DocumentDB, cette valeur entière limite le nombre de documents renvoyés par lot aller-retour. Si la taille du lot est égale à zéro (0), le curseur utilise la taille de lot maximale définie par le serveur. La valeur par défaut est 0.	Spécifie le nombre maximal de documents renvoyés par lot. Chaque lot nécessite un aller retour jusqu’au serveur.
partitions	Lorsque type est partitions-list, il s’agit d’un tableau de chaînes qui spécifient les noms des partitions à charger en parallèle.	Noms des partitions à charger en parallèle.
subpartitions	(Points de terminaison Oracle uniquement) Lorsque type est partitions-list, il s’agit d’un tableau de chaînes qui spécifient les noms des sous-partitions à charger en parallèle.	Noms des sous-partitions à charger en parallèle.
columns	Lorsque type est défini sur ranges, il s’agit d’un tableau de chaînes définies sur les noms des colonnes utilisées pour identifier les segments de table, de vue ou de collection basés sur une plage à charger en parallèle.	Noms des colonnes utilisés pour identifier les segments de table, de vue ou de collection basés sur une plage à charger en parallèle.
boundaries	Lorsque type est ranges, tableau de tableaux de valeurs de colonne. Chaque tableau de valeurs de colonne contient des valeurs de colonne dans la quantité et l'ordre spécifiés par columns. Un tableau de valeurs de colonne spécifie la limite supérieure d’un segment de table, de vue ou de collection. Chaque tableau de valeurs de colonne supplémentaire ajoute la limite supérieure pour un segment de table, de vue ou de collection supplémentaire. Tous ces segments de table, de vue ou de collection basés sur une plage sont chargés en parallèle.	Valeurs de colonne qui identifient les partitions de table, de vue ou de collection basées sur une plage à charger en parallèle.
lob-settings	Objet avec les paramètres suivants : mode : spécifie le mode de gestion de migration des objets LOB. bulk-max-size : spécifie la taille maximale des objets LOB, en fonction du paramètre mode.	Valeur qui spécifie la gestion LOB pour la table ou la vue identifiée par l'option object-locator. La tâche de gestion LOB spécifiée remplace tous les paramètres de tâche LOB de cette table ou de cette vue uniquement. Pour plus d’informations sur l’utilisation des paramètres LOB, consultez Spécification des paramètres LOB pour une table ou une vue sélectionnée.
mode	Spécifie le traitement de migration des LOB dans la table ou la vue sélectionnée à l'aide des valeurs suivantes : limited : (par défaut) Cette valeur définit la migration en mode LOB limité, avec tous les objets LOB migrés en ligne, ainsi que tous les autres types de données des colonnes de la table ou de la vue. Utilisez cette valeur lors de la réplication des LOB de petite taille (100 Mo ou moins). Spécifiez également une valeur bulk-max-size (zéro n'est pas valide). Tous les LOB ayant migré supérieurs à bulk-max-size sont tronqués à la taille que vous définissez. unlimited : cette valeur définit la migration en mode LOB complet. Utilisez cette valeur lorsque la totalité ou la majorité des LOB que vous souhaitez répliquer ont une taille supérieure à 1 Go. Si vous spécifiez une valeur bulk-max-size égale à zéro, tous les LOB sont migrés en mode LOB complet standard. Dans cette forme de mode unlimited, tous les LOB sont migrés séparément à partir des autres types de données de colonne à l'aide d'une recherche dans la table ou la vue source. Si vous spécifiez une valeur bulk-max-size supérieure à zéro, tous les LOB sont migrés en mode LOB complet combinaison. Dans cette forme de mode unlimited, les LOB supérieurs à bulk-max-size sont migrés à l'aide d'une recherche dans la table ou la vue source, similaire au mode LOB complet standard. Sinon, les LOB inférieurs ou égaux à cette taille sont migrés en ligne, comme dans le mode LOB limité. Aucun LOB n’est jamais tronqué en mode unlimited, quelle que soit la forme que vous utilisez. none : tous les objets LOB de table ou de vue sont migrés selon les paramètres LOB de tâche. Pour plus d’informations sur les paramètres LOB de tâche, consultez Paramètres de métadonnées des tâches cibles. Pour plus d’informations sur la migration des objets LOB et sur la spécification de ces paramètres LOB de tâche, consultez Configuration du support LOB pour les bases de données sources dans une tâche AWS DMS.	Spécifie le mécanisme utilisé pour migrer les LOB.
bulk-max-size	L'effet de cette valeur dépend du mode.	Spécifie la taille maximale des LOB en kilo-octets par incréments. Spécifiez cette option uniquement si vous avez besoin de répliquer des LOB de petite taille ou si le point de terminaison cible ne prend pas en charge la taille de LOB illimitée.

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 en une seule tâche avecparallel-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

• 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)

• Amazon DynamoDB

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

• Chaîne

• 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)

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 * 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. Pour plus d'informations sur le paramètre MaxFullLoadSubTasks, consultez Paramètres de tâche de chargement complet. 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.

2. (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.

3. (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.

2. 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.

3. 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.

   2. Spécifiez chaque tableau de valeurs de colonne comme limite supérieure, dans l'ordre, de chaque segment, du bas 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.

   Par exemple, supposons que vous définissez trois tableaux de valeurs de colonne pour les colonnes COL1, COL2 et COL3, comme suit.

   COL1	COL2	COL3
   10	30	105
   20	20	120
   100	12	99

   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 tous vos LOB sont petits (moins de 100 Mo) ou si le point de terminaison cible ne prend pas en charge une taille de LOB illimitée. De plus, si vous utilisez limited, tous les LOB doivent se trouver dans la limite de taille que vous avez définie pour bulk-max-size.

    Dans ce mode, pour une tâche de chargement complet, l'instance de réplication migre tous les LOB en ligne avec les autres types de données de colonne dans le cadre d'un stockage de table ou de vue principal. Toutefois, l'instance tronque les LOB supérieurs à votre valeur bulk-max-size à la taille spécifiée. Pour un chargement de capture des données modifiées (CDC), l'instance migre tous les LOB à l'aide d'une recherche de table source, quelle que soit la taille des LOB, comme dans le mode LOB complet standard. 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.

  • 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 sur zéro, l’instance de réplication migre tous les objets LOB à l’aide du 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é. Utilisez ce mode uniquement si la totalité ou la plupart de vos LOB 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 un chargement de capture des données modifiées (CDC), l'instance migre tous les LOB à l'aide d'une recherche de table source, quelle que soit la taille des LOB, comme dans le mode LOB complet standard. 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 une combinaison de LOB de petites et grandes tailles et que la plupart des LOB 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

    Quelle que soit la façon dont vous spécifiez le mode unlimited, l'instance migre tous les LOB entièrement, sans troncature.

  • none : l’instance de réplication migre les objets LOB de la table ou la vue sélectionnée à l’aide de vos paramètres LOB de tâche. 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 a des LOB inclus dans la réplication, vous ne pouvez définir le paramètre de tâche BatchApplyEnabled sur true qu'en cas d'utilisation du mode LOB limited.

  Dans certains cas, il se peut que vous définissiez BatchApplyEnabled sur true et BatchApplyPreserveTransaction sur false. Dans ce cas, l'instance définit BatchApplyPreserveTransaction sur true si la table ou la vue a des LOB et que 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 convertit les LOB 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.

Exemple 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"
            }
        }
     ]
}

Exemple 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"
            }
        }
     ]
}

Exemple 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"
                ]
            }
        }
    ]
}

Exemple 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"
                ]
            }
        }
    ]
}

Exemple 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.

Exemple 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" 
            }
        }
    ]
}

Exemple Charger une table avec des LOB à l’aide du mode LOB limité

L'exemple suivant charge une table ITEMS incluant des LOB de votre source à l'aide du mode LOB limité (valeur par défaut) avec une taille maximale non tronquée de 100 Mo. Les LOB qui dépassent cette taille sont tronqués à 100 Mo. Tous les LOB 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"
            }
        }
     ]
}

Exemple Charger une table avec des LOB à l’aide du mode LOB complet standard

L'exemple suivant charge une table ITEMS de votre source, y compris tous ses LOB sans troncation à l’aide du mode LOB complet standard. Tous les LOB, quelle que soit leur taille, sont chargés séparément des autres types de données à l'aide d'une recherche de 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"
            }
        }
     ]
}

Exemple Charger une table avec des LOB à l’aide du mode LOB complet avec combinaison

L'exemple suivant charge une table ITEMS de votre source, y compris tous ses LOB sans troncation à l’aide du mode LOB complet avec combinaison Tous les LOB dont la taille est inférieure à 100 Mo sont chargés en ligne avec les autres types de données, comme dans le mode LOB limité. Tous les LOB supérieurs à 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"
            }
        }
     ]
}

Exemple Charger une table avec des LOB à l'aide des paramètres LOB de tâche

L'exemple suivant charge une table ITEMS de votre source, y compris tous les LOB, à l'aide de ses paramètres LOB de tâche. 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"
            }
        }
     ]
}