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