

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

Utilizzate le impostazioni della tabella per specificare le impostazioni da applicare a una tabella o vista selezionata per un'operazione specificata. Table-settings le regole sono opzionali, 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)
+ [Table-settings esempi](#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. 


| Parametro | Valori possibili | Description | 
| --- | --- | --- | 
| rule-type | table-settings  | Un valore che applica la regola a una tabella, una vista o una raccolta specificata dalla regola di selezione. | 
| rule-id | Un valore numerico. | Un valore numerico univoco per identificare la regola. | 
| rule-name | Un valore alfanumerico. | Un nome univoco per identificare la regola. | 
| object-locator | Un oggetto con i seguenti parametri:+  `schema-name`: il nome dello schema. Per gli endpoint MongoDB e Amazon DocumentDB, questo è il nome del database che contiene un set di raccolte. <br />+  `table-name`: il nome della tabella, della vista o della raccolta.  | Il nome di uno schema e di una tabella o di una vista specifici o il nome di un database e di una raccolta specifici (senza caratteri jolly). | 
| parallel-load | Un oggetto con i seguenti parametri:+  `type`: specifica se il caricamento in parallelo è attivato.  <br />In questo caso, il parametro specifica anche il meccanismo per identificare le partizioni delle tabelle o delle viste, le partizioni secondarie o altri segmenti da caricare in parallelo. Le partizioni sono segmenti già definiti e identificati in base al nome nella tabella o nella vista di origine.  <br />Per gli endpoint MongoDB e Amazon DocumentDB, le partizioni sono segmenti. AWS DMS può calcolare questi parametri di segmentazione automatica associati automaticamente. In alternativa è possibile specificarli manualmente utilizzando i parametri di segmentazione degli intervalli.  <br />Solo per gli endpoint Oracle, le partizioni secondarie rappresentano un ulteriore livello di segmenti già definiti e identificati in base al nome nella tabella o nella vista di origine. Puoi identificare altri segmenti nella regola `table-settings` specificando i limiti dell'intervallo di valori per una o più colonne della tabella o della vista. <br />+  `partitions`: quando `type` è `partitions-list`, questo valore specifica tutte le partizioni da caricare in parallelo. <br />+  `subpartitions`: solo per gli endpoint Oracle, quando `type` è `partitions-list` questo valore specifica tutte le partizioni secondarie da caricare in parallelo. <br />+  `columns`: quando `type` è `ranges`, questo valore specifica i nomi delle colonne utilizzate per identificare i segmenti basati su intervalli che vengono caricati in parallelo. <br />+  `boundaries`: quando `type` è `ranges`, questo valore specifica i valori di `columns` utilizzati per identificare i segmenti basati su intervalli da caricare in parallelo.  | Specifica un'operazione di caricamento parallelo (multi-thread) sulla tabella o sulla vista identificato dall'opzione `object-locator`. In questo caso, è possibile caricare in parallelo in uno dei seguenti modi: +  Per segmenti specificati da tutte le partizioni disponibili o secondarie. <br />+  Per partizioni selezionate e partizioni secondarie. <br />+  Per segmentazione automatica o segmenti basati su intervalli specificati dall'utente. <br />Per ulteriori informazioni sul caricamento parallelo, consulta [Utilizzo del caricamento parallelo per le tabelle, le viste e le raccolte selezionate](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.ParallelLoad).  | 
| type | Uno dei valori seguenti di parallel-load:+  `partitions-auto`: tutte le partizioni della tabella o della vista vengono caricate in parallelo. Ogni partizione è allocata al proprio thread. <br />Questa è un'impostazione obbligatoria per gli endpoint di origine MongoDB e Amazon DocumentDB per utilizzare l'opzione di segmentazione automatica di un pieno carico parallelo. <br />+  `subpartitions-auto`: (solo per endpoint Oracle) tutte le partizioni secondarie delle tabelle o delle viste vengono caricate in parallelo. Ogni partizione secondaria è allocata al proprio thread. <br />+  `partitions-list`: tutte le partizioni specificate della tabella o della vista vengono caricate in parallelo. Solo per gli endpoint Oracle, tutte le partizioni secondarie specificate delle tabelle o delle viste vengono caricate in parallelo. Ogni partizione e partizione secondaria specificate vengono allocate al proprio thread. Puoi identificare le partizioni e le partizioni secondarie da caricare in parallelo specificando i nomi delle partizioni (`partitions`) e i nomi delle partizioni secondarie (`subpartitions`). <br />+  `ranges`: tutti i segmenti della tabella, della vista o della raccolta specificati dall'intervallo vengono caricati in parallelo. Ogni segmento della tabella, della vista o della raccolta identificato è allocato al proprio thread. Puoi specificare questi segmenti per i nomi delle colonne (`columns`) e i valori delle colonne (`boundaries`). <br />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`). <br />+  `none`: la tabella, la vista o la raccolta viene caricata in un'unica operazione a thread singolo (impostazione predefinita), indipendentemente dalle sue partizioni o dalle partizioni secondarie. Per ulteriori informazioni, consulta [Creazione di un'attività](CHAP_Tasks.Creating.md).  | Il meccanismo per identificare partizioni, partizioni secondarie o segmenti della tabella, della vista o della raccolta da caricare in parallelo. | 
| number-of-partitions | (Facoltativo) Quando type è partitions-auto per raccolte specifiche di un endpoint MongoDB o Amazon DocumentDB, questo parametro specifica il numero totale di partizioni (segmenti) utilizzate per la migrazione. Il valore predefinito è 16. | Specifica il numero esatto di partizioni da caricare in parallelo. | 
|  collection-count-from-metadata | (Facoltativo) Quando si type tratta partitions-auto di raccolte specifiche di un endpoint MongoDB o Amazon DocumentDB e questo parametro è impostato sutrue, AWS DMS utilizza un numero di raccolte stimato per determinare il numero di partizioni. Se questo parametro è impostato sufalse, AWS DMS utilizza il conteggio effettivo delle raccolte. Il valore predefinito è true. | Specifica se utilizzare un numero stimato di raccolte o il numero effettivo di raccolte per calcolare il numero di partizioni da caricare in parallelo. | 
| max-records-skip-per-page | (Facoltativo) Quando type è partitions-auto per raccolte specifiche di un endpoint MongoDB o Amazon DocumentDB, questo è numero di record da ignorare contemporaneamente quando si determinano i limiti di ogni partizione. AWS DMS utilizza un approccio per ignorare con paginazione per determinare il limite minimo di una partizione. Il valore predefinito è 10.000. | Specifica il numero di record da ignorare contemporaneamente quando si determinano i limiti di ogni partizione. L'impostazione di un valore relativamente elevato rispetto a quello predefinito potrebbe causare timeout del cursore e errori delle attività. L'impostazione di un valore relativamente basso rispetto a quello predefinito comporta un numero maggiore di operazioni per pagina e un pieno carico più lento.  | 
| batch-size | (Facoltativo) Quando type è partitions-auto per raccolte specifiche di un endpoint MongoDB o Amazon DocumentDB, questo valore intero limita il numero di documenti restituiti in un batch di andata e ritorno. Se la dimensione del batch è zero (0), il cursore utilizza la dimensione massima del batch definita dal server. Il valore predefinito è 0. | Specifica il numero massimo di documenti restituiti in un batch. Ogni batch richiede un round trip al server. | 
| partitions | Quando type è impostato su partitions-list, questo è un vettore di stringhe che specifica i nomi delle partizioni che vengono caricate in parallelo. | I nomi di partizioni da caricare in parallelo. | 
| subpartitions | (Solo per endpoint Oracle) Quando type è impostato su partitions-list, questo è un vettore di stringhe che specifica i nomi delle partizioni secondarie da caricare in parallelo. | I nomi delle partizioni secondarie da caricare in parallelo. | 
| columns | Quando type è ranges, questa è una matrice di stringhe che specifica i nomi delle colonne utilizzate per identificare i segmenti delle tabelle, delle viste o delle raccolte basati su intervalli da caricare in parallelo. | I nomi delle colonne utilizzate per identificare i segmenti delle tabelle, delle viste o delle raccolte basati su intervalli da caricare in parallelo. | 
| boundaries | Quando type è impostato su ranges, questo è un vettore di vettori di valori di colonna. Ogni vettore di valori di colonna contiene valori di colonna nella quantità e nell'ordine specificati da columns. Una matrice di valori di colonna specifica il limite superiore di un segmento delle tabelle, delle viste o delle raccolte. Ogni matrice di valori di colonna aggiuntiva aggiunge un limite superiore per definire un ulteriore segmento delle tabelle, delle viste o delle raccolte. Tutti questi segmenti delle tabelle, delle viste o delle raccolte basati su intervalli vengono caricati in parallelo. | I valori della colonna che identificano le partizioni delle tabelle, delle viste o delle raccolte basate su intervalli da caricare in parallelo. | 
| lob-settings | Un oggetto con i seguenti parametri:+  `mode`: specifica la modalità di gestione della migrazione per i LOB. <br />+  `bulk-max-size`: specifica le dimensioni massime dei LOB, in base all'impostazione `mode`.  | Un valore che specifica la gestione LOB per la tabella o la vista identificata dall'opzione object-locator. Il LOB specificato sostituisce tutte le attività di gestione delle impostazioni LOB solo per questa tabella o questa vista. Per ulteriori informazioni sull'utilizzo dei parametri delle impostazioni dei LOB, consulta [Definizione delle impostazioni LOB per una tabella o una vista selezionata](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.LOB). | 
| mode | Specifica la gestione della migrazione per i LOB nella tabella o nella vista selezionata utilizzando i seguenti valori:+  `limited`: (impostazione predefinita) questo valore imposta la migrazione nella modalità LOB limitata, con tutti i LOB migrati inline insieme a tutti gli altri tipi di dati di colonna nella tabella o nella vista. Utilizzare questo valore quando si replicano i LOB più piccoli (100 MB o meno). Inoltre, specifica un valore `bulk-max-size` (zero non è valido). Tutti i LOB migrati superiori a `bulk-max-size` vengono troncati alle dimensioni che hai impostato.  <br />+  `unlimited` questo valore imposta la migrazione nella modalità LOB completa. Utilizza questo valore quando tutti o la maggior parte dei LOB che desideri replicare sono di dimensioni superiori a 1 GB. Se si specifica un valore `bulk-max-size` di zero, tutti i LOB vengono migrati in modalità LOB*standard* completa. In questa modalità `unlimited`, viene eseguita separatamente la migrazione di tutti i LOB da altri tipi di dati di colonna utilizzando una ricerca dalla tabella o dalla vista di origine. Se si specifica un valore `bulk-max-size` superiore a zero, tutti i LOB vengono migrati in modalità LOB completa in *combinazione*. In questa modalità `unlimited`, viene eseguita la migrazione dei LOB superiori a `bulk-max-size` utilizzando una ricerca della tabella o della vista di origine, in modo analogo alla modalità LOB standard completa. Al contrario, i LOB fino a questa dimensione vengono migrati inline, in modo analogo a quanto accade per la modalità LOB limitati. Nessun LOB viene mai troncato in modalità `unlimited`, indipendentemente dalla forma utilizzata. <br />+  `none`: viene eseguita la migrazione di tutti i LOB della tabella o della vista in base alle impostazioni per i LOB delle attività.  <br />Per ulteriori informazioni sulle impostazioni per i LOB delle attività, consulta [Impostazioni delle attività dei metadati di destinazione](CHAP_Tasks.CustomizingTasks.TaskSettings.TargetMetadata.md).  <br />Per ulteriori informazioni su come migrare i LOB e su come specificare le impostazioni per i LOB delle attività, consulta [Impostazione del supporto LOB per i database di origine in un AWS DMS task](CHAP_Tasks.LOBSupport.md).   | Il meccanismo utilizzato per migrare i LOB. | 
| bulk-max-size | L'effetto di questo valore dipende dall'impostazione del parametro mode. | Specifica le dimensioni massime dei LOB in incrementi di kilobyte. Specifica questa opzione solo se hai bisogno di replicare LOB di piccole dimensioni o se l'endpoint di destinazione non supporta LOB di dimensioni illimitate. | 

## Utilizzo limitato dei caratteri jolly nelle impostazioni delle tabelle
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.Wildcards"></a>

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, ti AWS consiglia di non caricare un gran numero di raccolte di grandi dimensioni utilizzando una singola attività 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
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.ParallelLoad"></a>

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 pieno carico in thread, con ogni segmento della tabella allocato al proprio 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 in 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` **\*** `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 [Full-load impostazioni delle attività](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 specificate in segmenti che AWS DMS vengono calcolati automaticamente anche utilizzando il tipo e 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 sorgente di MongoDB e Amazon DocumentDB, puoi calcolare AWS DMS automaticamente le partizioni (o i 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. Specificare ogni matrice di valori di colonna come limite superiore, in ordine, di ogni segmento, da quello inferiore a quello successivo della tabella o della vista. 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, supponi di definire tre vettori colonna-valore per le colonne COL1, COL2 e COL3 come segue.


<table>
<thead>
  <tr><th>COL1</th><th>COL2</th><th>COL3</th></tr>
</thead>
<tbody>
  <tr><td>10</td><td>30</td><td>105</td></tr>
  <tr><td>20</td><td>20</td><td>120</td></tr>
  <tr><td>100</td><td>12</td><td>99</td></tr>
</tbody>
</table>


   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
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.LOB"></a>

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. Utilizzare questa modalità solo se tutti i LOB sono piccoli (100 MB al massimo) o l'endpoint di destinazione non supporta un numero illimitato di dimensioni LOB. Anche se utilizzi `limited`, tutti i LOB devono essere entro le dimensioni impostate per `bulk-max-size`. 

    In questa modalità per un'attività di caricamento completo, l'istanza di replica esegue la migrazione di tutti i LOB inline insieme ad altri tipi di dati delle colonne come parte dello storage della tabella o della vista principale. Tuttavia, l'istanza tronca tutti i LOB migrati di dimensioni maggiori rispetto al valore `bulk-max-size` riducendoli alla dimensione specificata. In caso di caricamento per acquisizione delle modifiche dei dati (Change Data Capture, CDC), l'istanza migra tutti i LOB utilizzando un'operazione di ricerca sulla tabella di origine, in modo analogo a quanto accade per la modalità standard LOB completi (vedi uanto 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à standard LOB completa**: quando imposti `bulk-max-size` su zero, l'istanza di replica migra tutti i LOB utilizzando la modalità LOB completa standard. 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. Utilizza questa modalità solo se tutti o la maggior parte dei tuoi LOB sono di grandi dimensioni (1 GB o superiore).
    + **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. In caso di caricamento per acquisizione delle modifiche dei dati (Change Data Capture, CDC), l'istanza migra tutti i LOB utilizzando un'operazione di ricerca sulla tabella di origine, in modo analogo a quanto accade per la modalità standard LOB completi (vedi uanto 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. Utilizza questa modalità solo quando agisci su una combinazione di LOB di piccole e grandi dimensioni e la maggior parte dei LOB sono di piccole dimensioni.

      Questa modalità LOB completa in combinazione è disponibile solo per i seguenti endpoint:
      + IBM Db2 come origine 
      + SAP ASE come origine o destinazione

    Indipendentemente da come viene specificato il meccanismo per la modalità `unlimited`, l'istanza migra tutti i LOB in modo completo, senza troncamento.
  + `none`: l'istanza di replica consente di eseguire la migrazione dei LOB nella tabella o nella vista selezionata utilizzando le impostazioni dei LOB dell'attività. 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 ha LOB inclusi nella replica, puoi impostare l'attività `BatchApplyEnabled` su `true` solo quando si usa la modalità `limited` LOB. 

  In alcuni casi, è possibile impostare `BatchApplyEnabled` su `true` e `BatchApplyPreserveTransaction` su `false`. In questi casi, l'istanza imposta `BatchApplyPreserveTransaction` su `true` se la tabella o la vista ha LOB 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 converte i LOB in 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).

## Table-settings esempi
<a name="CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.Examples"></a>

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 Caricare una tabella con i LOB utilizzando le impostazioni per i LOB dell'attività**  
L'esempio seguente carica una tabella `ITEMS` presente sull'origine, compresi tutti i suoi LOB, utilizzando le impostazioni per i LOB dell'attività. 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 Caricare una tabella con LOB utilizzando la modalità LOB limitati**  
L'esempio seguente carica una tabella `ITEMS` che include i LOB presenti sull'origine utilizzando la modalità LOB limitata (quella predefinita) con una dimensione massima non troncata di 100 MB. Qualsiasi LOB di dimensioni superiori a questa viene troncato a 100 MB. Tutti i LOB vengono caricati in linea assieme a 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 Caricare una tabella con LOB utilizzando la modalità standard LOB completi**  
L'esempio seguente carica una tabella `ITEMS` presente sull'origine, compresi tutti i suoi LOB, senza troncamento utilizzando la modalità LOB completi. Tutti i LOB, indipendentemente dalle dimensioni, vengono caricati separatamente da altri tipi di dati utilizzando un'operazione di ricerca sulla tabella di origine per ogni LOB.  

```
{
   "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 Caricare una tabella con LOB utilizzando la modalità combinazione LOB completi**  
L'esempio seguente carica una tabella `ITEMS` presente sull'origine, compresi tutti i suoi LOB, senza troncamento utilizzando la modalità combinazione LOB completi. Tutti i LOB di dimensione inferiore ai 100 MB vengono caricati inline insieme ad altri tipi di dati, come accade nella modalità LOB limitati. Tutti i LOB di dimensioni 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"
            }
        }
     ]
}
```