Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Regole e operazioni delle impostazioni di tabella e raccolta
Puoi utilizzare le impostazioni di tabella per specificare le impostazioni che desideri applicare alla tabella o alla vista selezionata per una determinata operazione. Le regole delle impostazioni di tabella sono facoltative, a seconda dell'endpoint e dei requisiti di migrazione.
Invece di tabelle e viste, i database MongoDB e Amazon DocumentDB archiviano i record di dati come documenti che vengono archiviati in *raccolte*. Un singolo database per un endpoint MongoDB o Amazon DocumentDB è un set specifico di raccolte identificate dal nome del database.
Quando esegui la migrazione da un'origine MongoDB o Amazon DocumentDB, le impostazioni di caricamento parallelo si utilizzano in modo leggermente diverso. In tal caso, considera il tipo di segmentazione automatica o di segmentazione degli intervalli delle impostazioni di caricamento parallelo per le raccolte selezionate anziché per le tabelle e le viste.
**Topics**
+ [Utilizzo limitato dei caratteri jolly nelle impostazioni delle tabelle](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.Wildcards)
+ [Utilizzo del caricamento parallelo per le tabelle, le viste e le raccolte selezionate](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.ParallelLoad)
+ [Definizione delle impostazioni LOB per una tabella o una vista selezionata](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.LOB)
+ [Esempi di impostazioni di tabella](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.Examples)
Per le regole di mappatura della tabella che utilizzano il tipo di regola di impostazione della tabella, puoi applicare i parametri riportati di seguito.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/dms/latest/userguide/CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.html)
## Utilizzo limitato dei caratteri jolly nelle impostazioni delle tabelle
L'utilizzo del carattere jolly percentuale (`"%"`) nelle regole `"table-settings"` non è supportato per i database di origine, come illustrato di seguito.
```
{
"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
}
}
```
Se si utilizza `"%"` nelle `"table-settings"` regole come mostrato, AWS DMS restituisce l'eccezione seguente.
```
Error in mapping rules. Rule with ruleId = x failed validation. Exact
schema and table name required when using table settings rule.
```
Inoltre, si AWS consiglia di non caricare un gran numero di raccolte di grandi dimensioni utilizzando un'unica operazione con`parallel-load`. AWS DMS limita il conflitto di risorse e il numero di segmenti caricati in parallelo in base al valore del parametro delle impostazioni delle attività `MaxFullLoadSubTasks`, con un valore massimo di 49.
Specifica tutte le raccolte più grandi per il database di origine definendo singolarmente `"schema-name"` e `"table-name"`. Inoltre, aumenta correttamente la migrazione. Ad esempio, esegui più attività su un numero sufficiente di istanze di replica per gestire un elevato numero di raccolte di grandi dimensioni nel database.
## Utilizzo del caricamento parallelo per le tabelle, le viste e le raccolte selezionate
Per velocizzare la migrazione e renderla più efficiente, puoi usare la funzione di caricamento parallelo per le tabelle relazionali, le viste e le raccolte selezionate. In altre parole, puoi eseguire la migrazione di una singola tabella, vista o raccolta segmentata utilizzando diversi thread in parallelo. A tale scopo, AWS DMS suddivide un'attività a caricamento completo in thread, con ogni segmento di tabella assegnato al relativo thread.
Utilizzando questo processo di caricamento in parallelo, puoi innanzitutto avere più thread che scaricano più tabelle, viste e raccolte in parallelo dall'endpoint di origine. Successivamente, puoi avere più thread che eseguono la migrazione e caricano le stesse tabelle, viste e raccolte in parallelo per l'endpoint di destinazione. Per alcuni motori di database, puoi segmentare le tabelle e le viste utilizzando le partizioni o le partizioni secondarie esistenti. Per altri motori di database, è possibile segmentare AWS DMS automaticamente le raccolte in base a parametri specifici (segmentazione automatica). In caso contrario, puoi segmentare qualsiasi tabella, vista o raccolta in base a intervalli di valori delle colonne specificati dall'utente.
Il caricamento parallelo è supportata per i seguenti endpoint di origine:
+ Oracle
+ Microsoft SQL Server
+ MySQL
+ PostgreSQL
+ IBM Db2 LUW
+ SAP Adaptive Server Enterprise (ASE)
+ MongoDB (supporta solo le opzioni di segmentazione automatica e segmentazione degli intervalli di un pieno carico parallelo)
+ Amazon DocumentDB (supporta solo le opzioni di segmentazione automatica e segmentazione degli intervalli di un pieno carico parallelo)
Per gli endpoint MongoDB e Amazon DocumentDB AWS DMS , supporta i seguenti tipi di dati per le colonne che sono chiavi di partizione per l'opzione di segmentazione dell'intervallo di un carico completo parallelo.
+ Double
+ Stringa
+ ObjectId
+ Intero a 32 bit
+ Intero a 64 bit
Il caricamento parallelo per l'utilizzo con le regole di impostazione delle tabelle è supportato per i seguenti endpoint di destinazione:
+ Oracle
+ Microsoft SQL Server
+ MySQL
+ PostgreSQL
+ Simple Storage Service (Amazon S3)
+ SAP Adaptive Server Enterprise (ASE)
+ Amazon Redshift
+ MongoDB (supporta solo le opzioni di segmentazione automatica e segmentazione degli intervalli di un pieno carico parallelo)
+ Amazon DocumentDB (supporta solo le opzioni di segmentazione automatica e segmentazione degli intervalli di un pieno carico parallelo)
+ Db2 LUW
Per specificare il numero massimo di tabelle e viste da caricare in parallelo, utilizza l'impostazione dell'attività `MaxFullLoadSubTasks`.
Per specificare il numero massimo di thread per tabella o vista per le destinazioni supportate di un'attività di caricamento parallelo, definisci più segmenti utilizzando i limiti dei valori delle colonne.
**Importante**
`MaxFullLoadSubTasks` controlla il numero di tabelle o segmenti di tabella da caricare in parallelo. `ParallelLoadThreads` controlla il numero di thread utilizzati da un'attività di migrazione per eseguire i carichi in parallelo. *Queste impostazioni sono moltiplicative*. Pertanto, il numero totale di thread utilizzati durante un'operazione di pieno carico è approssimativamente il risultato del valore di `ParallelLoadThreads `moltiplicato per il valore di `MaxFullLoadSubTasks` (`ParallelLoadThreads` **\$1** `MaxFullLoadSubtasks)`.
Se si creano attività con un numero elevato di attività secondarie di pieno carico e un numero elevato di thread di caricamento parallelo, l'attività può consumare troppa memoria e non riuscire.
Per specificare il numero massimo di thread per tabella per le destinazioni Amazon DynamoDB, Flusso di dati Amazon Kinesis, Apache Kafka o Amazon Elasticsearch Service, utilizza l'impostazione dell'attività dei metadati di destinazione `ParallelLoadThreads`.
Per specificare le dimensioni del buffer per un'attività di caricamento parallelo quando si usa `ParallelLoadThreads`, utilizza l'impostazione dell'attività dei metadati di destinazione `ParallelLoadBufferSize`.
La disponibilità e le impostazioni di `ParallelLoadThreads` e `ParallelLoadBufferSize` dipendono dall'endpoint di destinazione.
Per ulteriori informazioni sulle impostazioni `ParallelLoadThreads` e `ParallelLoadBufferSize`, consulta [Impostazioni delle attività dei metadati di destinazione](CHAP_Tasks.CustomizingTasks.TaskSettings.TargetMetadata.md). Per ulteriori informazioni sull'impostazione `MaxFullLoadSubTasks`, consulta [Impostazioni delle attività di caricamento completo](CHAP_Tasks.CustomizingTasks.TaskSettings.FullLoad.md). Per informazioni specifiche per gli endpoint di destinazione, vedere gli argomenti correlati.
Per utilizzare il caricamento in parallelo, crea una regola di mappatura della tabella di tipo `table-settings` con l'opzione `parallel-load`. All'interno della regola `table-settings`, puoi specificare i criteri di segmentazione per una singola tabella, vista o raccolta che desideri caricare in parallelo. Per farlo, impostare il parametro `type` dell'opzione `parallel-load` per una delle diverse opzioni.
Come eseguire questa operazione dipende dal modo in cui desideri segmentare la tabella, la vista o la raccolta per il caricamento in parallelo:
+ Per partizioni (o segmenti): carica tutte le partizioni (o i segmenti) delle tabelle o delle viste esistenti utilizzando il tipo `partitions-auto`. In alternativa, carica solo le partizioni selezionate utilizzando il tipo `partitions-list` con una matrice di partizioni specificata.
Solo per gli endpoint MongoDB e Amazon DocumentDB, carica tutte le raccolte o quelle specificate per segmenti, AWS DMS che vengono calcolate automaticamente anche utilizzando il tipo e i parametri opzionali aggiuntivi. `partitions-auto` `table-settings`
+ (Solo gli endpoint Oracle) Per partizioni secondarie: carica tutte le partizioni secondarie delle tabelle o delle viste esistenti utilizzando il tipo `subpartitions-auto`. Oppure caricare solo le partizioni secondarie selezionate utilizzando il tipo `partitions-list` con una matrice `subpartitions` specificata.
+ Per segmenti definiti: carica i segmenti delle tabelle, delle viste o delle raccolte definiti utilizzando limiti di valori per colonna. Per farlo, utilizzare il tipo `ranges` con matrice specificate `columns` e `boundaries`.
**Nota**
Gli endpoint PostgreSQL supportano solo questo tipo di caricamento parallelo. MongoDB e Amazon DocumentDB come endpoint di origine supportano sia questo tipo di segmentazione dell'intervallo che il tipo di segmentazione automatica di un pieno carico parallelo (`partitions-auto`).
Per identificare le tabelle, le viste o le raccolte aggiuntive da caricare in parallelo, specifica ulteriori oggetti `table-settings` con opzioni `parallel-load`.
Nelle seguenti procedure puoi scoprire come creare il codice JSON per ciascun tipo di caricamento parallelo, dai casi più semplici a quelli più complessi.
**Per specificare tutte le partizioni delle tabelle, delle viste o delle raccolte o tutte le partizioni secondarie delle tabelle o delle viste**
+ Specifica `parallel-load` con il tipo `partitions-auto` o il tipo `subpartitions-auto` (ma non entrambi).
Ogni partizione (segmento) o partizione secondaria della tabella, della vista o della raccolta viene automaticamente allocata al proprio thread.
Per alcuni endpoint, il caricamento parallelo include partizioni o partizioni secondarie solo se sono già definite per la tabella o la vista. Per gli endpoint di origine MongoDB e Amazon DocumentDB, puoi calcolare automaticamente le partizioni (o AWS DMS segmenti) in base a parametri aggiuntivi opzionali. Tra queste vi sono `number-of-partitions`, `collection-count-from-metadata`, `max-records-skip-per-page` e `batch-size`.
**Per specificare partizioni o partizioni secondarie di una tabella o una vista selezionata o entrambe**
1. Specifica `parallel-load` con il tipo`partitions-list`.
1. (Facoltativo) Includi le partizioni specificando una vasta gamma di nomi di partizione come valore di `partitions`.
Ogni partizione specificata viene quindi allocata al proprio thread.
**Importante**
Per gli endpoint Oracle, assicurati che le partizioni e le partizioni secondarie non si sovrappongano quando le scegli per il caricamento parallelo. Se si utilizzano partizioni e partizioni secondarie sovrapposte per caricare i dati in parallelo, le voci vengono duplicate o l'operazione non riesce a causa di una violazione del duplicato della chiave primaria.
1. (Facoltativo) Solo per gli endpoint Oracle includi le partizioni secondarie specificando una serie di nomi di partizioni secondarie come valore di `subpartitions`.
Ogni partizione secondaria specificata viene quindi allocata al proprio thread.
**Nota**
Il caricamento in parallelo include partizioni o partizioni secondarie solo se sono già definite per la tabella o la vista.
Puoi specificare i segmenti delle tabelle o delle viste come intervalli di valori delle colonne. In questo caso, è necessario ricordare le caratteristiche di queste colonne:
+ L'utilizzo di colonne indicizzate migliora in modo significativo le prestazioni.
+ È possibile specificare fino a 10 colonne.
+ Non puoi utilizzare le colonne per definire i confini dei segmenti con i seguenti tipi di AWS DMS dati: DOUBLE, FLOAT, BLOB, CLOB e NCLOB
+ I record con valori nulli non vengono replicati.
**Per specificare i segmenti delle tabelle, delle viste o delle raccolte come intervalli di valori delle colonne**
1. Specifica `parallel-load` con il tipo`ranges`.
1. Definire un limite tra i segmenti delle tabelle o delle viste specificando una matrice di nomi di colonne come valore di `columns`. Eseguire questa operazione per ogni colonna per cui si desidera definire un limite tra i segmenti delle tabelle o delle viste.
L'ordine delle colonne è significativo. La prima colonna è la più significativa e l'ultima colonna è la meno significativa nella definizione di ogni limite, come descritto nei seguenti passaggi.
1. Definire gli intervalli di dati per tutti i segmenti delle tabelle o delle viste i attribuendo a una matrice di delimitatori il valore `boundaries`. Un *vettore di delimitatori* è un vettore di vettori colonna-valore. A tale scopo, procedere come indicato di seguito.
1. Specifica ciascun elemento di una matrice colonna-valore come valore che corrisponde a ogni colonna. Una *matrice di valori di colonna* rappresenta il limite superiore di ciascun segmento della tabella o della vista da definire. Specifica ogni colonna nello stesso ordine specificato per tale colonna nella matrice `columns`.
Inserisci i valori per le colonne di tipo DATE nel formato supportato dall'origine.
1. Specificate ogni array di valori di colonna come limite superiore, nell'ordine, di ogni segmento dalla parte inferiore al segmento della tabella o della vista. next-to-top Se esistono delle righe che vanno oltre il massimo limite superiore specificato, queste righe costituiranno l'ultimo segmento della tabella o della vista. Di conseguenza, il numero di segmenti basati su intervalli è potenzialmente uno più del numero di delimitazioni di segmento contenute nel vettore delle delimitazioni. Ognuno di questi segmenti basati su intervalli è allocato al proprio thread.
Tutti i dati non nulli della tabella vengono replicati, anche se non si definiscono intervalli di dati per tutte le colonne della tabella o della vista.
Ad esempio, si supponga di definire tre matrici di valori di colonna per le colonne e quanto segue. COL1 COL2 COL3
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/dms/latest/userguide/CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.html)
Hai definito tre delimitazioni di segmenti per un totale di quattro potenziali segmenti.
Per identificare gli intervalli di righe da replicare per ogni segmento, l'istanza di replica applica una ricerca su queste tre colonne per ciascuno dei quattro segmenti. La ricerca è simile alla seguente:
**Segmento 1**
Replicare tutte le righe in cui si verificano le seguenti condizioni: i primi valori di due colonne sono inferiori o uguali ai valori di limite superiore del **Segmento 1** corrispondenti. Inoltre, i valori della terza colonna sono inferiori al valore di limite superiore del **Segmento 1**.
**Segmento 2**
Replica tutte le righe (eccetto le righe **Segmento 1** ) in cui si verificano le seguenti condizioni: i valori delle prime due colonne sono inferiori o uguali ai valori di limite superiore del **Segmento 2** corrispondente. Inoltre, i valori della terza colonna sono inferiori al relativo valore di limite superiore del **Segmento 2** .
**Segmento 3**
Replicare tutte le righe (eccetto le righe del **Segmento 2** ) in cui si verificano le seguenti condizioni: i valori delle prime due colonne sono inferiori o uguali ai valori di limite superiore del **Segmento 3** corrispondente. Inoltre, i valori della terza colonna sono inferiori al relativo valore del limite superiore del **Segmento 3** .
**Segmento 4**
Replica tutte le righe rimanenti (escluse quelle appartenenti ai **Segmenti 1, 2 e 3**).
In questo caso, l'istanza di replica crea una clausola `WHERE` per caricare ogni segmento come segue:
**Segmento 1**
`((COL1 < 10) OR ((COL1 = 10) AND (COL2 < 30)) OR ((COL1 = 10) AND (COL2 = 30) AND (COL3 < 105)))`
**Segmento 2**
`NOT ((COL1 < 10) OR ((COL1 = 10) AND (COL2 < 30)) OR ((COL1 = 10) AND (COL2 = 30) AND (COL3 < 105))) AND ((COL1 < 20) OR ((COL1 = 20) AND (COL2 < 20)) OR ((COL1 = 20) AND (COL2 = 20) AND (COL3 < 120)))`
**Segmento 3**
`NOT ((COL1 < 20) OR ((COL1 = 20) AND (COL2 < 20)) OR ((COL1 = 20) AND (COL2 = 20) AND (COL3 < 120))) AND ((COL1 < 100) OR ((COL1 = 100) AND (COL2 < 12)) OR ((COL1 = 100) AND (COL2 = 12) AND (COL3 < 99)))`
**Segmento 4**
`NOT ((COL1 < 100) OR ((COL1 = 100) AND (COL2 < 12)) OR ((COL1 = 100) AND (COL2 = 12) AND (COL3 < 99)))`
## Definizione delle impostazioni LOB per una tabella o una vista selezionata
Puoi impostare le impostazioni LOB dell'attività per una o più tabelle mediante la creazione di una regola di mappatura della tabella di tipo `table-settings` con l'opzione `lob-settings` per uno o più oggetti `table-settings`.
La definizione delle impostazioni LOB per le tabelle o le viste selezionate è supportata per i seguenti endpoint origine:
+ Oracle
+ Microsoft SQL Server
+ MySQL
+ PostgreSQL
+ IBM Db2, a seconda delle impostazioni `mode` e `bulk-max-size`, descritte di seguito
+ SAP Adaptive Server Enterprise (ASE), a seconda delle impostazioni `mode` e `bulk-max-size`, come descritto di seguito
La definizione delle impostazioni LOB per le tabelle o le viste selezionate è supportata per i seguenti endpoint di destinazione:
+ Oracle
+ Microsoft SQL Server
+ MySQL
+ PostgreSQL
+ SAP ASE, a seconda delle impostazioni `mode` e `bulk-max-size`, come descritto di seguito
**Nota**
Puoi utilizzare i tipi di dati LOB solo con le tabelle e le viste che includono una chiave primaria.
Per usare le impostazioni per i LOB per una tabella o una vista selezionata, devi creare una regola di mappatura della tabella di tipo `table-settings` con l'opzione `lob-settings`. Questa azione specifica la modalità di gestione dei LOB per la tabella o la vista identificata dall'opzione `object-locator`. All'interno della regola `table-settings` è possibile specificare un oggetto `lob-settings` con i parametri seguenti:
+ `mode`: specifica il meccanismo di gestione della migrazione dei LOB per la tabella o la vista selezionata come segue:
+ `limited`: questa modalità LOB limitata predefinita è la modalità più veloce ed efficiente. Utilizzate questa modalità solo se tutti i vostri dispositivi LOBs sono di piccole dimensioni (entro 100 MB) o se l'endpoint di destinazione non supporta una dimensione LOB illimitata. Inoltre, se la utilizzi`limited`, tutte LOBs devono rientrare nelle dimensioni che hai impostato. `bulk-max-size`
In questa modalità, per un'attività a pieno carico, l'istanza di replica migra tutta LOBs in linea insieme ad altri tipi di dati di colonna come parte dello storage principale di tabelle o viste. Tuttavia, l'istanza tronca tutti i LOB migrati di dimensioni maggiori rispetto al valore `bulk-max-size` riducendoli alla dimensione specificata. Per un'attività di caricamento dei dati di modifica (CDC), l'istanza migra tutta LOBs utilizzando una ricerca nella tabella di origine, come nella modalità LOB completa standard (vedere quanto segue).
**Nota**
Puoi eseguire la migrazione delle viste solo per le attività di caricamento completo.
+ `unlimited`: il meccanismo di migrazione per questa modalità LOB completa varia in base al valore impostato per `bulk-max-size` come segue:
+ **Modalità LOB completa standard**: se impostata su zero, l'istanza `bulk-max-size` di replica migra tutta utilizzando la modalità LOB completa standard. LOBs Questa modalità richiede un'operazione di ricerca nella tabella o nella vista di origine per eseguire la migrazione di ogni LOB, indipendentemente dalle dimensioni. In genere ciò porta a una migrazione molto più lenta rispetto a quelle in modalità LOB limitate. Utilizzate questa modalità solo se tutte o la maggior parte delle vostre unità LOBs sono di grandi dimensioni (1 GB o più).
+ **Modalità combinazione LOB completa**: quando imposti `bulk-max-size` su un valore diverso da zero, la modalità LOB completa utilizza una combinazione di modalità LOB limitata e modalità LOB completa standard. Ciò è valido per un’attività di caricamento completo, se la dimensione del LOB rientra all'interno del valore `bulk-max-size`, l'istanza migra il LOB inline come accade nella modalità LOB limitata. Se la dimensione del LOB è superiore a tale valore, l'istanza esegue la migrazione del LOB utilizzando un'operazione di ricerca nella tabella o nella vista di origine come accade nella modalità standard LOB completa. Per un'attività di caricamento CDC (Change Data Capture), l'istanza migra tutta LOBs utilizzando una ricerca nella tabella di origine, come nella modalità LOB completa standard (vedere quanto segue). Opera in questo modo, indipendentemente dalle dimensioni LOB.
**Nota**
Puoi eseguire la migrazione delle viste solo per le attività di caricamento completo.
In questo modo si ottiene una velocità di migrazione che è un compromesso tra la più veloce modalità LOB limitati e la più lenta modalità standard LOB completi. Utilizzate questa modalità solo quando avete una combinazione di piccole e grandi dimensioni LOBs e la maggior parte di esse sono piccole. LOBs
Questa modalità LOB completa in combinazione è disponibile solo per i seguenti endpoint:
+ IBM Db2 come origine
+ SAP ASE come origine o destinazione
Indipendentemente dal meccanismo specificato per la `unlimited` modalità, l'istanza migra LOBs completamente, senza troncamento.
+ `none`— L'istanza di replica migra nella tabella o LOBs nella vista selezionata utilizzando le impostazioni LOB dell'operazione. Puoi utilizzare questa opzione per confrontare i risultati della migrazione con e senza le impostazioni per LOB specifici per la tabella o la vista selezionata.
Se la tabella o la vista specificata è LOBs inclusa nella replica, è possibile impostare l'`BatchApplyEnabled`attività su `true` solo quando si utilizza la modalità LOB. `limited`
In alcuni casi, è possibile impostare `BatchApplyEnabled` su `true` e `BatchApplyPreserveTransaction` su `false`. In questi casi, l'istanza imposta `BatchApplyPreserveTransaction` `true` se la tabella o la vista hanno LOBs e gli endpoint di origine e di destinazione sono Oracle.
+ `bulk-max-size`: imposta questo valore su zero o un valore diverso da zero in kilobyte, a seconda dell'impostazione di `mode` come descritto per i precedenti elementi. In modalità `limited`, è necessario impostare un valore diverso da zero per il parametro.
L'istanza viene convertita in LOBs formato binario. Pertanto, per indicare il LOB di dimensione massima da replicare, moltiplica le sue dimensioni per tre. Ad esempio, se il tuo LOB è di maggiori dimensioni di 2MB, imposta `bulk-max-size` su 6.000 (6 MB).
## Esempi di impostazioni di tabella
In seguito, puoi trovare alcuni esempi che illustrano l'utilizzo delle impostazioni di tabella.
**Example Carica una tabella segmentata per partizioni**
L'esempio seguente carica una tabella `SALES` presente nell'origine in modo più efficiente eseguendo il caricamento in parallelo sulla base di tutte le sue partizioni.
```
{
"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 Carica una tabella segmentata per partizioni secondarie**
L'esempio seguente carica una tabella `SALES` presente nell'origine in modo più efficiente eseguendo il caricamento in parallelo sulla base di tutte le sue partizioni secondarie.
```
{
"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 Caricare una tabella segmentata tramite un elenco di partizioni**
L'esempio seguente carica una tabella `SALES` presente nell'origine eseguendo il caricamento in parallelo sulla base di uno specifico elenco di partizioni. In questo caso, le partizioni specificate vengono denominate con valori che iniziano con porzioni dell'alfabeto inglese, ad esempio `ABCD`, `EFGH` e così via.
```
{
"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 Caricare una tabella Oracle segmentata tramite un elenco di partizioni e partizioni secondarie selezionate.**
L'esempio seguente carica una tabella `SALES` presente sull'origine Oracle caricandola in parallelo tramite un elenco selezionato di partizioni e partizioni secondarie. In questo caso, le partizioni specificate vengono denominate con valori che iniziano con porzioni dell'alfabeto inglese, ad esempio `ABCD`, `EFGH` e così via. Le partizioni secondarie specificate vengono denominate in base ai valori a partire dai numerali, ad esempio `01234` e `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 Caricare una tabella segmentata per intervalli di valori di colonna**
L'esempio seguente carica una tabella `SALES` presente sull'origine caricandola in parallelo per segmenti specificati da intervalli di valori delle colonne `SALES_NO` e `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"
]
]
}
}
]
}
```
In questo caso, per gli intervalli dei segmenti sono specificate due colonne denominate `SALES_NO` e `REGION`. Sono indicati due delimitazioni con due gruppi di valori di colonna (`["1000","NORTH"]` e `["3000","WEST"]`).
Queste due delimitazioni identificano perciò i seguenti tre segmenti di tabella da caricare in parallelo:
Segmento 1
Righe con `SALES_NO` minore o uguale a 1.000 e `REGION` inferiore a "NORTH". In altre parole, i totali di vendita fino a 1.000 nella regione EAST.
Segmento 2
Righe non incluse nel **Segmento 1** con `SALES_NO` minore o uguale a 3.000 e `REGION` inferiore a "WEST". In altre parole, i totali di vendita maggiori di 1.000 e fino a 3.000 nelle regioni NORTH e SOUTH.
Segmento 3
Tutte le righe rimanenti non incluse nel **Segmento 1** e nel **Segmento 2**. In altre parole, i totali di vendita maggiori di 3.000 nella regione "WEST".
**Example Caricamento di due tabelle: una segmentata per intervalli e l'altra segmentata tramite partizioni**
L'esempio seguente consente di caricare una tabella `SALES` in parallelo per limiti di segmenti che hai identificato. Inoltre, consente di caricare una tabella `ORDERS` in parallelo da tutte le partizioni, come con esempi precedenti.
```
{
"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 Carica una tabella LOBs utilizzando le impostazioni LOB dell'attività**
L'esempio seguente carica una `ITEMS` tabella nell'origine, inclusa tutta LOBs, utilizzando le impostazioni LOB del relativo task. L'impostazione a 100 MB di `bulk-max-size` viene ignorata e lasciata solo per un più rapido ripristino delle modalità `limited` o `unlimited`.
```
{
"rules": [{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "%",
"table-name": "%"
},
"rule-action": "include"
},
{
"rule-type": "table-settings",
"rule-id": "2",
"rule-name": "2",
"object-locator": {
"schema-name": "INV",
"table-name": "ITEMS"
},
"lob-settings": {
"mode": "none",
"bulk-max-size": "100000"
}
}
]
}
```
**Example Carica una tabella LOBs utilizzando la modalità LOB limitata**
L'esempio seguente carica una `ITEMS` tabella inclusa LOBs nel codice sorgente utilizzando la modalità LOB limitata (impostazione predefinita) con una dimensione massima non troncata di 100 MB. Tutte le dimensioni LOBs superiori a questa dimensione vengono troncate a 100 MB. Tutti LOBs vengono caricati in linea con tutti gli altri tipi di dati di colonna.
```
{
"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 Carica una tabella LOBs utilizzando la modalità LOB completa standard**
L'esempio seguente carica una `ITEMS` tabella nell'origine, incluse tutte le relative tabelle LOBs senza troncamento, utilizzando la modalità LOB completa standard. Tutti LOBs, indipendentemente dalle dimensioni, vengono caricati separatamente dagli altri tipi di dati utilizzando una ricerca per ogni LOB nella tabella di origine.
```
{
"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 Carica una tabella LOBs utilizzando la modalità LOB completa combinata**
L'esempio seguente carica una `ITEMS` tabella nell'origine, incluse tutte le relative tabelle LOBs senza troncamento, utilizzando la modalità LOB completa combinata. Tutti i dati di dimensioni inferiori LOBs a 100 MB vengono caricati in linea insieme ad altri tipi di dati, come nella modalità LOB limitata. Tutti i dati di dimensioni LOBs superiori a 100 MB vengono caricati separatamente dagli altri tipi di dati. Questo carico separato utilizza una ricerca per ciascun LOB di questo tipo nella tabella di origine, come nella modalità LOB completa 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"
}
}
]
}
```