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à.
# Utilizzo della mappatura delle tabelle per specificare le impostazioni delle attività
La mappatura delle tabelle utilizza diversi tipi di regole per specificare l'origine dati, lo schema di origine, i dati e le eventuali trasformazioni che devono verificarsi durante l'attività. Puoi utilizzare la mappatura delle tabelle per specificare singole tabelle in un database per eseguire la migrazione e lo schema da utilizzare per la migrazione.
Quando si utilizza la mappatura delle tabelle, è possibile utilizzare i filtri per specificare i dati che si desidera replicare dalle colonne delle tabelle. Inoltre è possibile utilizzare le trasformazioni per modificare schemi, tabelle o viste selezionati prima che vengano scritti nel database di destinazione.
**Topics**
+ [
# Specifica della selezione delle tabelle e delle regole di trasformazione dalla console
](CHAP_Tasks.CustomizingTasks.TableMapping.Console.md)
+ [
# Specifica della selezione delle tabelle e delle regole di trasformazione tramite JSON
](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.md)
+ [
# Operazioni e regole di selezione
](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Selections.md)
+ [
# Caratteri jolly nella mappatura delle tabelle
](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Wildcards.md)
+ [
# Operazioni e regole di trasformazione
](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Transformations.md)
+ [
# Utilizzo delle espressioni delle regole di trasformazione per definire il contenuto delle colonne
](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions.md)
+ [
# Regole e operazioni delle impostazioni di tabella e raccolta
](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.md)
+ [
# Utilizzo del mascheramento dei dati per nascondere informazioni sensibili
](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Masking.md)
**Nota**
Quando si utilizza la mappatura delle tabelle per un endpoint di origine MongoDB, è possibile usare i filtri per specificare i dati da replicare e indicare un nome di database al posto di `schema_name`. In alternativa, puoi usare il valore `"%"` predefinito.
# Specifica della selezione delle tabelle e delle regole di trasformazione dalla console
È possibile utilizzarli Console di gestione AWS per eseguire la mappatura delle tabelle, inclusa la specificazione della selezione e delle trasformazioni delle tabelle. Nella console, utilizza la sezione **Where (Dove)** per specificare lo schema, la tabella e l'operazione (includere o escludere). Utilizza la sezione **Filter (Filtro)** per specificare il nome della colonna in una tabella e le condizioni che desideri applicare a un'attività di replica. Insieme, queste due operazioni creano una regola di selezione.
Puoi includere trasformazioni in una mappatura delle tabelle dopo aver specificato almeno una regola di selezione. Puoi utilizzare le trasformazioni per rinominare uno schema o una tabella, aggiungere un prefisso o un suffisso a uno schema o a una tabella oppure rimuovere la colonna di una tabella.
**Nota**
AWS DMS non supporta più di una regola di trasformazione per livello di schema, livello di tabella o livello di colonna.
Nella procedura seguente viene illustrato come configurare le regole di selezione in base a una tabella chiamata **Customers** in uno schema denominato **EntertainmentAgencySample**.
**Per specificare una selezione delle tabelle, criteri di filtro e trasformazioni mediante la console**
1. Accedi a Console di gestione AWS e apri la AWS DMS console alla [https://console.aws.amazon.com/dms/v2/](https://console.aws.amazon.com/dms/v2/).
Se hai eseguito l'accesso come utente IAM, verifica di disporre delle autorizzazioni appropriate per accedere a AWS DMS. Per ulteriori informazioni sulle autorizzazioni richieste, consulta [Autorizzazioni IAM necessarie per l'uso AWS DMS](security-iam.md#CHAP_Security.IAMPermissions).
1. Nella pagina **Dashboard** scegli **Attività di migrazione del database**.
1. Scegli **Create Task (Crea attività)**.
1. Nella sezione **Configurazione dell'attività** inserisci le informazioni sull'attività, tra cui **Identificativo dell'attività**, **Istanza di replica**, **Endpoint del database di origine**, **Endpoint del database di destinazione** e **Tipo di migrazione**.
![\[Selezione di schemi e tabelle\]](http://docs.aws.amazon.com/it_it/dms/latest/userguide/images/datarep-create-task-20.png)
1. Nella sezione **Mappatura delle tabelle** scegli il nome dello schema e quello della tabella. Quando specifichi il nome dello schema o della tabella, puoi utilizzare "%" come valore di carattere jolly. Per informazioni sugli altri caratteri jolly che puoi usare, consulta [Caratteri jolly nella mappatura delle tabelle](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Wildcards.md). Specifica l'azione da eseguire, per includere o escludere i dati definiti dal filtro.
![\[Selezione di schemi e tabelle\]](http://docs.aws.amazon.com/it_it/dms/latest/userguide/images/datarep-Tasks-selecttransfrm.png)
1. Specifica le informazioni di filtro utilizzando i link **Add column filter (Aggiungi filtro colonna)** e **Add condition (Aggiungi condizione)**.
1. Scegli **Aggiungi filtro colonna** per specificare una colonna e le condizioni.
1. Scegli **Add condition (Aggiungi condizione)** per aggiungere condizioni aggiuntive.
L'esempio seguente mostra un filtro per la tabella **Customers** che include **AgencyIDs** tra **01** e **85**.
![\[Selezione di schemi e tabelle\]](http://docs.aws.amazon.com/it_it/dms/latest/userguide/images/datarep-Tasks-filter.png)
1. Dopo aver creato le selezioni desiderate, scegli **Aggiungi nuova regola di selezione**.
1. Dopo aver creato almeno una regola di selezione, puoi aggiungere una trasformazione all'attività. Scegli **Add transformation rule (Aggiungi regola di trasformazione)**.
![\[Regola di trasformazione\]](http://docs.aws.amazon.com/it_it/dms/latest/userguide/images/datarep-Tasks-transform1.png)
1. Scegli la destinazione che desideri trasformare, quindi immetti le informazioni aggiuntive richieste. L'esempio seguente mostra una trasformazione che elimina la colonna **AgencyStatus** dalla tabella **Customer**.
![\[Regola di trasformazione\]](http://docs.aws.amazon.com/it_it/dms/latest/userguide/images/datarep-Tasks-transform2.png)
1. Scegli **Add transformation rule (Aggiungi regola di trasformazione)**.
1. Scegli **Create task (Crea attività)**.
**Nota**
AWS DMS non supporta più di una regola di trasformazione per livello di schema, livello di tabella o livello di colonna.
# Specifica della selezione delle tabelle e delle regole di trasformazione tramite JSON
Per specificare le mappature delle tabelle che si desidera applicare durante la migrazione, è possibile creare un file JSON. Se si crea un'attività di migrazione utilizzando la console, è possibile cercare questo file JSON o immetterlo direttamente nella casella di mappatura delle tabelle. Se si utilizza la CLI o l'API per eseguire le migrazioni, è possibile specificare questo file utilizzando il parametro `TableMappings` dell'operazione API `CreateReplicationTask` o `ModifyReplicationTask`.
AWS DMS può elaborare solo file JSON di mappatura delle tabelle con dimensioni fino a 2 MB. Si consiglia di mantenere la dimensione del file JSON della regola di mappatura al di sotto del limite di 2 MB durante l'utilizzo di attività DMS. In questo modo si evitano errori imprevisti durante la creazione o la modifica delle attività. Quando un file di regole di mappatura supera il limite di 2 MB, si consiglia di suddividere le tabelle tra più attività per ridurre le dimensioni del file delle regole di mappatura in modo che rimanga al di sotto di questo limite.
Puoi specificare le tabelle, le viste e gli schemi da utilizzare. Puoi anche eseguire trasformazioni di tabelle, viste e schemi e specificare le impostazioni per il modo in cui AWS DMS carica singole tabelle e viste. Puoi creare regole di mappatura delle tabelle per queste opzioni utilizzando i seguenti tipi di regole:
+ Regole `selection`: identificano i tipi e i nomi delle viste, degli schemi e delle tabelle di origine da caricare. Per ulteriori informazioni, consulta [Operazioni e regole di selezione](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Selections.md).
+ Regole `transformation`: specificano determinate modifiche o aggiunte a schemi e tabelle di origine particolari sull'origine prima del caricamento sulla destinazione. Per ulteriori informazioni, consulta [Operazioni e regole di trasformazione](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Transformations.md).
Inoltre, per definire il contenuto di colonne nuove ed esistenti, è possibile utilizzare un'espressione all'interno di una regola di trasformazione. Per ulteriori informazioni, consulta [Utilizzo delle espressioni delle regole di trasformazione per definire il contenuto delle colonne](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions.md).
+ Regole `table-settings`: specificano il modo in cui le attività DMS caricano i dati per le singole tabelle. Per ulteriori informazioni, consulta [Regole e operazioni delle impostazioni di tabella e raccolta](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.md).
**Nota**
Per le destinazioni Amazon S3, è anche possibile aggiungere tag a oggetti S3 mappati a tabelle e schemi selezionati utilizzando il tipo di regola `post-processing` e l'azione della regola `add-tag`. Per ulteriori informazioni, consulta [Applicazione di tag agli oggetti Amazon S3](CHAP_Target.S3.md#CHAP_Target.S3.Tagging).
Per le destinazioni seguenti, puoi specificare come e dove gli schemi e le tabelle selezionati vengono migrati verso la destinazione utilizzando il tipo di regola `object-mapping`:
Amazon DynamoDB: per ulteriori informazioni, consulta [Utilizzo della mappatura degli oggetti per la migrazione dei dati a DynamoDB](CHAP_Target.DynamoDB.md#CHAP_Target.DynamoDB.ObjectMapping).
Amazon Kinesis: per ulteriori informazioni, consulta [Utilizzo della mappatura degli oggetti per la migrazione dei dati a un flusso di dati Kinesis](CHAP_Target.Kinesis.md#CHAP_Target.Kinesis.ObjectMapping).
Apache Kafka: per ulteriori informazioni, consulta [Utilizzo della mappatura degli oggetti per la migrazione dei dati in un argomento Kafka](CHAP_Target.Kafka.md#CHAP_Target.Kafka.ObjectMapping).
# Operazioni e regole di selezione
Mediante la mappatura delle tabelle, puoi specificare quali tabelle, viste e schemi desideri utilizzare tramite regole e operazioni di selezione. Per le regole di mappatura delle tabelle che utilizzano il tipo di regola di selezione, sono applicabili i seguenti valori.
**avvertimento**
Non includere dati sensibili all'interno di queste regole.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/dms/latest/userguide/CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Selections.html)
**Example Migrazione di tutte le tabelle in uno schema**
Nell'esempio seguente viene eseguita la migrazione di tutte le tabelle da uno schema denominato `Test` nell'origine all'endpoint di destinazione.
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "Test",
"table-name": "%"
},
"rule-action": "include"
}
]
}
```
**Example Migrazione di alcune tabelle in uno schema**
Nell'esempio seguente viene eseguita la migrazione di tutte le tabelle tranne quelle che iniziano per `DMS` da uno schema denominato `Test` nell'origine all'endpoint di destinazione.
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "Test",
"table-name": "%"
},
"rule-action": "include"
},
{
"rule-type": "selection",
"rule-id": "2",
"rule-name": "2",
"object-locator": {
"schema-name": "Test",
"table-name": "DMS%"
},
"rule-action": "exclude"
}
]
}
```
**Example Migrazione di una singola tabella specificata in un singolo schema**
Nell'esempio seguente la tabella `Customer` viene migrata dallo schema `NewCust` nell'origine all'endpoint di destinazione.
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "NewCust",
"table-name": "Customer"
},
"rule-action": "explicit"
}
]
}
```
È possibile selezionare esplicitamente più tabelle e schemi specificando più regole di selezione.
**Example Migrazione di tabelle in un ordine impostato**
Le tabelle e le viste vengono migrate in base ai rispettivi valori dell'ordine di caricamento, con i valori più alti che ricevono la priorità nella sequenza di migrazione. L'esempio seguente migra due tabelle, `loadfirst` con un valore di priorità pari a 2 e `loadsecond` con un valore di priorità pari a 1, il task di migrazione elaborerà innanzitutto la tabella prima di procedere alla `loadfirst` tabella. `loadsecond` Questo meccanismo di prioritizzazione garantisce il rispetto delle dipendenze tra gli oggetti del database durante il processo di migrazione.
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "Test",
"table-name": "loadsecond"
},
"rule-action": "include",
"load-order": "1"
},
{
"rule-type": "selection",
"rule-id": "2",
"rule-name": "2",
"object-locator": {
"schema-name": "Test",
"table-name": "loadfirst"
},
"rule-action": "include",
"load-order": "2"
}
]
}
```
**Nota**
`load-order` è applicabile per l'inizializzazione della tabella. Il caricamento di una tabella successiva non attende il completamento del caricamento della tabella precedente se `MaxFullLoadSubTasks` è maggiore di 1.
**Example Migrazione di alcune viste in uno schema**
L'esempio seguente esegue la migrazione di alcune viste da uno schema denominato `Test` nell'origine a tabelle equivalenti nella destinazione.
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "2",
"rule-name": "2",
"object-locator": {
"schema-name": "Test",
"table-name": "view_DMS%",
"table-type": "view"
},
"rule-action": "include"
}
]
}
```
**Example Migrazione di tutte le tabelle e tutte le viste in uno schema**
L'esempio seguente esegue la migrazione di tutte le tabelle e tutte le viste da uno schema denominato `report` nell'origine a tabelle equivalenti nella destinazione.
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "3",
"rule-name": "3",
"object-locator": {
"schema-name": "report",
"table-name": "%",
"table-type": "all"
},
"rule-action": "include"
}
]
}
```
# Caratteri jolly nella mappatura delle tabelle
Questa sezione descrive i caratteri jolly che è possibile utilizzare per specificare il nomi dello schema e della tabella per la mappatura delle tabelle.
| Carattere jolly | Corrispondenze |
| --- |--- |
| % | Zero o più caratteri |
| \$1 | Un singolo personaggio |
| [\$1] | Un carattere di sottolineatura letterale |
| [ab] | Un set di caratteri. Ad esempio, [ab] corrisponde a 'a' o 'b'. |
| [a-d] | Una serie di personaggi. Ad esempio, [a-d] corrisponde a 'a', 'b', 'c' o 'd'. |
Per gli endpoint di origine e di destinazione Oracle, è possibile utilizzare l'attributo aggiuntivo di connessione `escapeCharacter` per specificare un carattere di escape. Un carattere di escape consente di usare nelle espressioni un carattere jolly specificato come se non fosse un carattere wild. Ad esempio, `escapeCharacter=#` consente di utilizzare "\$1" per fare in modo che in un'espressione un carattere jolly agisca come un normale carattere, come in questo codice di esempio.
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "542485267",
"rule-name": "542485267",
"object-locator": { "schema-name": "ROOT", "table-name": "TEST#_T%" },
"rule-action": "include",
"filters": []
}
]
}
```
Qui, il carattere di escape '\$1' fa sì che il carattere jolly '\$1' si comporti come un carattere normale. AWS DMS seleziona le tabelle nello schema denominato`ROOT`, dove ogni tabella ha un nome `TEST_T` come prefisso.
# Operazioni e regole di trasformazione
Puoi utilizzare le operazioni di trasformazione per specificare le trasformazioni che desideri applicare alla tabella selezionata, allo schema selezionato o alla vista selezionata. Le regole di trasformazione sono opzionali.
## Limitazioni
+ Non è possibile applicare più di un'azione della regola di trasformazione sullo stesso oggetto (schema, tabella, colonna, table-tablespace o index-tablespace). È possibile applicare diverse azioni delle regole di trasformazione a qualsiasi livello, purché ogni azione di trasformazione venga applicata a un oggetto diverso. Tuttavia, questa restrizione non è applicabile quando si utilizzano regole di trasformazione con mascheramento dei dati in cui è possibile avere un'altra trasformazione simile o per la stessa colonna. `ADD-COLUMN` `CHANGE-DATA-TYPE`
+ I nomi di tabella e di colonna nelle regole di trasformazione rispettano la distinzione tra maiuscole e minuscole. Ad esempio, è necessario specificare in maiuscolo i nomi delle tabelle e delle colonne per un database Oracle o Db2.
+ Le trasformazioni non sono supportate per i nomi di colonna con lingue. Right-to-Left
+ Le trasformazioni non possono essere eseguite su colonne che includono nel nome caratteri speciali (ad esempio \$1, \$1, /, -).
+ L'unica trasformazione supportata per le colonne mappate ai tipi di BLOB/CLOB dati consiste nel rilasciare la colonna sulla destinazione.
+ AWS DMS non supporta la replica di due tabelle di origine in un'unica tabella di destinazione. AWS DMS replica i record da una tabella all'altra e da una colonna all'altra, in base alle regole di trasformazione dell'attività di replica. I nomi degli oggetti devono essere univoci per evitare sovrapposizioni.
Ad esempio, una tabella di origine ha una colonna denominata `ID` e la tabella di destinazione corrispondente ha una colonna preesistente denominata `id`. Se una regola utilizza un'`ADD-COLUMN`istruzione per aggiungere una nuova colonna `id` denominata e un' SQLite istruzione per popolare la colonna con valori personalizzati, ciò crea un oggetto duplicato e ambiguo denominato `id` e non è supportato.
+ Quando si crea una regola di trasformazione, si consiglia di utilizzare il `data-type` parametro solo quando le regole di selezione specificano più colonne, ad esempio quando si imposta su. `column-name` `%` Non è consigliabile utilizzarlo `data-type` per selezionare una singola colonna.
+ AWS DMS non supporta le regole di trasformazione in cui gli oggetti di origine e di destinazione (tabelle) si trovano sullo stesso database/schema. L'utilizzo della stessa tabella come origine e destinazione in una regola di trasformazione può portare a risultati imprevisti e potenzialmente dannosi, tra cui, a titolo esemplificativo ma non esaustivo, alterazioni involontarie dei dati della tabella, modifiche delle strutture delle tabelle o persino l'eliminazione delle tabelle.
## Valori
Per le regole di mappatura delle tabelle che utilizzano il tipo di regola di trasformazione, sono applicabili i seguenti valori.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/dms/latest/userguide/CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Transformations.html)
## Esempi
**Example Assegnazione di un nuovo nome a uno schema**
Nell'esempio seguente viene rinominato uno schema da `Test` nell'origine a `Test1` nella destinazione.
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "Test",
"table-name": "%"
},
"rule-action": "include"
},
{
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-action": "rename",
"rule-target": "schema",
"object-locator": {
"schema-name": "Test"
},
"value": "Test1"
}
]
}
```
**Example Rinominare una tabella**
Nell'esempio seguente viene rinominata una tabella da `Actor` nell'origine a `Actor1` nella destinazione.
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "Test",
"table-name": "%"
},
"rule-action": "include"
},
{
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-action": "rename",
"rule-target": "table",
"object-locator": {
"schema-name": "Test",
"table-name": "Actor"
},
"value": "Actor1"
}
]
}
```
**Example Ridenominazione di una colonna**
Nell'esempio seguente viene rinominata una colonna nella tabella `Actor` da `first_name` nell'origine a `fname` nella destinazione.
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "test",
"table-name": "%"
},
"rule-action": "include"
},
{
"rule-type": "transformation",
"rule-id": "4",
"rule-name": "4",
"rule-action": "rename",
"rule-target": "column",
"object-locator": {
"schema-name": "test",
"table-name": "Actor",
"column-name" : "first_name"
},
"value": "fname"
}
]
}
```
**Example Rinominare uno spazio tabella di tabella Oracle**
L'esempio seguente rinomina lo spazio tabella di tabella denominato `SetSpace` per una tabella denominata `Actor` nell'origine Oracle in `SceneTblSpace` nell'endpoint Oracle di destinazione.
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "Play",
"table-name": "%"
},
"rule-action": "include"
},
{
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-action": "rename",
"rule-target": "table-tablespace",
"object-locator": {
"schema-name": "Play",
"table-name": "Actor",
"table-tablespace-name": "SetSpace"
},
"value": "SceneTblSpace"
}
]
}
```
**Example Rinominare uno spazio tabella di indice Oracle**
L'esempio seguente rinomina lo spazio tabella di indice denominato `SetISpace` per una tabella denominata `Actor` nell'origine Oracle in `SceneIdxSpace` nell'endpoint Oracle di destinazione.
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "Play",
"table-name": "%"
},
"rule-action": "include"
},
{
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-action": "rename",
"rule-target": "table-tablespace",
"object-locator": {
"schema-name": "Play",
"table-name": "Actor",
"table-tablespace-name": "SetISpace"
},
"value": "SceneIdxSpace"
}
]
}
```
**Example Aggiungere una colonna**
Nell'esempio seguente viene aggiunta una colonna `datetime` alla tabella `Actor` nello schema `test`.
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "test",
"table-name": "%"
},
"rule-action": "include"
},
{
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-action": "add-column",
"rule-target": "column",
"object-locator": {
"schema-name": "test",
"table-name": "actor"
},
"value": "last_updated",
"data-type": {
"type": "datetime",
"precision": 6
}
}
]
}
```
**Example Rimozione di una colonna**
Nell'esempio seguente viene trasformata la tabella denominata `Actor` nell'origine per rimuovere da essa tutte le colonne che iniziano con i caratteri `col` nella destinazione.
```
{
"rules": [{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "test",
"table-name": "%"
},
"rule-action": "include"
}, {
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-action": "remove-column",
"rule-target": "column",
"object-locator": {
"schema-name": "test",
"table-name": "Actor",
"column-name": "col%"
}
}]
}
```
**Example Conversione in minuscolo**
Nell'esempio seguente viene convertito un nome di tabella da `ACTOR` nell'origine a `actor` nella destinazione.
```
{
"rules": [{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "test",
"table-name": "%"
},
"rule-action": "include"
}, {
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-action": "convert-lowercase",
"rule-target": "table",
"object-locator": {
"schema-name": "test",
"table-name": "ACTOR"
}
}]
}
```
**Example Conversione in caratteri maiuscoli**
Nell'esempio seguente vengono convertite tutte le colonne in tutte le tabelle e tutti gli schemi da caratteri minuscoli nell'origine a caratteri maiuscoli nella destinazione.
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "test",
"table-name": "%"
},
"rule-action": "include"
},
{
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-action": "convert-uppercase",
"rule-target": "column",
"object-locator": {
"schema-name": "%",
"table-name": "%",
"column-name": "%"
}
}
]
}
```
**Example Aggiunta di un prefisso**
Nell'esempio seguente tutte le tabelle nell'origine vengono trasformate con l'aggiunta del prefisso `DMS_` nella destinazione.
```
{
"rules": [{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "test",
"table-name": "%"
},
"rule-action": "include"
}, {
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-action": "add-prefix",
"rule-target": "table",
"object-locator": {
"schema-name": "test",
"table-name": "%"
},
"value": "DMS_"
}]
}
```
**Example Sostituzione di un prefisso**
Nell'esempio seguente tutte le colonne contenenti il prefisso `Pre_` nell'origine vengono trasformate mediante la sostituzione del prefisso con `NewPre_` nella destinazione.
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "test",
"table-name": "%"
},
"rule-action": "include"
},
{
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-action": "replace-prefix",
"rule-target": "column",
"object-locator": {
"schema-name": "%",
"table-name": "%",
"column-name": "%"
},
"value": "NewPre_",
"old-value": "Pre_"
}
]
}
```
**Example Rimozione di un suffisso**
Nell'esempio seguente tutte le tabelle nell'origine vengono trasformate con la rimozione del suffisso `_DMS` nella destinazione.
```
{
"rules": [{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "test",
"table-name": "%"
},
"rule-action": "include"
}, {
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-action": "remove-suffix",
"rule-target": "table",
"object-locator": {
"schema-name": "test",
"table-name": "%"
},
"value": "_DMS"
}]
}
```
**Example Definire una chiave primaria**
L'esempio seguente definisce una chiave primaria denominata `ITEM-primary-key` su tre colonne della tabella `ITEM` migrata nell'endpoint di destinazione.
```
{
"rules": [{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "inventory",
"table-name": "%"
},
"rule-action": "include"
}, {
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-action": "define-primary-key",
"rule-target": "table",
"object-locator": {
"schema-name": "inventory",
"table-name": "ITEM"
},
"primary-key-def": {
"name": "ITEM-primary-key",
"columns": [
"ITEM-NAME",
"BOM-MODEL-NUM",
"BOM-PART-NUM"
]
}
}]
}
```
**Example Definire un indice univoco**
L'esempio seguente definisce un indice univoco denominato `ITEM-unique-idx` su tre colonne della tabella `ITEM` migrata verso l'endpoint di destinazione.
```
{
"rules": [{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "inventory",
"table-name": "%"
},
"rule-action": "include"
}, {
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-action": "define-primary-key",
"rule-target": "table",
"object-locator": {
"schema-name": "inventory",
"table-name": "ITEM"
},
"primary-key-def": {
"name": "ITEM-unique-idx",
"origin": "unique-index",
"columns": [
"ITEM-NAME",
"BOM-MODEL-NUM",
"BOM-PART-NUM"
]
}
}]
}
```
**Example Modifica del tipo di dati della colonna di destinazione**
Nell'esempio seguente viene modificato il tipo di dati di una colonna di destinazione denominata `SALE_AMOUNT` da un tipo di dati esistente su `int8`.
```
{
"rule-type": "transformation",
"rule-id": "1",
"rule-name": "RuleName 1",
"rule-action": "change-data-type",
"rule-target": "column",
"object-locator": {
"schema-name": "dbo",
"table-name": "dms",
"column-name": "SALE_AMOUNT"
},
"data-type": {
"type": "int8"
}
}
```
**Example Aggiungere una colonna dell'immagine precedente**
Per una colonna di origine denominata `emp_no`, la regola di trasformazione nell'esempio seguente aggiunge una nuova colonna denominata `BI_emp_no` nella destinazione.
```
{
"rules": [{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "%",
"table-name": "%"
},
"rule-action": "include"
},
{
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-target": "column",
"object-locator": {
"schema-name": "%",
"table-name": "employees"
},
"rule-action": "add-before-image-columns",
"before-image-def": {
"column-prefix": "BI_",
"column-suffix": "",
"column-filter": "pk-only"
}
}
]
}
```
Qui, l'istruzione seguente popola una colonna `BI_emp_no` nella riga corrispondente con 1.
```
UPDATE employees SET emp_no = 3 WHERE BI_emp_no = 1;
```
Quando si scrivono aggiornamenti CDC su AWS DMS destinazioni supportate, la `BI_emp_no` colonna consente di stabilire quali righe hanno valori aggiornati nella colonna. `emp_no`
# Utilizzo delle espressioni delle regole di trasformazione per definire il contenuto delle colonne
Per definire il contenuto per colonne nuove ed esistenti, è possibile utilizzare un'espressione all'interno di una regola di trasformazione. Ad esempio, utilizzando le espressioni è possibile aggiungere una colonna o replicare intestazioni di tabella di origine a una destinazione. È inoltre possibile utilizzare le espressioni per contrassegnare i record nelle tabelle di destinazione come inseriti, aggiornati o eliminati nell'origine.
**Topics**
+ [
## Aggiunta di una colonna mediante un'espressione
](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-adding)
+ [
## Contrassegno dei record di destinazione mediante un'espressione
](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-Flagging)
+ [
## Replica delle intestazioni della tabella di origine mediante espressioni
](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-Headers)
+ [
## Utilizzo di SQLite funzioni per creare espressioni
](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-SQLite)
+ [
## Aggiunta di metadati a una tabella di destinazione utilizzando espressioni
](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-Metadata)
## Aggiunta di una colonna mediante un'espressione
Per aggiungere colonne alle tabelle utilizzando un'espressione in una regola di trasformazione, utilizzare un'azione della regola `add-column` e una destinazione della regola `column`.
Nell'esempio seguente viene aggiunta una nuova colonna alla tabella `ITEM`. Imposta il nome della nuova colonna su `FULL_NAME`, con un tipo di dati di `string`, lungo 50 caratteri. L'espressione concatena i valori di due colonne esistenti `FIRST_NAME` e `LAST_NAME`, da valutare per `FULL_NAME`. `schema-name`, `table-name` e i parametri di espressione si riferiscono agli oggetti nella tabella del database di origine. `Value` e il blocco `data-type` si riferiscono agli oggetti nella tabella del database di destinazione.
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "Test",
"table-name": "%"
},
"rule-action": "include"
},
{
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-action": "add-column",
"rule-target": "column",
"object-locator": {
"schema-name": "Test",
"table-name": "ITEM"
},
"value": "FULL_NAME",
"expression": "$FIRST_NAME||'_'||$LAST_NAME",
"data-type": {
"type": "string",
"length": 50
}
}
]
}
```
## Contrassegno dei record di destinazione mediante un'espressione
Per contrassegnare i record nelle tabelle di destinazione come inseriti, aggiornati o eliminati nella tabella di origine, utilizzare un'espressione in una regola di trasformazione. L'espressione utilizza una funzione `operation_indicator` per contrassegnare i record. I record eliminati dall'origine non vengono eliminati dalla destinazione. Al contrario, il record di destinazione viene contrassegnato con un valore fornito dall'utente per indicare che è stato eliminato dall'origine.
**Nota**
La funzione `operation_indicator` funziona solo su tabelle che hanno una chiave primaria sul database di origine e di destinazione.
Ad esempio, la regola di trasformazione seguente aggiunge prima una nuova colonna `Operation` a una tabella di destinazione. Quindi aggiorna la colonna con il valore `D` ogni volta che un record viene eliminato da una tabella di origine.
```
{
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-target": "column",
"object-locator": {
"schema-name": "%",
"table-name": "%"
},
"rule-action": "add-column",
"value": "Operation",
"expression": "operation_indicator('D', 'U', 'I')",
"data-type": {
"type": "string",
"length": 50
}
}
```
## Replica delle intestazioni della tabella di origine mediante espressioni
Per impostazione predefinita, le intestazioni per le tabelle di origine non vengono replicate nella destinazione. Per indicare le intestazioni da replicare, utilizzare una regola di trasformazione con un'espressione che include l'intestazione di colonna della tabella.
Nelle espressioni è possibile utilizzare le intestazioni di colonna seguenti.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/dms/latest/userguide/CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions.html)
Nell'esempio seguente viene aggiunta una nuova colonna alla destinazione utilizzando il valore della posizione del flusso dall'origine. Per SQL Server, il valore della posizione del flusso è il LSN dell'endpoint di origine. Per Oracle, il valore della posizione del flusso è il SCN dell'endpoint di origine.
```
{
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-target": "column",
"object-locator": {
"schema-name": "%",
"table-name": "%"
},
"rule-action": "add-column",
"value": "transact_id",
"expression": "$AR_H_STREAM_POSITION",
"data-type": {
"type": "string",
"length": 50
}
}
```
L'esempio seguente aggiunge una nuova colonna alla destinazione con un numero incrementale univoco dell'origine. Questo valore rappresenta un numero univoco di 35 cifre a livello di attività. Le prime 16 cifre fanno parte del timestamp e le ultime 19 cifre sono il numero record\$1id incrementato dal DBMS.
```
{
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-target": "column",
"object-locator": {
"schema-name": "%",
"table-name": "%"
},
"rule-action": "add-column",
"value": "transact_id",
"expression": "$AR_H_CHANGE_SEQ",
"data-type": {
"type": "string",
"length": 50
}
}
```
## Utilizzo di SQLite funzioni per creare espressioni
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 a livello di impostazioni di tabella sono facoltative.
**Nota**
Invece di tabelle e viste, i database MongoDB e DocumentDB archiviano i record di dati come documenti che vengono archiviati in *raccolte*. Quindi, quando esegui la migrazione da una origine MongoDB o DocumentDB, considera il tipo di segmentazione dell'intervallo delle impostazioni di caricamento parallelo per le *raccolte* selezionate anziché le tabelle e le viste.
**Topics**
+ [
### Utilizzo di un'espressione CASE
](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-SQLite.CASE)
+ [
### Esempi
](#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Expressions-SQLite.Ex)
Di seguito sono disponibili le funzioni di stringa che puoi utilizzare per creare espressioni di regole di trasformazione.
| Funzioni stringa | Description |
| --- | --- |
| `lower(x)` | La funzione `lower(x)` restituisce una copia della stringa *`x`* con tutti i caratteri convertiti in minuscolo. La funzione `lower` predefinita e integrata funziona solo per i caratteri ASCII. |
| `upper(x)` | La funzione `upper(x)` restituisce una copia della stringa *`x`* con tutti i caratteri convertiti in maiuscolo. La funzione `upper` predefinita e integrata funziona solo per i caratteri ASCII. |
| `ltrim(x,y)` | La funzione `ltrim(x,y)` restituisce una stringa formata rimuovendo tutti i caratteri presenti in y dal lato sinistro di x. Se non è presente alcun valore per y, `ltrim(x)` rimuove gli spazi dal lato sinistro di x. |
| `replace(x,y,z)` | La funzione `replace(x,y,z)` restituisce una stringa formata sostituendo la stringa z per ogni occorrenza della stringa y nella stringa x. |
| `rtrim(x,y)` | La funzione `rtrim(x,y)` restituisce una stringa formata rimuovendo tutti i caratteri presenti in y dal lato destro di x. Se non è presente alcun valore per y, `rtrim(x)` rimuove gli spazi dal lato destro di x. |
| `substr(x,y,z)` | La funzione `substr(x,y,z)` restituisce una sottostringa della stringa di input `x` che inizia con il carattere `y`th e che è lunga *`z`* caratteri. Se *`z`* viene omesso, `substr(x,y)` restituisce tutti i caratteri fino alla fine della stringa `x` che inizia con il carattere `y`th. Il carattere più a sinistra di `x` è il numero 1. Se *`y`* è negativo, il primo carattere della sottostringa viene trovato contando da destra anziché da sinistra. Se *`z`* è negativo, vengono restituiti i caratteri `abs(z)` che precedono il carattere `y`th. Se `x` è una stringa, gli indici dei caratteri si riferiscono ai caratteri UTF-8 effettivi. Se `x` è un BLOB, gli indici si riferiscono ai byte. |
| trim(x,y) | La funzione `trim(x,y)` restituisce una stringa formata rimuovendo tutti i caratteri presenti in `y` da entrambi i lati di `x`. Se non è presente alcun valore per `y`, `trim(x)` rimuove gli spazi da entrambi i lati di `x`. |
Di seguito sono disponibili le funzioni LOB che puoi utilizzare per creare espressioni di regole di trasformazione.
| Funzioni LOB | Description |
| --- | --- |
| `hex(x)` | La funzione `hex` riceve un BLOB come argomento e restituisce una versione in stringa esadecimale maiuscola del contenuto del BLOB. |
| `randomblob (N)` | La funzione `randomblob(N)` restituisce un BLOB di `N` byte che contiene byte pseudocasuali. Se *N* è inferiore a 1, viene restituito un BLOB casuale da 1 byte. |
| `zeroblob(N)` | La funzione `zeroblob(N)` restituisce un BLOB composto da `N` byte di 0x00. |
Di seguito sono disponibili le funzioni numeriche che puoi utilizzare per creare espressioni di regole di trasformazione.
| Funzioni numeriche | Description |
| --- | --- |
| `abs(x)` | La funzione `abs(x)` restituisce il valore assoluto dell'argomento numerico `x`. La `abs(x)` funzione restituisce NULL se è NULL. *x* La `abs(x)` funzione restituisce 0.0 se **x** è una stringa o un BLOB che non può essere convertito in un valore numerico. |
| `random()` | La funzione `random` restituisce un intero pseudocasuale compreso tra -9.223.372.036.854.775.808 e \$19.223.372.036.854.775.807. |
| `round (x,y)` | La `round (x,y)` funzione restituisce un valore a virgola mobile *x* arrotondato alle *y* cifre a destra del punto decimale. Se non è presente alcun valore per*y*, si presume che sia 0. |
| `max (x,y...)` | La funzione `max` multiargomento restituisce l'argomento con il valore massimo o restituisce NULL se un argomento è NULL. La funzione `max` cerca negli argomenti da sinistra a destra un argomento che definisca una funzione di confronto. Se ne viene trovato uno, utilizza la funzione delle regole di confronto per i confronti tra tutte le stringhe. Se nessuno degli argomenti per `max` definiscono una funzione delle regole di confronto, viene utilizzata la funzione delle regole di confronto `BINARY`. La funzione `max` è una funzione semplice quando ha due o più argomenti, ma viene usata come una funzione aggregata se ha un solo argomento. |
| `min (x,y...)` | La funzione `min` multiargomento restituisce l'argomento con il valore minimo. La funzione `min` cerca negli argomenti da sinistra a destra un argomento che definisca una funzione di confronto. Se ne viene trovato uno, utilizza la funzione delle regole di confronto per i confronti tra tutte le stringhe. Se nessuno degli argomenti per `min` definiscono una funzione delle regole di confronto, viene utilizzata la funzione delle regole di confronto `BINARY`. La funzione `min` è una funzione semplice quando ha due o più argomenti, ma viene usata come una funzione aggregata se ha un solo argomento. |
Di seguito sono disponibili le funzioni di controllo NULL che puoi utilizzare per creare espressioni di regole di trasformazione.
| Funzioni di controllo NULL | Description |
| --- | --- |
| `coalesce (x,y...)` | La funzione `coalesce` restituisce una copia del primo argomento non NULL, ma restituisce NULL se tutti gli argomenti sono NULL. La funzione coalesce ha almeno due argomenti. |
| `ifnull(x,y)` | La funzione `ifnull` restituisce una copia del primo argomento non NULL, ma restituisce NULL se entrambi gli argomenti sono NULL. La funzione `ifnull` ha esattamente due argomenti. La funzione `ifnull` è uguale a `coalesce` con due argomenti. |
| `nullif(x,y)` | La funzione `nullif(x,y)` restituisce una copia del primo argomento se gli argomenti sono diversi, ma restituisce NULL se gli argomenti sono gli stessi. La funzione `nullif(x,y)` cerca negli argomenti da sinistra a destra un argomento che definisca una funzione di confronto. Se ne viene trovato uno, utilizza la funzione delle regole di confronto per i confronti tra tutte le stringhe. Se nessuno degli argomenti per nullif definisce una funzione delle regole di confronto, viene utilizzata la funzione delle regole di confronto `BINARY`. |
Di seguito sono disponibili le funzioni di data e ora che puoi utilizzare per creare espressioni di regole di trasformazione.
| Funzioni di data e ora | Description |
| --- | --- |
| `date(timestring, modifier, modifier...)` | La `date` funzione restituisce la data nel formato YYYY-MM-DD. |
| `time(timestring, modifier, modifier...)` | La funzione `time` restituisce l'ora nel formato HH:MM:SS. |
| `datetime(timestring, modifier, modifier...)` | La `datetime` funzione restituisce la data e l'ora nel formato YYYY-MM-DD HH:MM:SS. |
| `julianday(timestring, modifier, modifier...)` | La funzione `julianday` restituisce il numero di giorni trascorsi dal mezzogiorno di Greenwich del 24 novembre 4714 a.C. |
| `strftime(format, timestring, modifier, modifier...)` | La funzione `strftime` restituisce la data in base alla stringa di formato specificata come primo argomento, utilizzando una delle seguenti variabili: `%d`: giorno del mese `%H`: ora 00-24 `%f`: \$1\$1 secondi frazionari SS.SSS `%j`: giorno dell'anno 001-366 `%J`: \$1\$1 numero del giorno del calendario giuliano `%m`: mese 01-12 `%M`: minuti 00-59 `%s`: secondi dal 1970-01-01 `%S`: secondi 00-59 `%w`: giorno della settimana 0-6 domenica==0 `%W`: settimana dell'anno 00-53 `%Y`: anno 0000-9999 `%%`: % |
Di seguito è disponibile una funzione hash che puoi utilizzare per creare espressioni di regole di trasformazione.
| Funzione hash | Description |
| --- | --- |
| `hash_sha256(x)` | La funzione `hash` genera un valore hash per una colonna di input (utilizzando l'algoritmo SHA-256) e restituisce il valore esadecimale del valore hash generato. Per utilizzare la funzione `hash` in un'espressione, aggiungi `hash_sha256(x)` all'espressione e sostituisci *`x`* con il nome della colonna di origine. |
### Utilizzo di un'espressione CASE
L' SQLite `CASE`espressione valuta un elenco di condizioni e restituisce un'espressione basata sul risultato. La sintassi viene mostrata di seguito.
```
CASE case_expression
WHEN when_expression_1 THEN result_1
WHEN when_expression_2 THEN result_2
...
[ ELSE result_else ]
END
# Or
CASE
WHEN case_expression THEN result_1
WHEN case_expression THEN result_2
...
[ ELSE result_else ]
END
```
### Esempi
**Example di aggiunta di una nuova colonna di stringhe alla tabella di destinazione utilizzando una condizione case**
Ad esempio, la regola di trasformazione seguente aggiunge la nuova colonna di stringhe `emp_seniority` alla tabella di destinazione `employee`. Utilizza la SQLite `round` funzione nella colonna dello stipendio, con una condizione maiuscola per verificare se lo stipendio è pari o superiore a 20.000. In tal caso, la colonna ottiene il valore `SENIOR` e ogni altra cosa ha il valore `JUNIOR`.
```
{
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-action": "add-column",
"rule-target": "column",
"object-locator": {
"schema-name": "public",
"table-name": "employee"
},
"value": "emp_seniority",
"expression": " CASE WHEN round($emp_salary)>=20000 THEN ‘SENIOR’ ELSE ‘JUNIOR’ END",
"data-type": {
"type": "string",
"length": 50
}
}
```
**Example di aggiungere una nuova colonna di stringhe alla tabella di destinazione utilizzando una funzione SUBSTR**
La seguente regola di trasformazione di esempio aggiunge una nuova colonna di stringhe utilizzando SQLite operatori o funzioni per definire i dati in una colonna. Questo approccio prevede l'utilizzo di SQLite funzioni per trasformare i dati GUID caricati da Oracle in formato UUID prima di inserirli nella tabella di destinazione Postgresql.
La regola seguente utilizza le funzioni SQLite sottostringa (SUBSTR), funzione esadecimale (HEX) e minuscola (LOWER) per suddividere i dati GUID in diversi gruppi separati da trattini, in particolare un gruppo di 8 cifre seguito da tre gruppi di 4 cifre seguiti da un gruppo di 12 cifre, per un totale di 32 cifre che rappresentano i 128 bit.
Ecco i dati di origine e l'output di esempio sulla post-elaborazione del target tramite la regola di trasformazione:
**Tabella di origine (formato Oracle GUID)**
T\$1 COL2
```
06F6949D234911EE80670242AC120002
1A2B3C4D5E6F11EE80670242AC120003
F5E4D3C2B1A011EE80670242AC120004
```
**Tabella di destinazione (formato PostgreSQL UUID)**
COL2T\$1 \$1TMP
```
06f6949d-2349-11ee-8067-0242ac120002
1a2b3c4d-5e6f-11ee-8067-0242ac120003
f5e4d3c2-b1a0-11ee-8067-0242ac120004
```
```
{
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-action": "add-column",
"rule-target": "column",
"object-locator": {
"schema-name": "SPORTS",
"table-name": "TEST_TBL_2"
},
"value": "t_col2_tmp",
"expression": "CASE LOWER(SUBSTR(HEX($T_COL2), 1, 8) || '-' || SUBSTR(HEX($T_COL2), 9, 4) || '-' || SUBSTR(HEX($T_COL2), 13, 4) || '-' || SUBSTR(HEX($T_COL2), 17, 4) || '-' || SUBSTR(HEX($T_COL2), 21, 12)) WHEN '----' THEN NULL ELSE LOWER(SUBSTR(HEX($T_COL2), 1, 8) || '-' || SUBSTR(HEX($T_COL2), 9, 4) || '-' || SUBSTR(HEX($T_COL2), 13, 4) || '-' || SUBSTR(HEX($T_COL2), 17, 4) || '-' || SUBSTR(HEX($T_COL2), 21, 12)) END",
"data-type": {
"type": "string",
"length": 60
}
}
```
**Example di aggiunta di una nuova colonna di data alla tabella di destinazione**
Nell'esempio seguente viene aggiunta la nuova colonna di data `createdate` alla tabella di destinazione `employee`. Quando si utilizza la funzione SQLite date`datetime`, la data viene aggiunta alla tabella appena creata per ogni riga inserita.
```
{
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-action": "add-column",
"rule-target": "column",
"object-locator": {
"schema-name": "public",
"table-name": "employee"
},
"value": "createdate",
"expression": "datetime ()",
"data-type": {
"type": "datetime",
"precision": 6
}
}
```
**Example di aggiunta di una nuova colonna numerica alla tabella di destinazione**
Nell'esempio seguente viene aggiunta la nuova colonna numerica `rounded_emp_salary` alla tabella di destinazione `employee`. Utilizza la SQLite `round` funzione per aggiungere lo stipendio arrotondato.
```
{
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-action": "add-column",
"rule-target": "column",
"object-locator": {
"schema-name": "public",
"table-name": "employee"
},
"value": "rounded_emp_salary",
"expression": "round($emp_salary)",
"data-type": {
"type": "int8"
}
}
```
**Example di aggiunta di una nuova colonna di stringhe alla tabella di destinazione utilizzando la funzione hash**
Nell'esempio seguente viene aggiunta la nuova colonna di stringhe `hashed_emp_number` alla tabella di destinazione `employee`. La SQLite `hash_sha256(x)` funzione crea valori con hash sulla destinazione per la colonna di origine,`emp_number`.
```
{
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-action": "add-column",
"rule-target": "column",
"object-locator": {
"schema-name": "public",
"table-name": "employee"
},
"value": "hashed_emp_number",
"expression": "hash_sha256($emp_number)",
"data-type": {
"type": "string",
"length": 64
}
}
```
## Aggiunta di metadati a una tabella di destinazione utilizzando espressioni
È possibile aggiungere le informazioni sui metadati alla tabella di destinazione utilizzando le espressioni seguenti:
+ `$AR_M_SOURCE_SCHEMA`: il nome dello schema di origine.
+ `$AR_M_SOURCE_TABLE_NAME`: il nome della tabella di origine.
+ `$AR_M_SOURCE_COLUMN_NAME`: il nome di una colonna nella tabella di origine.
+ `$AR_M_SOURCE_COLUMN_DATATYPE`: il tipo di dati di una colonna nella tabella di origine.
**Example di aggiunta di una colonna per il nome dello schema utilizzando il nome dello schema dell'origine**
Nell'esempio seguente viene aggiunta una nuova colonna denominata `schema_name` alla destinazione utilizzando il nome dello schema dell'origine.
```
{
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-action": "add-column",
"rule-target": "column",
"object-locator": {
"schema-name": "%",
"table-name": "%"
},
"rule-action": "add-column",
"value":"schema_name",
"expression": "$AR_M_SOURCE_SCHEMA",
"data-type": {
"type": "string",
"length": 50
}
}
```
# 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"
}
}
]
}
```
# Utilizzo del mascheramento dei dati per nascondere informazioni sensibili
Per nascondere i dati sensibili archiviati in una o più colonne delle tabelle oggetto di migrazione, puoi sfruttare le azioni delle regole di trasformazione di Data Masking. A partire dalla versione 3.5.4, AWS DMS consente l'uso delle azioni delle regole di trasformazione di mascheramento dei dati nella mappatura delle tabelle, consentendo di modificare il contenuto di una o più colonne durante il processo di migrazione. AWS DMS carica i dati modificati nelle tabelle di destinazione.
AWS Database Migration Service offre tre opzioni per le azioni delle regole di trasformazione di mascheramento dei dati:
+ Mascheramento dei dati: maschera con cifre
+ Mascheramento dei dati: le cifre vengono randomizzate
+ Mascheramento dei dati: Hashing Mask
Queste azioni delle regole di trasformazione di mascheramento dei dati possono essere configurate nella mappatura delle tabelle dell'attività di replica, in modo simile ad altre regole di trasformazione. L'obiettivo della regola deve essere impostato a livello di colonna.
## Mascherare i numeri nei dati della colonna con un carattere di mascheramento
L'azione della regola di trasformazione «Mascheratura dei dati: maschera delle cifre» consente di mascherare i dati numerici in una o più colonne sostituendo le cifre con un singolo carattere stampabile ASCII specificato dall'utente (esclusi i caratteri vuoti o gli spazi bianchi).
Ecco un esempio che maschera tutte le cifre nella `cust_passport_no` colonna della `customer_master` tabella con il carattere `'#'` di mascheramento e carica i dati mascherati nella tabella di destinazione:
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "cust_schema",
"table-name": "%"
},
"rule-action": "include"
},
{
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-target": "column",
"object-locator": {
"schema-name": "cust_schema",
"table-name": "customer_master",
"column-name": "cust_passport_no"
},
"rule-action": "data-masking-digits-mask",
"value": "#"
}
]
}
```
Ad esempio, se la colonna `cust_passport_no` nella tabella di origine contiene il record «C6 BGJ566669 K», l' AWS DMS attività scriverà questi dati nella tabella di destinazione come. `"C#BGJ######K"`
## Sostituzione dei numeri nella colonna con numeri casuali
La regola di trasformazione «Data Masking: Digits Randomize» consente di sostituire ogni cifra numerica in una o più colonne con un numero casuale. Nell'esempio seguente, AWS DMS sostituisce ogni cifra nella `cust_passport_no` colonna della tabella di origine `customer_master` con un numero casuale e scrive i dati modificati nella tabella di destinazione:
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "cust_schema",
"table-name": "%"
},
"rule-action": "include"
},
{
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-target": "column",
"object-locator": {
"schema-name": "cust_schema",
"table-name": "customer_master",
"column-name": "cust_passport_no"
},
"rule-action": "data-masking-digits-randomize"
}
]
}
```
Ad esempio, l' AWS DMS attività trasformerà il valore `"C6BGJ566669K"` nella `cust_passport_no` colonna della tabella di origine `"C1BGJ842170K"` e lo scriverà nel database di destinazione.
## Sostituzione dei dati della colonna con un valore hash
La regola di trasformazione «Data Masking: Hashing Mask» consente di sostituire i dati della colonna con un hash generato utilizzando l'algoritmo. `SHA256` La lunghezza dell'hash sarà sempre di 64 caratteri, quindi la lunghezza della colonna della tabella di destinazione deve essere almeno di 64 caratteri. In alternativa, puoi aggiungere un'azione della regola di `change-data-type` trasformazione alla colonna per aumentare la larghezza della colonna nella tabella di destinazione.
L'esempio seguente genera un valore hash lungo 64 caratteri per i dati nella `cust_passport_no` colonna della tabella di origine `customer_master` e carica i dati trasformati nella tabella di destinazione dopo aver aumentato la lunghezza della colonna:
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "cust_schema",
"table-name": "%"
},
"rule-action": "include"
},
{
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-target": "column",
"object-locator": {
"schema-name": "cust_schema",
"table-name": "customer_master",
"column-name": "cust_passport_no"
},
"rule-action": "change-data-type",
"data-type": {
"type": "string",
"length": "100",
"scale": ""
}
},
{
"rule-type": "transformation",
"rule-id": "3",
"rule-name": "3",
"rule-target": "column",
"object-locator": {
"schema-name": "cust_schema",
"table-name": "customer_master",
"column-name": "cust_passport_no"
},
"rule-action": "data-masking-hash-mask"
}
]
}
```
Ad esempio, se la colonna `cust_passport_no` della tabella di origine contiene un valore`“C6BGJ566669K”`, AWS DMS task scriverà un hash nella tabella `“7CB06784764C9030CCC41E25C15339FEB293FFE9B329A72B5FED564E99900C75”` di destinazione.
## Limitazioni
+ Ogni opzione della regola di trasformazione Data Masking è supportata solo per tipi di AWS DMS dati specifici:
+ Data Masking: Digits Mask è supportato per colonne di tipi di dati: and. `WSTRING` `STRING`
+ Mascheramento dei dati: Digits Randomize è supportato per colonne di tipi di dati: con controparti non firmate. `WSTRING, STRING; NUMERIC, INT1, INT2, INT4, and INT8 `
+ Data Masking: Hashing Mask è supportato per colonne di tipi di dati: and. `WSTRING` `STRING`
Per ulteriori informazioni sulla mappatura dei tipi di AWS DMS dati ai tipi di dati del motore di origine, consulta la mappatura dei tipi di dati del motore di origine con i tipi di dati. AWS DMS Vedi i tipi di dati di origine per[Tipi di dati di origine per Oracle](CHAP_Source.Oracle.md#CHAP_Source.Oracle.DataTypes), [Tipi di dati di origine per SQL Server](CHAP_Source.SQLServer.md#CHAP_Source.SQLServer.DataTypes)[Tipi di dati di origine per PostgreSQL](CHAP_Source.PostgreSQL.md#CHAP_Source-PostgreSQL-DataTypes), e. [Tipi di dati di origine per MySQL](CHAP_Source.MySQL.md#CHAP_Source.MySQL.DataTypes)
+ L'utilizzo di un'azione della regola di mascheramento dei dati per una colonna con un tipo di dati incompatibile causerà un errore nell'attività DMS. Fate riferimento alle impostazioni DataMaskingErrorPolicy dell'attività DMS per specificare il comportamento di gestione degli errori. Per ulteriori informazioni su `DataMaskingErrorPolicy`, consultare [Impostazioni delle attività per la gestione degli errori](CHAP_Tasks.CustomizingTasks.TaskSettings.ErrorHandling.md).
+ È possibile aggiungere un'azione della regola di change-data-type trasformazione per modificare il tipo di dati della colonna in un tipo compatibile se il tipo di colonna di origine non è supportato per l'opzione di mascheramento che si intende utilizzare. Il valore `rule-id` della `change-data-type` trasformazione deve essere un numero inferiore rispetto all'ID della trasformazione di mascheramento in modo che la modifica del tipo di dati avvenga prima del mascheramento.
+ Usa l'azione Data Masking: Hashing Mask per mascherare le colonne Chiave primaria/Chiave unica/Chiave esterna, poiché il valore hash generato sarà unico e coerente. Le altre due opzioni di mascheramento non possono garantire l'unicità.
+ Mentre Data Masking: Digits Mask e Data Masking: Digits Randomize influiscono solo sulle cifre nei dati della colonna e non sulla lunghezza dei dati, Data Masking: Hashing Mask modifica l'intera colonna, la lunghezza dei dati passa a 64 caratteri. Pertanto, è necessario aggiungere la tabella di destinazione da creare di conseguenza o una regola di change-data-type trasformazione per la colonna che viene mascherata.
+ Le colonne per le quali è specificata l'azione della regola di trasformazione Data Masking sono escluse dalla convalida dei dati in. AWS DMS Se le colonne Chiave primaria/chiave unica sono mascherate, la convalida dei dati non verrà eseguita per questa tabella; lo stato di convalida di tale tabella sarà uguale a. `No Primary key`