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 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 } } ```