Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Regole di trasformazione nella conversione dello schema DMS
*Le regole di trasformazione* consentono di personalizzare il modo in cui DMS Schema Conversion converte gli oggetti del database, sostituendo la denominazione predefinita e le mappature dei tipi di dati. È possibile applicare queste regole a database, schemi, tabelle, viste, colonne, valori restituiti dalle funzioni, parametri di routine e variabili locali.
Supponi, ad esempio, di avere una serie di tabelle nello schema di origine denominato `test_TABLE_NAME`. Puoi impostare una regola che modifichi il prefisso `test_` con il prefisso `demo_` nello schema di destinazione.
Puoi creare regole di trasformazione in grado di eseguire le seguenti attività:
+ Aggiunta, rimozione o sostituzione di un prefisso
+ Aggiunta, rimozione o sostituzione di un suffisso
+ Modificare il tipo di dati di una colonna, il valore restituito dalla funzione, il parametro di routine o la variabile locale
+ Converte il nome dell'oggetto in minuscolo o maiuscolo
+ Rinominare un oggetto
## Creazione delle regole di trasformazione
La conversione dello schema DMS memorizza le regole di trasformazione come parte del progetto di migrazione. Per definire le regole di trasformazione, passale come stringa JSON che contiene un oggetto con un `rules` array quando crei o modifichi un progetto di migrazione. Ogni elemento dell'array rappresenta un oggetto regola separato. Un progetto di migrazione supporta fino a 512 regole di trasformazione (massimo 128 KB).
La struttura dell'array con regole di trasformazione è la seguente:
```
{
"rules": [
{
{{Rule object 1}}
},
{
{{Rule object 2}}
},
...
{
{{Rule object N}}
}
]
}
```
Puoi aggiungere più regole di trasformazione nel progetto. La conversione dello schema DMS applica le regole di trasformazione durante la conversione nello stesso ordine in cui le hai aggiunte.
Se più regole hanno come target lo stesso oggetto, il comportamento dipende dal tipo di azione. Le regole con tipi di azione diversi hanno tutte effetto. Ad esempio, si applicano sia una `add-suffix` regola che una regola. `add-prefix` Le regole con lo stesso tipo di azione si sovrascrivono a vicenda e solo l'ultima ha effetto.
Per creare regole di trasformazione, utilizzate uno dei seguenti metodi.
------
#### [ AWS Management Console ]
**Per creare regole di trasformazione utilizzando la console**
1. Nella pagina **Crea un progetto di migrazione** scegli **Aggiungi regola di trasformazione**. Per ulteriori informazioni, consulta [ Creazione di progetti di migrazione](migration-projects-create.md).
1. Per **Rule target**, scegli il tipo di oggetti di database a cui si applica questa regola. La procedura guidata della console supporta `schema``table`, e `column` destinazioni. Per utilizzare altre destinazioni come `database` o`view`, usa l'editor JSON nella console o la AWS CLI.
1. Per **Schema di origine** scegli **Inserisci uno schema**. Quindi, specifica gli schemi di origine, le tabelle e le colonne a cui si applica questa regola. È possibile utilizzare un nome esatto per selezionare un oggetto oppure utilizzare un modello con il segno di percentuale (%) come jolly per abbinare un numero qualsiasi di caratteri.
1. In **Operazione** scegli l'attività da eseguire.
1. A seconda dell'azione della regola, inserisci valori aggiuntivi:
+ `add-prefix`oppure `add-suffix` — Immettete il testo da aggiungere.
+ `remove-prefix`oppure `remove-suffix` — Inserite il testo da rimuovere.
+ `replace-prefix`o `replace-suffix` — Inserite il testo esistente e il testo sostitutivo.
+ `rename`— Inserite il nuovo nome per l'oggetto.
+ `convert-uppercase`o `convert-lowercase` — Non sono richiesti valori aggiuntivi.
+ `change-data-type`— Immettere il nome del tipo di dati di destinazione e, facoltativamente, la precisione, la scala o la lunghezza.
1. Scegli **Aggiungi regola di trasformazione** per aggiungere un'altra regola di trasformazione.
Dopo aver aggiunto le regole, scegli **Crea un progetto di migrazione**.
------
#### [ AWS CLI ]
Per aggiungere regole di trasformazione utilizzando la AWS CLI, utilizzate il `--transformation-rules` parametro con uno dei seguenti comandi:
+ [create-migration-project — Quando si crea un nuovo progetto](https://docs.aws.amazon.com/cli/latest/reference/dms/create-migration-project.html) di migrazione.
+ [modify-migration-project — Per un progetto di migrazione esistente](https://docs.aws.amazon.com/cli/latest/reference/dms/modify-migration-project.html).
L'esempio seguente aggiunge regole di trasformazione a un progetto di migrazione esistente:
```
aws dms modify-migration-project \
--migration-project-identifier {{migration_project_arn}} \
--transformation-rules '{{json_rules}}'
```
Per eseguire questo comando in una regione AWS specifica, aggiungi il `--region` parametro, ad esempio`--region us-west-2`.
------
Per modificare, duplicare o rimuovere le regole di trasformazione esistenti, consulta[Modifica delle regole di trasformazione](#sc-transformation-rules-edit).
## Recupero delle regole di trasformazione
È possibile recuperare le regole di trasformazione da un progetto di migrazione DMS Schema Conversion esistente utilizzando la console di AWS gestione o la AWS CLI.
------
#### [ AWS Management Console ]
Per visualizzare le regole di trasformazione utilizzando la console di AWS gestione, scegli **Modifica** su un progetto di migrazione esistente e consulta l'elenco delle regole esistenti nella sezione Regole di **trasformazione**.
------
#### [ AWS CLI ]
Per recuperare le regole di trasformazione da un progetto di migrazione DMS Schema Conversion esistente, utilizzate il comando [describe-migration-projects](https://docs.aws.amazon.com/cli/latest/reference/dms/describe-migration-projects.html). La risposta utilizza il formato JSON e include le regole di trasformazione associate al progetto.
Il seguente esempio di AWS CLI recupera le regole di trasformazione da un progetto di migrazione:
```
aws dms describe-migration-projects \
--filters Name=migration-project-identifier,Values={{migration_project_arn}}
```
------
## Modifica delle regole di trasformazione
Per modificare, aggiungere o rimuovere le regole di trasformazione nel progetto di migrazione, utilizzate uno dei seguenti metodi.
------
#### [ AWS Management Console ]
**Per modificare le regole di trasformazione**
1. Scegli **Progetti di migrazione**, quindi seleziona il tuo progetto di migrazione.
1. Scegli **Modifica** per modificare le impostazioni del progetto di migrazione.
1. Per **Regole di trasformazione** scegli una delle seguenti azioni:
+ Scegli **Aggiungi regola di trasformazione** per aggiungere una nuova regola di trasformazione.
+ Scegli **Duplica per duplicare** una regola di trasformazione esistente e aggiungerla alla fine dell'elenco.
+ Scegli **Rimuovi** per rimuovere una regola di trasformazione esistente.
+ Scegli la regola di trasformazione esistente per modificarla.
1. Dopo aver terminato la modifica delle regole, seleziona **Salva modifiche**.
------
#### [ AWS CLI ]
Per aggiornare le regole di trasformazione utilizzando la AWS CLI, utilizzate il comando [modify-migration-project](https://docs.aws.amazon.com/cli/latest/reference/dms/modify-migration-project.html) con il parametro. `--transformation-rules` Passa il set completo di regole aggiornato come stringa JSON.
```
aws dms modify-migration-project \
--migration-project-identifier {{migration_project_arn}} \
--transformation-rules '{{json_rules}}'
```
------
## Formato delle regole di trasformazione
Una regola di trasformazione utilizza i campi degli oggetti JSON per definire come convertire un oggetto di origine nel suo equivalente di destinazione. Ogni tipo di regola utilizza un set specifico di campi. Includi solo i campi relativi all'attività.
Il seguente oggetto JSON descrive una regola di trasformazione di DMS Schema Conversion:
```
{
"rule-type": "transformation",
"rule-id": {{rule_id}},
"rule-name": "{{rule_name}}",
"rule-action": "{{rule_action}}",
"rule-target": "{{rule_target}}",
"object-locator": {
[ "database-name": "{{database_name}}", ]
[ "schema-name": "{{schema_name}}", ]
[ "table-name": "{{table_name}}", ]
[ "column-name": "{{column_name}}", ]
[ "parent": "{{parent_name}}", ]
[ "function-name": "{{function_name}}", ]
[ "procedure-name": "{{procedure_name}}", ]
[ "parameter-name": "{{parameter_name}}", ]
[ "local-variable-name": "{{local_variable_name}}", ]
[ "type": "{{source_data_type}}", ]
[ "precision": {{source_precision}}, ]
[ "scale": {{source_scale}}, ]
[ "length": {{source_length}} ]
},
[ "value": "{{rule_value}}", ]
[ "old-value": "{{rule_old_value}}", ]
[ "data-type": {
"type": "{{data_type_name}}",
[ "precision": {{data_type_precision}}, ]
[ "scale": {{data_type_scale}}, ]
[ "length": {{data_type_length}} ]
} ]
}
```
La tabella seguente descrive ogni parametro.
| Parametro | Valori possibili | Description |
| --- | --- | --- |
| rule-type | transformation | Un valore che applica la regola a ogni oggetto specificato dall'object locator.
Per tutte le regole di trasformazione, impostalo su. `transformation`
Parametro obbligatorio. |
| rule-id | Un valore numerico (intero). | Un valore numerico univoco per identificare la regola.
Parametro obbligatorio. |
| rule-name | Un valore alfanumerico. | Un nome univoco per identificare la regola.
Parametro obbligatorio. |
| rule-action | add-prefix, remove-prefix, replace-prefix, add-suffix, remove-suffix, replace-suffix, convert-uppercase, convert-lowercase, rename, change-data-type | La trasformazione che desideri applicare all'oggetto. Tutte le operazioni delle regole di trasformazione prevedono una distinzione tra lettere maiuscole e minuscole.
Operazioni con prefisso:[See the AWS documentation website for more details](http://docs.aws.amazon.com/it_it/dms/latest/userguide/sc-transformation-rules.html)
Operazioni sui suffissi:[See the AWS documentation website for more details](http://docs.aws.amazon.com/it_it/dms/latest/userguide/sc-transformation-rules.html)
Conversione dei casi:[See the AWS documentation website for more details](http://docs.aws.amazon.com/it_it/dms/latest/userguide/sc-transformation-rules.html)
Modifica diretta:[See the AWS documentation website for more details](http://docs.aws.amazon.com/it_it/dms/latest/userguide/sc-transformation-rules.html)
Ambito: le operazioni di prefisso, suffisso, ridenominazione e conversione dei casi possono essere applicate a schemi, tabelle e colonne.
L'`change-data-type`operazione si applica solo alle colonne, ai valori restituiti dalle funzioni, ai parametri di routine e alle variabili locali.
Parametro obbligatorio. |
| rule-target | database, schema, table, view, column, function result, routine parameter, local variable | Il tipo di oggetto a cui verrà applicata la regola.[See the AWS documentation website for more details](http://docs.aws.amazon.com/it_it/dms/latest/userguide/sc-transformation-rules.html)
Parametro obbligatorio. |
| object-locator | Un oggetto JSON. | Un oggetto che identifica gli oggetti del database di origine a cui si applica la regola. È possibile utilizzare il segno di percentuale (`%`) come carattere jolly per tutto o parte del valore in ogni campo dell'`object-locator`oggetto.
L'oggetto contiene i seguenti campi di stringa:[See the AWS documentation website for more details](http://docs.aws.amazon.com/it_it/dms/latest/userguide/sc-transformation-rules.html)
Tutti i nomi degli oggetti, ad esempio i nomi di tabelle o colonne, nelle regole di trasformazione fanno distinzione tra maiuscole e minuscole.
Le sezioni seguenti descrivono ogni campo dell'oggetto.
Parametro obbligatorio. |
| object-locator \| database-name | Un valore alfanumerico che segue le regole di denominazione per il database di origine. | Il nome del database di origine.
Applicabile ai fornitori di database in cui l'architettura del database proviene dal database come contenitore di oggetti di primo livello. Ad esempio: Microsoft SQL Server, SAP ASE.
Campo oggetto JSON opzionale. |
| object-locator \| schema-name | Un valore alfanumerico che segue le regole di denominazione per il database di origine. | Il nome dello schema del database di origine.
Campo oggetto JSON opzionale. |
| object-locator \| table-name | Un valore alfanumerico che segue le regole di denominazione per il database di origine. | Il nome della tabella del database di origine.
Campo oggetto JSON opzionale. |
| object-locator \| column-name | Un valore alfanumerico che segue le regole di denominazione per il database di origine. | Il nome della colonna della tabella del database di origine.
Campo oggetto JSON opzionale. |
| object-locator \| parent | Un valore alfanumerico che segue le regole di denominazione per il database di origine. | Il nome dell'oggetto del database di origine che è il padre dell'oggetto specificato, ad esempio per o. `function-name` `procedure-name`
Nei database di alcuni fornitori, l'oggetto a cui viene applicata la regola può essere subordinato e richiedere di specificare il relativo elemento principale.
Ad esempio, le funzioni pacchettizzate in Oracle, dove l'elemento principale è il nome del pacchetto.
Campo oggetto JSON opzionale. |
| object-locator \| function-name | Un valore alfanumerico che segue le regole di denominazione per il database di origine. | Il nome della funzione del database di origine.
Campo oggetto JSON opzionale. |
| object-locator \| procedure-name | Un valore alfanumerico che segue le regole di denominazione per il database di origine. | Il nome della procedura del database di origine.
Campo oggetto JSON opzionale. |
| object-locator \| parameter-name | Un valore alfanumerico che segue le regole di denominazione per il database di origine. | Il nome della funzione o del parametro della procedura del database di origine.
Campo oggetto JSON opzionale. |
| object-locator \| local-variable-name | Un valore alfanumerico che segue le regole di denominazione per il database di origine. | Il nome di una variabile locale all'interno della funzione o della procedura del database di origine.
Campo oggetto JSON opzionale. |
| object-locator \| type | Un valore alfanumerico. | Il nome del tipo di dati di origine da abbinare. Utilizzate questo campo per applicare la regola solo agli oggetti con un tipo di dati specifico.
Campo oggetto JSON opzionale. |
| object-locator \| precision | Un valore numerico (intero). | La precisione del tipo di dati di origine da abbinare.
Campo oggetto JSON opzionale. |
| object-locator \| scale | Un valore numerico (intero). | La scala del tipo di dati di origine da abbinare.
Campo oggetto JSON opzionale. |
| object-locator \| length | Un valore numerico (intero). | La lunghezza del tipo di dati di origine da abbinare.
Campo oggetto JSON opzionale. |
| value | Un valore alfanumerico che segue le regole di denominazione per il database di destinazione. | Il valore di testo utilizzato dall'azione di trasformazione. Per `add-prefix` e`add-suffix`, specifica il testo da aggiungere. Per `remove-prefix` and`remove-suffix`, specifica il testo da rimuovere. Per `replace-prefix` e`replace-suffix`, specifica il testo sostitutivo. Per`rename`, specifica il nuovo nome.
Obbligatorio per tutte le azioni tranne `convert-uppercase``convert-lowercase`, e`change-data-type`. |
| old-value | Un valore alfanumerico che segue le regole di denominazione per il database di origine. | Il valore esistente da trovare e sostituire nel nome dell'oggetto. Necessario per azioni come `replace-prefix` e`replace-suffix`.
Parametro opzionale. |
| data-type | Un oggetto JSON. | Un oggetto che descrive le proprietà del tipo di dati sostitutivo quando è`rule-action`. `change-data-type`
L'oggetto include i seguenti campi:[See the AWS documentation website for more details](http://docs.aws.amazon.com/it_it/dms/latest/userguide/sc-transformation-rules.html)
Le seguenti sezioni descrivono ogni campo dell'oggetto.
Parametro opzionale. |
| data-type \| type | Un valore alfanumerico. | Il nome del tipo di dati sostitutivo per la colonna del database di destinazione, se `rule-action` è`change-data-type`. Deve essere un tipo di dati del database di destinazione valido.
Campo oggetto JSON obbligatorio. |
| data-type \| precision | Un valore numerico (intero). | La precisione del tipo di dati sostitutivo per il database di destinazione, se è`rule-action`. `change-data-type`
Campo oggetto JSON opzionale. |
| data-type \| scale | Un valore numerico (intero). | La scala del tipo di dati sostitutivo per il database di destinazione, se è`rule-action`. `change-data-type`
Campo oggetto JSON opzionale. |
| data-type \| length | Un valore numerico (intero). | La lunghezza del tipo di dati sostitutivo per il database di destinazione, se è`rule-action`. `change-data-type`
Campo oggetto JSON opzionale. |
## Esempi di regole di trasformazione
Gli esempi seguenti mostrano il valore JSON del `--transformation-rules` parametro per diversi tipi di regole:
### Aggiunta di un prefisso
L'esempio seguente esegue queste azioni durante la conversione dal database di origine a quello di destinazione:
+ Aggiungi il prefisso `DW_` allo schema. `SALES`
+ Aggiungi il prefisso `FACT_` alla tabella `ORDERS` nello schema. `SALES`
+ Aggiungi il prefisso `OLD_` alla colonna `UNIT_PRICE` nella tabella `PRODUCTS` nello schema. `SALES`
```
{
"rules": [
{
"rule-id": 5,
"rule-type": "transformation",
"rule-name": "add-prefix-schema-sales",
"rule-action": "add-prefix",
"rule-target": "schema",
"object-locator": {
"schema-name": "SALES"
},
"value": "DW_"
},
{
"rule-id": 12,
"rule-type": "transformation",
"rule-name": "add-prefix-table-orders",
"rule-action": "add-prefix",
"rule-target": "table",
"object-locator": {
"schema-name": "SALES",
"table-name": "ORDERS"
},
"value": "FACT_"
},
{
"rule-id": 27,
"rule-type": "transformation",
"rule-name": "add-prefix-column-unit-price",
"rule-action": "add-prefix",
"rule-target": "column",
"object-locator": {
"schema-name": "SALES",
"table-name": "PRODUCTS",
"column-name": "UNIT_PRICE"
},
"value": "OLD_"
}
]
}
```
### Rimuovi un prefisso
L'esempio seguente esegue queste azioni durante la conversione dal database di origine a quello di destinazione:
+ Rimuove il prefisso `SRC_` dallo schema. `SRC_FINANCE`
+ Rimuovi il prefisso `TMP_` dalla tabella `TMP_INVOICES` nello schema. `SRC_FINANCE`
+ Rimuovi il prefisso `PAID_` dalla colonna `PAID_AMOUNT` nella tabella `TMP_PAYMENTS` nello schema. `SRC_FINANCE`
```
{
"rules": [
{
"rule-id": 3,
"rule-type": "transformation",
"rule-name": "remove-prefix-schema-src-finance",
"rule-action": "remove-prefix",
"rule-target": "schema",
"object-locator": {
"schema-name": "SRC_FINANCE"
},
"value": "SRC_"
},
{
"rule-id": 18,
"rule-type": "transformation",
"rule-name": "remove-prefix-table-tmp-invoices",
"rule-action": "remove-prefix",
"rule-target": "table",
"object-locator": {
"schema-name": "SRC_FINANCE",
"table-name": "TMP_INVOICES"
},
"value": "TMP_"
},
{
"rule-id": 41,
"rule-type": "transformation",
"rule-name": "remove-prefix-column-paid-amount",
"rule-action": "remove-prefix",
"rule-target": "column",
"object-locator": {
"schema-name": "SRC_FINANCE",
"table-name": "TMP_PAYMENTS",
"column-name": "PAID_AMOUNT"
},
"value": "PAID_"
}
]
}
```
### Sostituzione di un prefisso
L'esempio seguente esegue queste azioni durante la conversione dal database di origine a quello di destinazione:
+ Sostituisci il prefisso `OLD_` con `NEW_` nello schema. `OLD_INVENTORY`
+ Sostituisci il prefisso `STG_` con `INT_` nella tabella `STG_WAREHOUSES` nello schema. `OLD_INVENTORY`
+ Sostituisci il prefisso `SRC_` con `TGT_` nella colonna `SRC_WAREHOUSE_CODE` nella tabella `STG_WAREHOUSES` nello schema. `OLD_INVENTORY`
```
{
"rules": [
{
"rule-id": 7,
"rule-type": "transformation",
"rule-name": "replace-prefix-schema-old-inventory",
"rule-action": "replace-prefix",
"rule-target": "schema",
"object-locator": {
"schema-name": "OLD_INVENTORY"
},
"value": "NEW_",
"old-value": "OLD_"
},
{
"rule-id": 22,
"rule-type": "transformation",
"rule-name": "replace-prefix-table-stg-warehouses",
"rule-action": "replace-prefix",
"rule-target": "table",
"object-locator": {
"schema-name": "OLD_INVENTORY",
"table-name": "STG_WAREHOUSES"
},
"value": "INT_",
"old-value": "STG_"
},
{
"rule-id": 35,
"rule-type": "transformation",
"rule-name": "replace-prefix-column-src-warehouse-code",
"rule-action": "replace-prefix",
"rule-target": "column",
"object-locator": {
"schema-name": "OLD_INVENTORY",
"table-name": "STG_WAREHOUSES",
"column-name": "SRC_WAREHOUSE_CODE"
},
"value": "TGT_",
"old-value": "SRC_"
}
]
}
```
### Aggiungi un suffisso
L'esempio seguente esegue queste azioni durante la conversione dal database di origine a quello di destinazione:
+ Aggiungi il suffisso `_HIST` allo schema. `HR_ARCHIVE`
+ Aggiungi il suffisso `_HIST` alla tabella `JOB_CHANGES` nello schema. `HR_ARCHIVE`
+ Aggiungi il suffisso `_TS` alla colonna `CREATED_AT` nella tabella `EMPLOYEE_SALARIES` nello schema. `HR_ARCHIVE`
```
{
"rules": [
{
"rule-id": 9,
"rule-type": "transformation",
"rule-name": "add-suffix-schema-hr-archive",
"rule-action": "add-suffix",
"rule-target": "schema",
"object-locator": {
"schema-name": "HR_ARCHIVE"
},
"value": "_HIST"
},
{
"rule-id": 16,
"rule-type": "transformation",
"rule-name": "add-suffix-table-job-changes",
"rule-action": "add-suffix",
"rule-target": "table",
"object-locator": {
"schema-name": "HR_ARCHIVE",
"table-name": "JOB_CHANGES"
},
"value": "_HIST"
},
{
"rule-id": 44,
"rule-type": "transformation",
"rule-name": "add-suffix-column-created-at",
"rule-action": "add-suffix",
"rule-target": "column",
"object-locator": {
"schema-name": "HR_ARCHIVE",
"table-name": "EMPLOYEE_SALARIES",
"column-name": "CREATED_AT"
},
"value": "_TS"
}
]
}
```
### Rimozione di un suffisso
L'esempio seguente esegue queste azioni durante la conversione dal database di origine a quello di destinazione:
+ Rimuove il suffisso `_FILES` dallo schema. `LEGAL_FILES`
+ Rimuovi il suffisso `_V1` dalla tabella `CLAUSES_V1` nello schema. `LEGAL_FILES`
+ Rimuovi il suffisso `_CODE` dalla colonna `COUNTRY_CODE` nella tabella `CONTRACTS_V1` nello schema. `LEGAL_FILES`
```
{
"rules": [
{
"rule-id": 6,
"rule-type": "transformation",
"rule-name": "remove-suffix-schema-legal-files",
"rule-action": "remove-suffix",
"rule-target": "schema",
"object-locator": {
"schema-name": "LEGAL_FILES"
},
"value": "_FILES"
},
{
"rule-id": 14,
"rule-type": "transformation",
"rule-name": "remove-suffix-table-clauses-v1",
"rule-action": "remove-suffix",
"rule-target": "table",
"object-locator": {
"schema-name": "LEGAL_FILES",
"table-name": "CLAUSES_V1"
},
"value": "_V1"
},
{
"rule-id": 31,
"rule-type": "transformation",
"rule-name": "remove-suffix-column-country-code",
"rule-action": "remove-suffix",
"rule-target": "column",
"object-locator": {
"schema-name": "LEGAL_FILES",
"table-name": "CONTRACTS_V1",
"column-name": "COUNTRY_CODE"
},
"value": "_CODE"
}
]
}
```
### Sostituisci un suffisso
L'esempio seguente esegue queste azioni durante la conversione dal database di origine a quello di destinazione:
+ Sostituisci il suffisso `_DEV` con `_PROD` nello schema. `REPORTING_DEV`
+ Sostituisci il suffisso `_RPT` con `_REPORT` nella tabella `MONTHLY_RPT` nello schema. `REPORTING_DEV`
+ Sostituisci il suffisso `_ID` con `_KEY` nella colonna `CUSTOMER_ID` nella tabella `MONTHLY_RPT` nello schema. `REPORTING_DEV`
```
{
"rules": [
{
"rule-id": 8,
"rule-type": "transformation",
"rule-name": "replace-suffix-schema-reporting-dev",
"rule-action": "replace-suffix",
"rule-target": "schema",
"object-locator": {
"schema-name": "REPORTING_DEV"
},
"value": "_PROD",
"old-value": "_DEV"
},
{
"rule-id": 23,
"rule-type": "transformation",
"rule-name": "replace-suffix-table-monthly-rpt",
"rule-action": "replace-suffix",
"rule-target": "table",
"object-locator": {
"schema-name": "REPORTING_DEV",
"table-name": "MONTHLY_RPT"
},
"value": "_REPORT",
"old-value": "_RPT"
},
{
"rule-id": 47,
"rule-type": "transformation",
"rule-name": "replace-suffix-column-customer-id",
"rule-action": "replace-suffix",
"rule-target": "column",
"object-locator": {
"schema-name": "REPORTING_DEV",
"table-name": "MONTHLY_RPT",
"column-name": "CUSTOMER_ID"
},
"value": "_KEY",
"old-value": "_ID"
}
]
}
```
### Conversione in caratteri maiuscoli
L'esempio seguente esegue queste azioni durante la conversione dal database di origine a quello di destinazione:
+ Converte tutti i caratteri nel nome dello schema in lettere `CRM_LEGACY` maiuscole.
+ Converti tutti i caratteri nel nome della tabella nello schema `CUSTOMER_ACCOUNTS` `CRM_LEGACY` in maiuscolo.
+ Converti tutti i caratteri nel nome della colonna `FIRST_NAME` nella tabella nello schema `CUSTOMER_ACCOUNTS` `CRM_LEGACY` in maiuscolo.
```
{
"rules": [
{
"rule-id": 4,
"rule-type": "transformation",
"rule-name": "convert-uppercase-schema-crm-legacy",
"rule-action": "convert-uppercase",
"rule-target": "schema",
"object-locator": {
"schema-name": "CRM_LEGACY"
}
},
{
"rule-id": 19,
"rule-type": "transformation",
"rule-name": "convert-uppercase-table-customer-accounts",
"rule-action": "convert-uppercase",
"rule-target": "table",
"object-locator": {
"schema-name": "CRM_LEGACY",
"table-name": "CUSTOMER_ACCOUNTS"
}
},
{
"rule-id": 36,
"rule-type": "transformation",
"rule-name": "convert-uppercase-column-first-name",
"rule-action": "convert-uppercase",
"rule-target": "column",
"object-locator": {
"schema-name": "CRM_LEGACY",
"table-name": "CUSTOMER_ACCOUNTS",
"column-name": "FIRST_NAME"
}
}
]
}
```
### Conversione in minuscolo
L'esempio seguente esegue queste azioni durante la conversione dal database di origine a quello di destinazione:
+ Converte tutti i caratteri nel nome dello schema `LOGISTICS` in lettere minuscole.
+ Converti tutti i caratteri nel nome della tabella nello schema `SHIPMENT_ORDERS` `LOGISTICS` in lettere minuscole.
+ Converti tutti i caratteri nel nome della colonna nella tabella nello schema `DESTINATION_CITY` `SHIPMENT_ORDERS` `LOGISTICS` in lettere minuscole.
```
{
"rules": [
{
"rule-id": 11,
"rule-type": "transformation",
"rule-name": "convert-lowercase-schema-logistics",
"rule-action": "convert-lowercase",
"rule-target": "schema",
"object-locator": {
"schema-name": "LOGISTICS"
}
},
{
"rule-id": 25,
"rule-type": "transformation",
"rule-name": "convert-lowercase-table-shipment-orders",
"rule-action": "convert-lowercase",
"rule-target": "table",
"object-locator": {
"schema-name": "LOGISTICS",
"table-name": "SHIPMENT_ORDERS"
}
},
{
"rule-id": 52,
"rule-type": "transformation",
"rule-name": "convert-lowercase-column-destination-city",
"rule-action": "convert-lowercase",
"rule-target": "column",
"object-locator": {
"schema-name": "LOGISTICS",
"table-name": "SHIPMENT_ORDERS",
"column-name": "DESTINATION_CITY"
}
}
]
}
```
### Assegnazione di un nuovo nome
L'esempio seguente esegue queste azioni durante la conversione dal database di origine a quello di destinazione:
+ Rinomina lo schema `TEST_SCHEMA` in. `TEST_NEW_SCHEMA`
+ Rinomina la tabella nello schema `REGIONS` `HR` in. `ORG_REGIONS`
+ Rinomina la colonna `CITY` nella tabella nello schema `LOCATIONS` `HR` in. `ORG_CITY_NAME`
```
{
"rules": [
{
"rule-id": 2,
"rule-type": "transformation",
"rule-name": "rename-schema-test-schema",
"rule-action": "rename",
"rule-target": "schema",
"object-locator": {
"schema-name": "TEST_SCHEMA"
},
"value": "TEST_NEW_SCHEMA"
},
{
"rule-id": 15,
"rule-type": "transformation",
"rule-name": "rename-table-hr-regions",
"rule-action": "rename",
"rule-target": "table",
"object-locator": {
"schema-name": "HR",
"table-name": "REGIONS"
},
"value": "ORG_REGIONS"
},
{
"rule-id": 38,
"rule-type": "transformation",
"rule-name": "rename-column-hr-locations-city",
"rule-action": "rename",
"rule-target": "column",
"object-locator": {
"schema-name": "HR",
"table-name": "LOCATIONS",
"column-name": "CITY"
},
"value": "ORG_CITY_NAME"
}
]
}
```
### Change column data type (Modifica tipo di dati della colonna)
L'esempio seguente esegue queste azioni durante la conversione dal database di origine a quello di destinazione:
+ Modifica il tipo di dati della colonna `SALARY` nella tabella `EMPLOYEES` nello schema `PAYROLL` da `NUMBER` a `DECIMAL` con precisione 18 e scala 4.
+ Modifica il tipo di dati della colonna `NOTES` nella tabella `EMPLOYEES` nello schema `PAYROLL` da `VARCHAR2` a `VARCHAR` con lunghezza 350.
+ Modifica il tipo di dati della colonna `HIRE_DATE` nella tabella `EMPLOYEES` nello schema `PAYROLL` da `DATE` a `TIMESTAMP WITH TIME ZONE` con precisione 3.
```
{
"rules": [
{
"rule-id": 10,
"rule-type": "transformation",
"rule-name": "change-datatype-column-salary",
"rule-action": "change-data-type",
"rule-target": "column",
"object-locator": {
"schema-name": "PAYROLL",
"table-name": "EMPLOYEES",
"column-name": "SALARY"
},
"data-type": {
"type": "DECIMAL",
"precision": 18,
"scale": 4
}
},
{
"rule-id": 29,
"rule-type": "transformation",
"rule-name": "change-datatype-column-notes",
"rule-action": "change-data-type",
"rule-target": "column",
"object-locator": {
"schema-name": "PAYROLL",
"table-name": "EMPLOYEES",
"column-name": "NOTES"
},
"data-type": {
"type": "VARCHAR",
"length": 350
}
},
{
"rule-id": 56,
"rule-type": "transformation",
"rule-name": "change-datatype-column-hire-date",
"rule-action": "change-data-type",
"rule-target": "column",
"object-locator": {
"schema-name": "PAYROLL",
"table-name": "EMPLOYEES",
"column-name": "HIRE_DATE"
},
"data-type": {
"type": "TIMESTAMP WITH TIME ZONE",
"precision": 3
}
}
]
}
```
### Modifica il parametro e il tipo di dati variabile
L'esempio seguente esegue queste azioni durante la conversione dal database di origine a quello di destinazione:
+ Modificare il tipo di dati del parametro `P_AMOUNT` nella stored procedure `PROCESS_PAYMENT` nello schema `FINANCE` in`NUMERIC`.
+ Modificare il tipo di dati della variabile `V_TAX_RATE` locale `PROCESS_PAYMENT` nella procedura memorizzata nello schema `FINANCE` `NUMERIC` con precisione 10 e scala 6.
+ Modifica il tipo di dati della variabile locale `V_DESCRIPTION` nella funzione autonoma `CALC_DISCOUNT` nello schema `FINANCE` `CHARACTER` con una lunghezza 150.
```
{
"rules": [
{
"rule-id": 7,
"rule-type": "transformation",
"rule-name": "change-datatype-param-p-amount",
"rule-action": "change-data-type",
"rule-target": "routine parameter",
"object-locator": {
"schema-name": "FINANCE",
"procedure-name": "PROCESS_PAYMENT",
"parameter-name": "P_AMOUNT"
},
"data-type": {
"type": "NUMERIC"
}
},
{
"rule-id": 21,
"rule-type": "transformation",
"rule-name": "change-datatype-localvar-v-tax-rate",
"rule-action": "change-data-type",
"rule-target": "local variable",
"object-locator": {
"schema-name": "FINANCE",
"procedure-name": "PROCESS_PAYMENT",
"local-variable-name": "V_TAX_RATE"
},
"data-type": {
"type": "NUMERIC",
"precision": 10,
"scale": 6
}
},
{
"rule-id": 43,
"rule-type": "transformation",
"rule-name": "change-datatype-localvar-v-description",
"rule-action": "change-data-type",
"rule-target": "local variable",
"object-locator": {
"schema-name": "FINANCE",
"function-name": "CALC_DISCOUNT",
"local-variable-name": "V_DESCRIPTION"
},
"data-type": {
"type": "CHARACTER",
"length": 150
}
}
]
}
```
### Modifica il tipo di dati di restituzione della funzione
L'esempio seguente esegue queste azioni durante la conversione dal database di origine a quello di destinazione:
+ Cambia il tipo di dati restituito dalla funzione autonoma nello schema `GET_PRODUCT_PRICE` `FNG_COMPANY` in. `BIGINT`
+ Cambia il tipo di dati restituiti dalla funzione autonoma nello schema `CALC_DISCOUNTED_PRICE` `FNG_COMPANY` in. `DECIMAL`
+ Cambia il tipo di dati restituito dalla funzione pacchettizzata `CALCULATE_TAX` all'interno del pacchetto nello schema `TAX_UTILS` `FNG_COMPANY` in. `REAL`
```
{
"rules": [
{
"rule-id": 13,
"rule-type": "transformation",
"rule-name": "change-result-type-get-product-price",
"rule-action": "change-data-type",
"rule-target": "function result",
"object-locator": {
"schema-name": "FNG_COMPANY",
"function-name": "GET_PRODUCT_PRICE"
},
"data-type": {
"type": "BIGINT"
}
},
{
"rule-id": 28,
"rule-type": "transformation",
"rule-name": "change-result-calc-discounted-price",
"rule-action": "change-data-type",
"rule-target": "function result",
"object-locator": {
"schema-name": "FNG_COMPANY",
"function-name": "CALC_DISCOUNTED_PRICE"
},
"data-type": {
"type": "DECIMAL"
}
},
{
"rule-id": 61,
"rule-type": "transformation",
"rule-name": "change-result-type-calculate-tax",
"rule-action": "change-data-type",
"rule-target": "function result",
"object-locator": {
"schema-name": "FNG_COMPANY",
"parent": "TAX_UTILS",
"function-name": "CALCULATE_TAX"
},
"data-type": {
"type": "REAL"
}
}
]
}
```
### Schemi con caratteri jolly
L'esempio seguente esegue queste azioni durante la conversione dal database di origine a quello di destinazione:
+ Aggiunge il prefisso `MIGR_` a tutti gli schemi i cui nomi iniziano con. `STG_`
+ Aggiunge il prefisso `MIGR_` a tutte le tabelle in tutti gli schemi i cui nomi iniziano con. `STG_`
+ Aggiungi il suffisso `_NEW` a tutte le colonne i cui nomi iniziano con `SRC_` in tutte le tabelle di tutti gli schemi i cui nomi iniziano con. `STG_`
```
{
"rules": [
{
"rule-id": 8,
"rule-type": "transformation",
"rule-name": "add-prefix-schemas-starting-with-stg",
"rule-action": "add-prefix",
"rule-target": "schema",
"object-locator": {
"schema-name": "STG_%"
},
"value": "MIGR_"
},
{
"rule-id": 33,
"rule-type": "transformation",
"rule-name": "add-prefix-all-tables-in-stg-schemas",
"rule-action": "add-prefix",
"rule-target": "table",
"object-locator": {
"schema-name": "STG_%",
"table-name": "%"
},
"value": "MIGR_"
},
{
"rule-id": 57,
"rule-type": "transformation",
"rule-name": "add-suffix-columns-starting-with-src",
"rule-action": "add-suffix",
"rule-target": "column",
"object-locator": {
"schema-name": "STG_%",
"table-name": "%",
"column-name": "SRC_%"
},
"value": "_NEW"
}
]
}
```