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à.
# Trasformare i dati con AWS Glue trasformazioni gestite
AWS Glue Studio offre due tipi di trasformazioni:
+ **Trasformazioni native di AWS Glue**: gestite da AWS Glue e disponibili per tutti gli utenti.
+ **Trasformazioni visive personalizzate**: consente di caricare le proprie trasformazioni da utilizzare in AWS Glue Studio
## Nodi di trasformazione dei dati gestiti da AWS Glue
AWS Glue Studio offre un set di trasformazioni predefinite che puoi usare per elaborare i dati. I dati passano da un nodo nel diagramma di processo a un altro in una struttura di dati denominata `DynamicFrame`, che è un'estensione di un SQL Apache Spark `DataFrame`.
Nel diagramma precompilato per un processo, tra i nodi di origine dati e di destinazione dati si trova il nodo di trasformazione **Modifica schema**. È·possibile configurare questo nodo di trasformazione per modificare i dati oppure utilizzare ulteriori trasformazioni.
Le seguenti trasformazioni predefinite sono disponibili con AWS Glue Studio:
+ **[ChangeSchema](transforms-configure-applymapping.md)**: mappa le chiavi di proprietà dei dati nell'origine dati alle chiavi di proprietà dei dati nella destinazione dati. È possibile rinominare le chiavi, modificare i tipi di dati per le chiavi e scegliere le chiavi da eliminare dal set di dati.
+ **[SelectFields](transforms-configure-select-fields.md)**: Scegli le chiavi di proprietà dei dati che desideri conservare.
+ **[DropFields](transforms-configure-drop-fields.md)**: Scegli le chiavi di proprietà dei dati che desideri eliminare.
+ **[RenameField](transforms-configure-rename-field.md)**: Rinomina una singola chiave di proprietà dei dati.
+ **[Spigot](transforms-configure-spigot.md)**: scrivi esempi dei dati in un bucket Amazon S3.
+ **[Join](transforms-configure-join.md)**: esegui il join di due set di dati in un set di dati utilizzando una frase di confronto sulle chiavi di proprietà dei dati specificate. È possibile utilizzare inner, outer, left, right, left semi e left anti join.
+ **[Union](transforms-configure-union.md)**: combina righe provenienti da più di un'origine dati che hanno lo stesso schema.
+ **[SplitFields](transforms-configure-split-fields.md)**: divide le chiavi delle proprietà dei dati in due`DynamicFrames`. Output è una raccolta di `DynamicFrames`: uno con le chiavi di proprietà dei dati selezionate e uno con le chiavi di proprietà dei dati rimanenti.
+ **[SelectFromCollection](transforms-selectfromcollection-overview.md)**: Scegline una `DynamicFrame` da una raccolta di`DynamicFrames`. L'output è il `DynamicFrame` selezionato.
+ **[FillMissingValues](transforms-configure-fmv.md)**: individua i record nel set di dati che contengono valori mancanti e aggiungi un nuovo campo con un valore suggerito determinato mediante imputazione
+ **[Filter](transforms-filter.md)**: divide un set di dati in due, in base a una condizione di filtro.
+ **[DropNullFields](transforms-dropnull-fields.md)**: rimuove le colonne dal set di dati se tutti i valori nella colonna sono "null".
+ ** [Elimina i duplicati](transforms-drop-duplicates.md)**: rimuove le righe dall'origine dati consentendo di scegliere se abbinare righe intere o specificare le chiavi.
+ **[SQL](transforms-sql.md)**: inserisce il codice SparkSQL in un campo di inserimento testo per utilizzare una query SQL e trasformare i dati. L'output è un singolo `DynamicFrame`.
+ **[Aggregate](transforms-aggregate-fields.md)**: esegue un calcolo (ad esempio media, somma, min, max) su campi e righe selezionati e crea un nuovo campo con i valori appena calcolati.
+ **[Flatten](transforms-flatten.md)**: estrae i campi all'interno delle strutture in campi di primo livello.
+ **[UUID](transforms-uuid.md)**: aggiunge una colonna con un identificatore univoco universale per ogni riga.
+ **[Identifier](transforms-identifier.md)**: aggiunge una colonna con un identificatore numerico per ogni riga.
+ **[To timestamp](transforms-to-timestamp.md)**: converte una colonna in un tipo di timestamp.
+ **[Format timestamp](transforms-format-timestamp.md)**: converte una colonna di timestamp in una stringa formattata.
+ **[Conditional Router transform](transforms-conditional-router.md)**: applica più condizioni ai dati in ingresso. Ogni riga dei dati in ingresso viene valutata in base a una condizione di filtro di gruppo ed elaborata nel gruppo corrispondente.
+ **[Trasformazione Concatena colonne](transforms-concatenate-columns.md)**: crea una nuova colonna di stringhe utilizzando i valori di altre colonne con un distanziatore opzionale.
+ **[Trasformazione Dividi stringa](transforms-split-string.md)**: suddividi una stringa in un array di token utilizzando un'espressione regolare per definire come viene eseguita la suddivisione.
+ **[Trasformazione Array a colonne](transforms-array-to-columns.md)**: estrai alcuni o tutti gli elementi di una colonna di tipo array in nuove colonne.
+ **[Trasformazione Aggiungi timestamp corrente](transforms-add-current-timestamp.md)**: contrassegna le righe con l'ora in cui i dati sono stati elaborati. Ciò è utile per scopi di controllo o per tenere traccia della latenza nella pipeline di dati.
+ **[Trasformazione Pivot: righe a colonne](transforms-pivot-rows-to-columns.md)**: aggrega una colonna numerica ruotando valori univoci su colonne selezionate che diventano nuove colonne. Se sono selezionate più colonne, i valori vengono concatenati per denominare le nuove colonne.
+ **[Trasformazione Elimina pivot: righe a colonne](transforms-unpivot-columns-to-rows.md)**: converti le colonne in valori di nuove colonne generando una riga per ogni valore univoco.
+ **[Trasformazione Bilancia automaticamente elaborazione](transforms-autobalance-processing.md)**: ridistribuisci i dati tra i worker per migliorare le prestazioni. Ciò è utile nei casi in cui i dati non sono bilanciati o, poiché provengono dall'origine, non consentono un'elaborazione parallela sufficiente.
+ **[Trasformazione Colonna derivata](transforms-derived-column.md)**: definisci una nuova colonna basata su una formula matematica o un'espressione SQL in cui è possibile utilizzare altre colonne nei dati, oltre a costanti e valori letterali.
+ **[Trasformazione Ricerca](transforms-lookup.md)**: aggiungi colonne da una tabella di catalogo definita quando le chiavi corrispondono alle colonne di ricerca definite nei dati.
+ **[Trasformazione Espandi array o mappa](transforms-explode-array.md)**: estrae i valori da una struttura annidata in singole righe più facili da manipolare.
+ **[Trasformazione Corrispondenza dei record](transforms-record-matching.md)**: richiama una trasformazione di classificazione dei dati di machine learning Corrispondenza dei record esistente.
+ **[Trasformazione Rimuovi righe nulle](transforms-remove-null-rows.md)**: rimuove dal set di dati le righe che hanno tutte le colonne come nulle o vuote.
+ **[Trasformazione Analizza colonna JSON](transforms-parse-json-column.md)**: analizza una colonna di stringhe contenente dati JSON e convertila in una struttura o in una colonna di array, a seconda che il JSON sia rispettivamente un oggetto o un array.
+ **[Trasformazione Estrai percorso JSON](transforms-extract-json-path.md)**: estrai nuove colonne da una colonna di stringhe JSON.
+ **[Trasformazione Estrai frammenti di stringa con un'espressione regolare](transforms-regex-extractor.md)**: estrai frammenti di stringa utilizzando un'espressione regolare e crea a partire da essa una nuova colonna o anche più colonne, se si utilizzano gruppi di espressioni regolari.
+ **[Custom transform](transforms-custom.md)**: inserisce il codice in un campo di inserimento testo per utilizzare le trasformazioni personalizzate. L'output è una raccolta di `DynamicFrames`.
# Utilizzo di una ricetta di preparazione dei dati in AWS Glue Studio
La trasformazione della **Ricetta di preparazione dei dati** consente di creare una ricetta di preparazione dei dati da zero utilizzando un'interfaccia di creazione interattiva in stile griglia. Consente inoltre di importare una ricetta AWS Glue DataBrew esistente e quindi modificarla in AWS Glue Studio.
Il nodo **Ricetta di preparazione dei dati** è disponibile nel pannello Risorse. È possibile connettere il nodo **Ricetta di preparazione dei dati** a un altro nodo del flusso di processo visivo, che si tratti di un nodo Origine dati o di un altro nodo di trasformazione. Dopo aver scelto una AWS Glue DataBrew ricetta e una versione, i passaggi applicati nella ricetta sono visibili nella scheda delle proprietà del nodo.
## Prerequisiti
+ Se si importa una AWS Glue DataBrew ricetta, si dispone delle autorizzazioni IAM richieste, come descritto in. [Importa una AWS Glue DataBrew ricetta in AWS Glue Studio](glue-studio-data-preparation-import-recipe.md)
+ È necessario creare una sessione di anteprima dei dati.
## Limitazioni
+ AWS Glue DataBrew le ricette sono supportate solo nelle regioni [commerciali DataBrew ](https://docs.aws.amazon.com/general/latest/gr/databrew.html).
+ Non tutte le AWS Glue DataBrew ricette sono supportate daAWS Glue. Alcune ricette non potranno essere eseguite in AWS Glue Studio.
+ Le ricette con trasformazioni `UNION` e `JOIN` non sono supportate, tuttavia AWS Glue Studio dispone già di nodi di trasformazione "Join" e "Union" che possono essere utilizzati prima o dopo un nodo **Ricetta di preparazione dei dati**.
+ I nodi **Ricetta di preparazione dei dati** sono supportati per i processi a partire da AWS Glue versione 4.0. Questa versione verrà selezionata automaticamente dopo l'aggiunta di un nodo **Ricetta di preparazione dei dati** al processo.
+ I nodi **Ricetta di preparazione dei dati** richiedono Python. Viene impostato automaticamente quando il nodo **Ricetta di preparazione dei dati** viene aggiunto al processo.
+ L'aggiunta di un nuovo nodo **Ricetta di preparazione dei dati** al grafico visivo riavvierà automaticamente la sessione di Anteprima dei dati con le librerie corrette per utilizzare il nodo **Ricetta di preparazione dei dati**.
+ Le seguenti trasformazioni non sono supportate per l'importazione o la modifica in un nodo **Ricetta di preparazione dei dati**: `GROUP_BY`, `PIVOT`, `UNPIVOT`, e`TRANSPOSE`.
## Funzionalità aggiuntive
Dopo aver selezionato la trasformazione **Ricetta di preparazione dei dati**, hai la possibilità di intraprendere azioni aggiuntive dopo aver scelto **Author recipe**.
+ Aggiungi passaggio: puoi aggiungere ulteriori passaggi a una ricetta, se necessario, scegliendo l'icona Aggiungi passaggio oppure utilizzare la barra degli strumenti nel riquadro di anteprima scegliendo un'azione.
![\[Lo screenshot mostra l'icona Aggiungi ricetta.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/add-recipe-icon.png)
![\[Lo screenshot mostra l'icona Aggiungi ricetta.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/author-recipe-toolbar.png)
+ Importa ricetta: scegli **Altro**, quindi **Importa ricetta** da utilizzare nel tuo AWS Glue Studio processo.
![\[Lo screenshot mostra l'icona Altro.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/data-preparation-recipe-node-more-icon.png)
![\[Lo screenshot mostra l'icona Altro.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/data-preparation-recipe-node-more-features.png)
+ Scarica come YAML: scegli **Altro**, quindi **Scarica come YAML** per scaricare la ricetta da salvare all'esterno. AWS Glue Studio
+ Scarica come JSON: scegli **Altro**, quindi **Scarica come JSON per scaricare la ricetta** da salvare all'esterno. AWS Glue Studio
+ Annulla e ripeti i passaggi della ricetta: puoi annullare e ripetere i passaggi della ricetta nel riquadro di anteprima quando lavori con i dati nella griglia.
![\[Lo screenshot mostra l'icona Altro.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/author-recipe-toolbar-undo-redo.png)
# Crea ed esegui ricette di preparazione dei dati in un job ETL AWS Glue visivo
In questo scenario, puoi creare ricette di preparazione dei dati senza doverle prima creare. DataBrew Prima di iniziare a creare ricette, devi:
+ Avere in esecuzione una sessione di Anteprima dati attiva. Quando la sessione di anteprima dei dati è PRONTA, **Author Recipe** diventerà attiva e potrai iniziare a creare o modificare la tua ricetta.
![\[Lo screenshot mostra la sessione Anteprima dati come completa.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/data-preparation-recipe-data-preview-complete.png)
+ Assicurati che l'interruttore per l'**importazione automatica delle librerie glue** sia abilitato.
![\[Lo screenshot mostra l'opzione per l'importazione automatica delle librerie glue attivata.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/data-preparation-recipe-automatically-import-glue-libraries.png)
Puoi farlo scegliendo l'icona a forma di ingranaggio nel riquadro Anteprima dati.
![\[Lo screenshot mostra l'opzione per l'importazione automatica delle librerie glue attivata.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/data-preview-preferences.png)
**Per creare una ricetta di preparazione dei dati in AWS Glue Studio:**
1. Aggiungi il trasformatore **Data Preparation Recipe** al canvas del lavoro. Il trasformatore deve essere connesso a un nodo di origine dati padre. Quando aggiungi il nodo **Data Preparation Recipe**, questo si riavvierà con le librerie appropriate e vedrai il frame dei dati in preparazione.
![\[Lo screenshot mostra il caricamento del frame dei dati dopo l'aggiunta della ricetta per la preparazione dei dati.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/data-preparation-preparing-dataframe.png)
1. Una volta che la sessione di Anteprima dati è pronta, i dati con tutti i passaggi applicati in precedenza verranno visualizzati nella parte inferiore dello schermo.
1. Scegli **Author Recipe**. Ciò ti consentirà di iniziare una nuova ricetta in AWS Glue Studio.
![\[La schermata mostra il pannello Trasforma con i campi Nome e Nodo padre, oltre all'opzione Author Recipe.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/data-preparation-recipe-transform-tab-new.png)
1. Nel pannello **Trasforma** a destra del canvas di lavoro, inserisci un nome per la ricetta di preparazione dei dati.
1. Sul lato sinistro, il canvas verrà sostituito da una visualizzazione a griglia dei dati. A destra, il pannello **Trasforma** cambierà per mostrare i passaggi della ricetta. Scegli **Aggiungi passaggio** per aggiungere il primo passaggio della ricetta.
![\[Lo screenshot mostra il pannello Trasforma dopo aver scelto Aggiungi passaggio. Quando scegli una colonna, le opzioni cambiano in modo dinamico. Puoi scegliere di ordinare, eseguire un'azione sulla colonna e filtrare i valori.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/author-recipe-preview-data-transform-panel.png)
1. Nel pannello **Trasforma** puoi scegliere di ordinare, eseguire un'azione sulla colonna e filtrare i valori. Ad esempio, scegli **Rinomina colonna**.
![\[Lo screenshot mostra il pannello Trasforma dopo aver scelto Aggiungi passaggio. Quando scegli una colonna, le opzioni cambiano in modo dinamico. Puoi scegliere di ordinare, eseguire un'azione sulla colonna e filtrare i valori.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/author-recipe-add-step.png)
1. Nel pannello Trasforma sul lato destro, le opzioni per rinominare una colonna consentono di scegliere la colonna di origine da rinominare e di inserire il nuovo nome della colonna. Dopo averlo fatto, scegli **Applica**.
Puoi visualizzare in anteprima ogni passaggio, annullarne uno, riordinarli e utilizzare qualsiasi icona di azione (Filtra, Ordina, Dividi, Unisci, ecc.) Quando esegui azioni nella griglia di dati, i passaggi vengono aggiunti alla ricetta nel pannello Trasforma.
![\[La schermata mostra la griglia Anteprima dei dati con la barra degli strumenti evidenziata. Puoi applicare un'azione utilizzando uno qualsiasi degli strumenti e questa verrà aggiunta alla ricetta nel pannello Trasforma a destra.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/author-recipe-preview-data-grid.png)
Se devi apportare una modifica, puoi farlo nel riquadro Anteprima visualizzando in anteprima il risultato di ogni passaggio, annullandolo e riordinandoli. Esempio:
+ Undo/redo passaggio: annulla un passaggio scegliendo l'icona **Annulla**. Puoi ripetere un passaggio scegliendo l'icona **Ripeti**.
![\[Lo screenshot mostra l'icona Altro.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/author-recipe-toolbar-undo-redo.png)
+ Fase di riordino: quando riordini una fase, AWS Glue Studio convaliderà ogni passaggio e ti comunicherà se non è valido.
1. Dopo aver applicato un passaggio, il pannello Trasforma ti mostrerà tutti i passaggi della ricetta. Puoi cancellare tutti i passaggi per ricominciare da capo, aggiungerne altri scegliendo l'icona Aggiungi o scegliere **Done Authoring Recipe**.
![\[Lo screenshot mostra il pannello Trasformazione con i passaggi aggiunti alla ricetta. Al termine, scegli Done Authoring Recipe o l'icona Aggiungi per aggiungere altri passaggi alla ricetta.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/author-recipe-done-authoring-recipe.png)
1. Scegli **Salva** nella parte in alto a destra dello schermo. I passaggi della ricetta non verranno salvati finché non salverai il lavoro.
# Importa una AWS Glue DataBrew ricetta in AWS Glue Studio
In AWS Glue DataBrew, una ricetta è un insieme di passaggi di trasformazione dei dati. AWS Glue DataBrew recipes descrive come trasformare i dati che sono già stati letti e non descrive dove e come leggere i dati, né come e dove scrivere i dati. Questo è configurato nei nodi di origine e destinazione in AWS Glue Studio. Per ulteriori informazioni sulle ricette, consulta [Creazione e utilizzo delle AWS Glue DataBrew ricette](https://docs.aws.amazon.com/databrew/latest/dg/recipes.html).
Per utilizzare AWS Glue DataBrew le ricette inAWS Glue Studio, iniziate con la creazione di ricette in AWS Glue DataBrew. Se disponi di ricette che desideri utilizzare, puoi ignorare questo passaggio.
## Autorizzazioni IAM per AWS Glue DataBrew
Questo argomento fornisce informazioni per aiutarti a comprendere le azioni e le risorse che un amministratore IAM può utilizzare in una policy AWS Identity and Access Management (IAM) per la trasformazione Data Preparation Recipe.
Per ulteriori informazioni sulla sicurezza in AWS Glue, consulta [Gestione degli accessi](https://docs.aws.amazon.com/glue/latest/dg/security.html).
**Nota**
La tabella seguente elenca le autorizzazioni necessarie perché un utente possa importare una ricetta AWS Glue DataBrew esistente.
**Azioni di trasformazione della ricetta di preparazione dei dati**
| Azione | Description |
| --- | --- |
| databrew:ListRecipes | Concede l'autorizzazione a recuperare le ricette AWS Glue DataBrew . |
| databrew:ListRecipeVersions | Concede l'autorizzazione a recuperare le versioni delle ricette AWS Glue DataBrew . |
| databrew:DescribeRecipe | Concede l'autorizzazione a recuperare la descrizione della ricetta AWS Glue DataBrew . |
Il ruolo che stai utilizzando per accedere a questa funzionalità deve disporre di una policy che consenta diverse azioni AWS Glue DataBrew . A tale scopo, puoi utilizzare una policy `AWSGlueConsoleFullAccess` che includa le azioni necessarie o aggiungere la seguente policy incorporata al tuo ruolo:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"databrew:ListRecipes",
"databrew:ListRecipeVersions",
"databrew:DescribeRecipe"
],
"Resource": [
"*"
]
}
]
}
```
------
Per utilizzare la trasformazione Ricetta di preparazione dei dati, devi aggiungere l'operazione `IAM:PassRole` alla policy delle autorizzazioni.
**Autorizzazioni aggiuntive richieste**
| Azione | Description |
| --- | --- |
| iam:PassRole | Concede a IAM l'autorizzazione per consentire all'utente di trasmettere i ruoli approvati. |
Senza queste autorizzazioni si verifica il seguente errore:
```
"errorCode": "AccessDenied"
"errorMessage": "User: arn:aws:sts::account_id:assumed-role/AWSGlueServiceRole is not
authorized to perform: iam:PassRole on resource: arn:aws:iam::account_id:role/service-role/AWSGlueServiceRole
because no identity-based policy allows the iam:PassRole action"
```
## Importazione di una ricetta AWS Glue DataBrew
**Per importare una AWS Glue DataBrew ricetta e utilizzarla inAWS Glue Studio:**
Se disponi di un nodo **Data Preparation Recipe** e desideri modificare i passaggi della ricetta direttamente in AWS Glue Studio, dovrai importare i passaggi della ricetta nel tuo AWS Glue Studio lavoro.
1. Avvia un processo AWS Glue con un'origine dati AWS Glue Studio.
1. Aggiungi il nodo **Data Preparation Recipe** al canvas del lavoro.
![\[La schermata mostra il modale Aggiungi nodo con la ricetta per la preparazione dei dati disponibile per la selezione.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/glue-add-node-data-preparation-recipe.png)
1. Nel pannello Trasforma, inserisci un nome per la ricetta.
1. Scegli uno o più nodi padre selezionando i nodi disponibili sul canvas dall'elenco a discesa.
1. Scegli **Author Recipe**. Se **Author Recipe** è grigio, non è disponibile fino a quando non sono stati selezionati i nodi padre e non è terminata una sessione di anteprima dei dati.
![\[Author Data Preparation Recipe form with name field and node parents selection dropdown.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/glue-author-data-preparation-recipe.png)
1. Il frame di dati viene caricato e mostra informazioni dettagliate sui dati di origine.
Seleziona l'icona **Altre azioni** e scegli **Importa ricetta**.
![\[Data preparation interface showing "Build your Recipe" with an "Add step" button.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/glue-dataframe-import-recipe.png)
1. Usa la procedura guidata di importazione della ricetta per completare i passaggi. Nel passaggio 1, cerca la tua ricetta, selezionala e scegli **Avanti**.
![\[Import recipe interface showing two recipes, with one selected for import.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/import-recipe-step-1.png)
1. Nel passaggio 2, scegli le opzioni di importazione. Puoi scegliere di aggiungere una nuova ricetta a una ricetta esistente o di sovrascrivere una ricetta esistente. Scegli **Next (Successivo)**.
![\[Import recipe interface showing selected recipe, version, and two imported steps.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/import-recipe-step-2.png)
1. Nel passaggio 3, convalida i passaggi della ricetta. Una volta importata la AWS Glue DataBrew ricetta, puoi modificarla direttamente in AWS Glue Studio.
![\[Recipe import interface showing two steps and a validation progress indicator.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/import-recipe-step-3.png)
![\[Import recipe interface showing validated steps for sorting and formatting data.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/import-recipe-step-3-validated-2.png)
1. Dopodiché, i passaggi verranno importati come parte del tuo AWS Glue lavoro. Apporta le modifiche di configurazione necessarie nella scheda **Dettagli del lavoro**, ad esempio assegnando un nome al lavoro e regolando la capacità allocata in base alle esigenze. Scegli **Salva** per salvare il lavoro e la ricetta.
**Nota**
JOIN, UNION, GROUP\$1BY, PIVOT, UNPIVOT, TRANSPOSE non sono supportati per l'importazione delle ricette, né saranno disponibili nella modalità di creazione delle ricette.
1. Facoltativamente, puoi completare la creazione del lavoro aggiungendo altri nodi di trasformazione secondo necessità e aggiungendo i nodi di destinazione dei dati.
Se riordini i passaggi dopo aver importato una ricetta, AWS Glue esegue la convalida di tali passaggi. Ad esempio, se hai rinominato e poi eliminato una colonna e hai spostato il passaggio di eliminazione in alto, il passaggio di ridenominazione non è valido. Puoi quindi modificare i passaggi per correggere l'errore di convalida.
# Migrazione da AWS Glue DataBrew AWS Glue Studio
Se hai delle ricette AWS Glue DataBrew, usa la seguente lista di controllo per migrare le tue ricette su AWS Glue Studio.
| Se vuoi | Allora completa le seguenti operazioni |
| --- | --- |
| Consenti agli utenti di recuperare AWS Glue DataBrew ricette, versioni e descrizioni delle ricette. | Aggiungi le autorizzazioni IAM a una policy che consenta al tuo ruolo di accedere alle azioni necessarie. Per informazioni, consulta [Autorizzazioni IAM per AWS Glue DataBrew](glue-studio-data-preparation-import-recipe.md#glue-studio-databrew-permissions). |
| Importa una AWS Glue DataBrew ricetta esistente in AWS Glue Studio. | Segui la procedura riportata in [Importazione di una ricetta AWS Glue DataBrew](glue-studio-data-preparation-import-recipe.md#glue-studio-databrew-import-steps). |
| Importa una ricetta con JOIN e UNION. | Le ricette con le trasformazioni UNION e JOIN non sono supportate. Usa le trasformazioni Join e Union in AWS Glue Studio prima o dopo un nodo Data Preparation Recipe. |
# Utilizzo di Modifica schema per mappare nuovamente le chiavi delle proprietà dei dati
Una trasformazione *Modifica schema* mappa nuovamente le chiavi di proprietà dei dati di origine nella configurazione desiderata per i dati di destinazione. In un nodo di trasformazione Modifica schema, puoi:
+ Modificare il nome di più chiavi di proprietà dati.
+ Modificare il tipo di dati delle chiavi di proprietà dei dati, se il nuovo tipo di dati è supportato e esiste un percorso di trasformazione tra i due tipi di dati.
+ Scegliere un sottoinsieme di chiavi di proprietà dei dati indicando quali chiavi di proprietà dei dati si desidera eliminare.
È anche possibile aggiungere ulteriori nodi *Modifica schema* al diagramma del processo in base alle esigenze, ad esempio per modificare origini dati aggiuntive o in seguito a una trasformazione *Join*.
## Utilizzo di Modifica schema con tipo di dati decimale
Quando si utilizza la trasformazione **Modifica schema** con tipo di dati decimale, la trasformazione **Modifica schema** cambia la precisione portandola al valore predefinito di (10,2). Per modificare questa impostazione e impostare la precisione per il proprio caso d'uso, è possibile utilizzare la trasformazione **SQL Query** ed eseguire il cast delle colonne con una precisione specifica.
Ad esempio, se disponi di una colonna di input denominata DecimalCol "" di tipo Decimal e desideri rimapparla su una colonna di output denominata "OutputDecimalCol" con una precisione specifica di (18,6), dovresti:
1. Aggiungere una successiva trasformazione di **SQL Query** dopo la trasformazione **Modifica schema.**
1. Nella trasformazione di **SQL Query**, usare una query SQL per eseguire il cast della colonna rimappata con la precisione desiderata. E la query SQL risulterà simile a quanto segue:
```
SELECT col1, col2, CAST(DecimalCol AS DECIMAL(18,6)) AS OutputDecimalCol
FROM __THIS__
```
Nella query SQL precedente.
+ "col1" e "col2" sono altre colonne dei dati da esaminare senza modifiche.
+ `DecimalCol` è il nome della colonna originale dei dati di input.
+ `CAST (DecimalCol AS DECIMAL (18,6)) `inserisce` `in un tipo decimale con una precisione di 18 cifre e 6 cifre decimali. DecimalCol
+ `AS `rinomina la colonna castata in` `. OutputDecimalCol OutputDecimalCol
**Utilizzando la trasformazione **SQL Query**, è possibile sovrascrivere la precisione predefinita impostata dalla trasformazione Modifica schema e convertire in modo esplicito le colonne Decimal alla precisione desiderata.** **Questo approccio consente di sfruttare la trasformazione **Modifica schema** per rinominare e ristrutturare i dati gestendo al contempo i requisiti di precisione per le colonne Decimal attraverso la successiva trasformazione di SQL Query.**
## Aggiungere una trasformazione Modifica schema al processo
**Nota**
La trasformazione **Modifica schema** non fa distinzione tra maiuscole e minuscole.
**Aggiunta di un nodo di trasformazione Modifica schema al diagramma di processo**
1. (Facoltativo) Apri il pannello Risorse, quindi scegli **Modifica schema** per aggiungere una nuova trasformazione al diagramma di processo, se necessario.
1. Nel pannello Proprietà del nodo, inserisci un nome per il nodo nel diagramma del processo. Se non è già selezionato un nodo padre, scegli un nodo dall'elenco **Node parents** (Nodi padre) da utilizzare come origine di input per la trasformazione.
1. Seleziona la scheda **Trasforma** nel pannello Proprietà del nodo.
1. Modifica lo schema di input:
+ Per rinominare una chiave di proprietà dati, inserisci il nuovo nome della chiave nel campo **Target key** (Chiave di destinazione).
+ Per modificare il tipo di dati per una chiave di proprietà dei dati, scegli il nuovo tipo di dati per la chiave dall'elenco **Data type** (Tipo di dati).
+ Per rimuovere una chiave di proprietà dati dallo schema di destinazione, scegli la casella di controllo **Drop** (Elimina) per quella chiave.
1. (Facoltativo) Dopo aver configurato le proprietà del nodo di trasformazione, puoi visualizzare lo schema modificato per i dati scegliendo la scheda **Output schema** (Schema di output) nel pannello dei dettagli del nodo. La prima volta che si sceglie questa scheda per qualsiasi nodo del processo, viene richiesto di fornire un ruolo IAM per accedere ai dati. Se non è stato specificato un ruolo IAM nella scheda **Job details** (Dettagli del processo), viene richiesto di immettere un ruolo IAM a questo punto.
1. (Facoltativo) Dopo aver configurato le proprietà del nodo e le proprietà di trasformazione, puoi visualizzare il set di dati modificato scegliendo la scheda **Data preview** (Anteprima dei dati) nel pannello dei dettagli del nodo. La prima volta che si sceglie questa scheda per qualsiasi nodo del processo, viene richiesto di fornire un ruolo IAM per accedere ai dati. Esiste un costo per l'utilizzo di questa caratteristica e la fatturazione inizia non appena si fornisce un ruolo IAM.
# Utilizzo di Elimina duplicati
La trasformazione Elimina duplicati offre due opzioni per rimuovere le righe dall'origine dati. È possibile scegliere di rimuovere le righe duplicate interamente uguali oppure selezionare alcuni campi e rimuovere le righe corrispondenti solo in base ai campi scelti.
Ad esempio, in questo set di dati sono presenti righe duplicate in cui tutti i valori in alcune righe sono esattamente gli stessi di un'altra riga mentre altri sono uguali o diversi.
| Riga | Name | Email | Età | Stato | Nota |
| --- | --- | --- | --- | --- | --- |
| 1 | Joy | joy@gmail | 33 | NY | |
| 2 | Tim | tim@gmail | 45 | OH | |
| 3 | Rose | rose@gmail | 23 | NJ | |
| 4 | Tim | tim@gmail | 42 | OH | |
| 5 | Rose | rose@gmail | 23 | NJ | |
| 6 | Tim | tim@gmail | 42 | OH | Questa è una riga duplicata e corrisponde completamente in tutti i valori alla riga n. 4 |
| 7 | Rose | rose@gmail | 23 | NJ | Questa è una riga duplicata e corrisponde completamente in tutti i valori alla riga n. 5 |
Se scegli di abbinare righe intere, le righe 6 e 7 verranno rimosse dal set di dati. Il set di dati ora è:
| Riga | Name | Email | Età | Stato |
| --- | --- | --- | --- | --- |
| 1 | Joy | joy@gmail | 33 | NY |
| 2 | Tim | tim@gmail | 45 | OH |
| 3 | Rose | rose@gmail | 23 | NJ |
| 4 | Tim | tim@gmail | 42 | OH |
| 5 | Rose | rose@gmail | 23 | NJ |
Se hai scelto di specificare le chiavi, puoi scegliere di rimuovere le righe che corrispondono a "nome" ed "e-mail". In questo modo puoi esercitare un maggiore controllo su che cosa si intende per "riga duplicata" per il tuo set di dati. Specificando "nome" ed "e-mail", il set di dati ora è:
| Riga | Name | Email | Età | Stato |
| --- | --- | --- | --- | --- |
| 1 | Joy | joy@gmail | 33 | NY |
| 2 | Tim | tim@gmail | 45 | OH |
| 3 | Rose | rose@gmail | 23 | NJ |
Alcune cose da tenere a mente:
+ Affinché le righe vengano riconosciute come duplicate, i valori fanno distinzione tra maiuscole e minuscole. Tutti i valori nelle righe devono avere la stessa successione di maiuscole e minuscole. Questo vale per entrambe le opzioni scelte (Abbina righe intere o Specifica le chiavi).
+ Tutti i valori vengono letti come stringhe.
+ La trasformazione **Elimina duplicati** utilizza il comando dropDuplicates di Spark.
+ Quando si utilizza la trasformazione **Elimina duplicati**, la prima riga viene mantenuta e le altre righe vengono eliminate.
+ La trasformazione **Elimina duplicati** non modifica lo schema del dataframe. Se scegli di specificare le chiavi, tutti i campi vengono conservati nel dataframe risultante.
# Utilizzo SelectFields per rimuovere la maggior parte delle chiavi di proprietà dei dati
È possibile creare un sottoinsieme di chiavi di proprietà dei dati dal set di dati utilizzando la *SelectFields*trasformazione. Puoi indicare quali chiavi di proprietà dei dati conservare e le altre vengono rimosse dal set di dati.
**Nota**
La *SelectFields*trasformazione distingue tra maiuscole e minuscole. Usalo *ApplyMapping*se hai bisogno di un modo senza distinzione tra maiuscole e minuscole per selezionare i campi.
**Per aggiungere un nodo di SelectFields trasformazione al diagramma del lavoro**
1. (Facoltativo) Aprite il pannello Risorse, quindi scegliete **SelectFields**di aggiungere una nuova trasformazione al diagramma del lavoro, se necessario.
1. Nella scheda **Node properties** (Proprietà del nodo), inserisci un nome per il nodo nel diagramma del processo. Se non è già selezionato un nodo padre, scegli un nodo dall'elenco **Node parents** (Nodi padre) da utilizzare come origine di input per la trasformazione.
1. Seleziona la scheda **Transform (Trasformazione)** nel pannello dei dettagli del nodo.
1. Sotto l'intestazione **SelectFields**, scegliete le chiavi delle proprietà dei dati nel set di dati che desiderate conservare. Tutte le chiavi di proprietà dei dati non selezionate vengono eliminate dal set di dati.
Puoi anche selezionare la casella di controllo accanto all'intestazione di colonna **Field** (Campo) per scegliere automaticamente tutte le chiavi di proprietà dei dati nel set di dati. Quindi puoi deselezionare singolarmente le chiavi di proprietà dei dati per rimuoverle dal set di dati.
1. (Facoltativo) Dopo aver configurato le proprietà del nodo di trasformazione, puoi visualizzare lo schema modificato per i dati scegliendo la scheda **Output schema** (Schema di output) nel pannello dei dettagli del nodo. La prima volta che si sceglie questa scheda per qualsiasi nodo del processo, viene richiesto di fornire un ruolo IAM per accedere ai dati. Se non è stato specificato un ruolo IAM nella scheda **Job details** (Dettagli del processo), viene richiesto di immettere un ruolo IAM a questo punto.
1. (Facoltativo) Dopo aver configurato le proprietà del nodo e le proprietà di trasformazione, puoi visualizzare il set di dati modificato scegliendo la scheda **Data preview** (Anteprima dei dati) nel pannello dei dettagli del nodo. La prima volta che si sceglie questa scheda per qualsiasi nodo del processo, viene richiesto di fornire un ruolo IAM per accedere ai dati. Esiste un costo per l'utilizzo di questa caratteristica e la fatturazione inizia non appena si fornisce un ruolo IAM.
# Utilizzo DropFields per conservare la maggior parte delle chiavi di proprietà dei dati
È possibile creare un sottoinsieme di chiavi di proprietà dei dati dal set di dati utilizzando la *DropFields*trasformazione. Puoi indicare quali chiavi di proprietà dei dati rimuovere dal dataset e le altre vengono conservate.
**Nota**
La *DropFields*trasformazione distingue tra maiuscole e minuscole. Utilizza *Modifica schema* se ti serve un modo per selezionare i campi che non faccia distinzione tra maiuscole e minuscole.
**Per aggiungere un nodo di DropFields trasformazione al diagramma del lavoro**
1. (Facoltativo) Aprite il pannello Risorse, quindi scegliete di **DropFields**aggiungere una nuova trasformazione al diagramma del lavoro, se necessario.
1. Nella scheda **Node properties** (Proprietà del nodo), inserisci un nome per il nodo nel diagramma del processo. Se non è già selezionato un nodo padre, scegli un nodo dall'elenco **Node parents** (Nodi padre) da utilizzare come origine di input per la trasformazione.
1. Seleziona la scheda **Transform (Trasformazione)** nel pannello dei dettagli del nodo.
1. Sotto l'intestazione **DropFields**, scegliete le chiavi di proprietà dei dati da eliminare dalla fonte dei dati.
Puoi anche selezionare la casella di controllo accanto all'intestazione di colonna **Field** (Campo) per scegliere automaticamente tutte le chiavi di proprietà dei dati nel set di dati. Quindi puoi deselezionare singolarmente le chiavi di proprietà dei dati per mantenerle nel set di dati.
1. (Facoltativo) Dopo aver configurato le proprietà del nodo di trasformazione, puoi visualizzare lo schema modificato per i dati scegliendo la scheda **Output schema** (Schema di output) nel pannello dei dettagli del nodo. La prima volta che si sceglie questa scheda per qualsiasi nodo del processo, viene richiesto di fornire un ruolo IAM per accedere ai dati. Se non è stato specificato un ruolo IAM nella scheda **Job details** (Dettagli del processo), viene richiesto di immettere un ruolo IAM a questo punto.
1. (Facoltativo) Dopo aver configurato le proprietà del nodo e le proprietà di trasformazione, puoi visualizzare il set di dati modificato scegliendo la scheda **Data preview** (Anteprima dei dati) nel pannello dei dettagli del nodo. La prima volta che si sceglie questa scheda per qualsiasi nodo del processo, viene richiesto di fornire un ruolo IAM per accedere ai dati. Esiste un costo per l'utilizzo di questa caratteristica e la fatturazione inizia non appena si fornisce un ruolo IAM.
# Rinominare un campo nel set di dati
È possibile utilizzare la *RenameField*trasformazione per modificare il nome di una singola chiave di proprietà nel set di dati.
**Nota**
La *RenameField*trasformazione distingue tra maiuscole e minuscole. Usalo *ApplyMapping*se hai bisogno di una trasformazione senza distinzione tra maiuscole e minuscole.
**Suggerimento**
Utilizzando la trasformazione *Modifica schema* è possibile rinominare più chiavi di proprietà dei dati nel set di dati con una singola trasformazione.
**Per aggiungere un nodo di RenameField trasformazione al diagramma del lavoro**
1. (Facoltativo) Aprite il pannello Risorse, quindi scegliete di **RenameField**aggiungere una nuova trasformazione al diagramma del lavoro, se necessario.
1. Nella scheda **Node properties** (Proprietà del nodo), inserisci un nome per il nodo nel diagramma del processo. Se non è già selezionato un nodo padre, scegli un nodo dall'elenco **Node parents** (Nodi padre) da utilizzare come origine di input per la trasformazione.
1. Seleziona la scheda **Transform** (Trasformazione).
1. Sotto l'intestazione **Data field** (Campo dati), scegli una chiave di proprietà dai dati di origine, quindi inserisci un nuovo nome nel campo **New field name** (Nuovo nome campo).
1. (Facoltativo) Dopo aver configurato le proprietà del nodo di trasformazione, puoi visualizzare lo schema modificato per i dati scegliendo la scheda **Output schema** (Schema di output) nel pannello dei dettagli del nodo. La prima volta che si sceglie questa scheda per qualsiasi nodo del processo, viene richiesto di fornire un ruolo IAM per accedere ai dati. Se non è stato specificato un ruolo IAM nella scheda **Job details** (Dettagli del processo), viene richiesto di immettere un ruolo IAM a questo punto.
1. (Facoltativo) Dopo aver configurato le proprietà del nodo e le proprietà di trasformazione, puoi visualizzare il set di dati modificato scegliendo la scheda **Data preview** (Anteprima dei dati) nel pannello dei dettagli del nodo. La prima volta che si sceglie questa scheda per qualsiasi nodo del processo, viene richiesto di fornire un ruolo IAM per accedere ai dati. Esiste un costo per l'utilizzo di questa caratteristica e la fatturazione inizia non appena si fornisce un ruolo IAM.
# Utilizzo di Spigot per campionare il set di dati
Per testare le trasformazioni eseguite dal processo, è possibile ottenere un campione dei dati, allo scopo di verificare che la trasformazione funzioni come previsto. La trasformazione *Spigot* scrive un sottoinsieme di regitri dal set di dati in un file JSON in un bucket Amazon S3. Il metodo di campionamento dei dati può essere un numero specifico di registri dall'inizio del file o un fattore di probabilità utilizzato per selezionare i registri.
**Per aggiungere un nodo di trasformazione Spigot al diagramma di processo**
1. (Facoltativo) Apri il pannello Risorse, quindi scegli **Spigot** per aggiungere una nuova trasformazione al diagramma di processo, se necessario.
1. Nella scheda **Node properties** (Proprietà del nodo), inserisci un nome per il nodo nel diagramma del processo. Se non è già selezionato un nodo padre, scegli un nodo dall'elenco **Node parents** (Nodi padre) da utilizzare come origine di input per la trasformazione.
1. Seleziona la scheda **Transform (Trasformazione)** nel pannello dei dettagli del nodo.
1. Inserisci un percorso Amazon S3 o scegli **Browse S3** (Sfoglia S3) per scegliere una posizione in Amazon S3. Questa è la posizione in cui il processo scrive il file JSON che contiene l'esempio di dati.
1. Inserisci le informazioni per il metodo di campionamento. Puoi specificare un valore per **Number of records** (Numero di registri) da scrivere a partire dall'inizio del set di dati e una **Probability threshold** (Soglia di probabilità) (inserita sotto forma di valore decimale con un valore massimo di 1) di scelta di un dato registro.
Ad esempio, per scrivere i primi 50 registri dal set di dati, è necessario impostare **Number of records** (Numero di registri) su 50 e **Probability threshold** (Soglia di probabilità) su 1 (100%).
# Unione di set di dati
La trasformazione *Join* consente di combinare due set di dati in uno. È possibile specificare i nomi delle chiavi nello schema di ogni set di dati da confrontare. L'output `DynamicFrame` contiene righe in cui le chiavi soddisfano la condizione di join. Le righe in ogni set di dati che soddisfano la condizione di join vengono combinate in una singola riga nell'output `DynamicFrame`, che contiene tutte le colonne trovate in entrambi i set di dati.
**Per aggiungere un nodo di trasformazione Join al diagramma di processo**
1. Se è disponibile una sola origine dati, è necessario aggiungere un nuovo nodo di origine dati al diagramma di processo.
1. Scegli uno dei nodi di origine per il join. Apri il pannello Risorse, quindi scegli **Join** per aggiungere una nuova trasformazione al diagramma del processo.
1. Nella scheda **Node properties** (Proprietà del nodo), inserisci un nome per il nodo nel diagramma del processo.
1. Nella scheda **Node properties** (Proprietà del nodo), sotto l'intestazione **Node parents** (Nodi padre), aggiungi un nodo padre in modo che ci siano due set di dati che forniscono input per il join. Il padre può essere un nodo di origine dati o un nodo di trasformazione.
**Nota**
Un join può avere solo due nodi padre.
1. Seleziona la scheda **Transform** (Trasformazione).
Se viene visualizzato un messaggio che indica che esistono nomi di chiavi in conflitto, è possibile:
+ Scegli **Risolvi** per aggiungere automaticamente un nodo di *ApplyMapping*trasformazione al diagramma del lavoro. Il ApplyMapping nodo aggiunge un prefisso a tutte le chiavi del set di dati che hanno lo stesso nome di una chiave nell'altro set di dati. Ad esempio, se utilizzi il valore predefinito di **right**, tutte le chiavi nel set di dati destro che hanno lo stesso nome di una chiave nel set di dati sinistro verranno rinominate in `(right)key name`.
+ Aggiungere manualmente un nodo di trasformazione in precedenza nel diagramma del processo per rimuovere o rinominare le chiavi in conflitto.
1. Scegli il tipo di join nell'elenco **Join type** (Tipo di join).
+ **Inner join**: restituisce una riga con colonne di entrambi i set di dati per ogni corrispondenza in base alla condizione di join. Le righe che non soddisfano la condizione di join non vengono restituite.
+ **Left join**: tutte le righe del set di dati sinistro e solo le righe del set di dati destro che soddisfano la condizione di join.
+ **Right join**: tutte le righe del set di dati destro e solo le righe del set di dati sinistro che soddisfano la condizione di join.
+ **Outer join**: tutte le righe di entrambi i set di dati.
+ **Left semi join**: tutte le righe del set di dati sinistro che hanno una corrispondenza nel set di dati destro in base alla condizione di join.
+ **Right semi join**: tutte le righe del set di dati sinistro che non hanno una corrispondenza nel set di dati destro in base alla condizione di join.
1. Nella scheda **Transform** (Trasformazione), sotto l'intestazione **Join conditions** (Condizioni di join), scegli **Add condition** (Aggiungi condizione). Scegli una chiave di proprietà da ciascun set di dati da confrontare. Le chiavi di proprietà sul lato sinistro dell'operatore di confronto vengono definite come set di dati sinistro e le chiavi di proprietà a destra vengono definite come set di dati destro.
Per condizioni di join più complesse, è possibile aggiungere ulteriori chiavi di corrispondenza scegliendo **Add condition** (Aggiungi condizione) più di una volta. Se si aggiunge accidentalmente una condizione, è possibile selezionare l'icona di eliminazione (![\[\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/delete-icon-black.png)) per rimuoverla.
1. (Facoltativo) Dopo aver configurato le proprietà del nodo di trasformazione, puoi visualizzare lo schema modificato per i dati scegliendo la scheda **Output schema** (Schema di output) nel pannello dei dettagli del nodo. La prima volta che si sceglie questa scheda per qualsiasi nodo del processo, viene richiesto di fornire un ruolo IAM per accedere ai dati. Se non è stato specificato un ruolo IAM nella scheda **Job details** (Dettagli del processo), viene richiesto di immettere un ruolo IAM a questo punto.
1. (Facoltativo) Dopo aver configurato le proprietà del nodo e le proprietà di trasformazione, puoi visualizzare il set di dati modificato scegliendo la scheda **Data preview** (Anteprima dei dati) nel pannello dei dettagli del nodo. La prima volta che si sceglie questa scheda per qualsiasi nodo del processo, viene richiesto di fornire un ruolo IAM per accedere ai dati. Esiste un costo per l'utilizzo di questa funzionalità e la fatturazione inizia non appena si fornisce un ruolo IAM.
Per un esempio di schema di output del join, considera un join tra due set di dati con le seguenti chiavi di proprietà:
```
Left: {id, dept, hire_date, salary, employment_status}
Right: {id, first_name, last_name, hire_date, title}
```
Il join è configurato in modo che corrisponda alle chiavi `id` e `hire_date` utilizzando l'operatore di confronto `=`.
Perché entrambi i set di dati contengono le chiavi `id` e `hire_date`, scegli **Resolve it** (Risolvi) per aggiungere automaticamente il prefisso **right** alle chiavi nel set di dati giusto.
Le chiavi nello schema di output sarebbero:
```
{id, dept, hire_date, salary, employment_status,
(right)id, first_name, last_name, (right)hire_date, title}
```
# Utilizzo di Union per combinare le righe
Il nodo di trasformazione Union si utilizza quando si desidera combinare righe provenienti da più di un'origine dati aventi il medesimo schema.
Esistono due tipi di trasformazioni Union:
1. ALL: quando si applica ALL, l'unione risultante non rimuove le righe duplicate.
1. DISTINCT: quando si applica DISTINCT, l'unione risultante rimuove le righe duplicate.
**Union e Join: differenze**
Si utilizza Union per combinare le righe. Si utilizza Join per combinare le colonne.
**Utilizzo della trasformazione Union nel canvas di ETL visivo**
1. Aggiungi più di un'origine dati per eseguire una trasformazione Union. Per aggiungere un'origine dati, apri il pannello Risorse, quindi scegli l'origine dati dalla scheda Origini. Prima di utilizzare la trasformazione Union, devi assicurarti che tutte le origini dati coinvolte nell'unione abbiano lo stesso schema e la stessa struttura.
1. Quando hai almeno due origini dati che desideri combinare utilizzando la trasformazione Union, crea la trasformazione Union aggiungendola al canvas. Apri il pannello Risorse sul canvas e cerca "Union". In alternativa, scegli la scheda Trasformazioni nel pannello Risorse, scorri verso il basso fino a trovare la trasformazione Union, quindi scegli **Union**.
1. Seleziona il nodo Union nel canvas del processo. Nella finestra Proprietà del nodo, scegli i nodi padri da connettere alla trasformazione Union.
1. AWS Glue verifica la compatibilità per assicurarsi che la trasformazione Union possa essere applicata a tutte le origini dati. Se lo schema delle origini dati è lo stesso, l'operazione sarà consentita. Se le origini dati non hanno lo stesso schema, viene visualizzato un messaggio di errore: "The input schemas of this union are not the same. Prendi in considerazione l'idea ApplyMapping di utilizzarlo per abbinare gli schemi.» Per risolvere questo problema, scegli Usa **ApplyMapping**.
1. Scegli il tipo di Union.
1. All: per impostazione predefinita, è selezionato il tipo All Union; ciò comporterà la duplicazione delle righe, se presenti nella combinazione di dati.
1. Distinct: scegli Distinct se desideri che le righe duplicate vengano rimosse dalla combinazione di dati risultante.
# Utilizzo SplitFields per dividere un set di dati in due
La *SplitFields*trasformazione consente di scegliere alcune delle chiavi di proprietà dei dati nel set di dati di input e inserirle in un set di dati e le chiavi non selezionate in un set di dati separato. L'output di questa trasformazione è una raccolta di `DynamicFrames`.
**Nota**
È necessario utilizzare una *SelectFromCollection*trasformazione per convertire la raccolta di `DynamicFrames` in una singola `DynamicFrame` prima di poter inviare l'output a una posizione di destinazione.
La *SplitFields*trasformazione distingue tra maiuscole e minuscole. Aggiungi una *ApplyMapping*trasformazione come nodo principale se hai bisogno di nomi di chiavi di proprietà senza distinzione tra maiuscole e minuscole.
**Per aggiungere un nodo di SplitFields trasformazione al diagramma del lavoro**
1. (Facoltativo) Aprite il pannello Risorse, quindi scegliete di **SplitFields**aggiungere una nuova trasformazione al diagramma del lavoro, se necessario.
1. Nella scheda **Node properties** (Proprietà del nodo), inserisci un nome per il nodo nel diagramma del processo. Se non è già selezionato un nodo padre, scegli un nodo dall'elenco **Node parents** (Nodi padre) da utilizzare come origine di input per la trasformazione.
1. Seleziona la scheda **Transform** (Trasformazione).
1. Scegli le chiavi di proprietà da inserire nel primo set di dati. Le chiavi non scelte vengono inserite nel secondo set di dati.
1. (Facoltativo) Dopo aver configurato le proprietà del nodo di trasformazione, puoi visualizzare lo schema modificato per i dati scegliendo la scheda **Output schema** (Schema di output) nel pannello dei dettagli del nodo. La prima volta che si sceglie questa scheda per qualsiasi nodo del processo, viene richiesto di fornire un ruolo IAM per accedere ai dati. Se non è stato specificato un ruolo IAM nella scheda **Job details** (Dettagli del processo), viene richiesto di immettere un ruolo IAM a questo punto.
1. (Facoltativo) Dopo aver configurato le proprietà del nodo e le proprietà di trasformazione, puoi visualizzare il set di dati modificato scegliendo la scheda **Data preview** (Anteprima dei dati) nel pannello dei dettagli del nodo. La prima volta che si sceglie questa scheda per qualsiasi nodo del processo, viene richiesto di fornire un ruolo IAM per accedere ai dati. Esiste un costo per l'utilizzo di questa caratteristica e la fatturazione inizia non appena si fornisce un ruolo IAM.
1. Configura un nodo di *SelectFromCollection*trasformazione per elaborare i set di dati risultanti.
# Panoramica della trasformazione *SelectFromCollection*
Alcune trasformazioni hanno come output più set di dati anziché un singolo set di dati, ad esempio. *SplitFields* La *SelectFromCollection*trasformazione seleziona un set di dati (`DynamicFrame`) da una raccolta di set di dati (una matrice di). `DynamicFrames` L'output per la trasformazione è il `DynamicFrame` selezionato.
È necessario utilizzare questa trasformazione dopo aver utilizzato una trasformazione che crea una raccolta di `DynamicFrames`, come ad esempio:
+ Trasformazioni di codice personalizzate
+ *SplitFields*
Se non aggiungete un nodo di *SelectFromCollection*trasformazione al diagramma del lavoro dopo una di queste trasformazioni, riceverete un errore relativo al vostro lavoro.
Il nodo padre per questa trasformazione deve essere un nodo che restituisce una raccolta di `DynamicFrames`. Se per questo nodo di trasformazione si sceglie un padre che restituisce un singolo `DynamicFrame`, ad esempio *Join*, il processo restituisce un errore.
Analogamente, se si utilizza un *SelectFromCollection*nodo nel diagramma del processo come elemento principale per una trasformazione che prevede un valore singolo `DynamicFrame` come input, il processo restituisce un errore.
![\[Lo screenshot mostra il campo Node parents (Nodi padre) nella scheda Node properties (Proprietà del nodo) del pannello dei dettagli del nodo. Il nodo principale selezionato è SplitFields e il messaggio di errore visualizzato indica che il nodo padre Split Fields genera una raccolta, ma il nodo Drop Fields non accetta una raccolta.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/screenshot-edit-splitfields-wrong-parent.png)
# Utilizzo SelectFromCollection per scegliere quale set di dati conservare
Usa la *SelectFromCollection*trasformazione per convertire una raccolta di `DynamicFrames` in una singola`DynamicFrame`.
**Per aggiungere un nodo di SelectFromCollection trasformazione al diagramma del lavoro**
1. (Facoltativo) Aprite il pannello Risorse, quindi scegliete di **SelectFromCollection**aggiungere una nuova trasformazione al diagramma del lavoro, se necessario.
1. Nella scheda **Node properties** (Proprietà del nodo), inserisci un nome per il nodo nel diagramma del processo. Se non è già selezionato un nodo padre, scegli un nodo dall'elenco **Node parents** (Nodi padre) da utilizzare come origine di input per la trasformazione.
1. Seleziona la scheda **Transform** (Trasformazione).
1. Sotto l'intestazione **Frame index** (Indice del frame), scegli il numero di indice della matrice che corrisponde al `DynamicFrame` da selezionare dalla raccolta di `DynamicFrames`.
Ad esempio, se il nodo principale di questa trasformazione è una *SplitFields*trasformazione, nella scheda **Schema di output** di quel nodo è possibile visualizzare lo schema per ciascuno `DynamicFrame` di essi. Per mantenere il `DynamicFrame` associato allo schema per **Output 2**, devi selezionare **1** per il valore di **Frame index** (Indice di frame), che è il secondo valore nell'elenco.
Solo il `DynamicFrame` scelto è incluso nell'output.
1. (Facoltativo) Dopo aver configurato le proprietà del nodo di trasformazione, puoi visualizzare lo schema modificato per i dati scegliendo la scheda **Output schema** (Schema di output) nel pannello dei dettagli del nodo. La prima volta che si sceglie questa scheda per qualsiasi nodo del processo, viene richiesto di fornire un ruolo IAM per accedere ai dati. Se non è stato specificato un ruolo IAM nella scheda **Job details** (Dettagli del processo), viene richiesto di immettere un ruolo IAM a questo punto.
1. (Facoltativo) Dopo aver configurato le proprietà del nodo e le proprietà di trasformazione, puoi visualizzare il set di dati modificato scegliendo la scheda **Data preview** (Anteprima dei dati) nel pannello dei dettagli del nodo. La prima volta che si sceglie questa scheda per qualsiasi nodo del processo, viene richiesto di fornire un ruolo IAM per accedere ai dati. Esiste un costo per l'utilizzo di questa caratteristica e la fatturazione inizia non appena si fornisce un ruolo IAM.
# Trovare e riempi i valori mancanti in un set di dati
È possibile utilizzare la *FillMissingValues*trasformazione per individuare i record nel set di dati con valori mancanti e aggiungere un nuovo campo con un valore determinato dall'imputazione. Il set di dati di input viene utilizzato per addestrare il modello di Machine Learning (ML) che determina quale dovrebbe essere il valore mancante. Se si utilizzano set di dati incrementali, ogni set incrementale viene utilizzato come dati di addestramento per il modello ML, pertanto i risultati potrebbero non essere molto accurati.
**Per utilizzare un nodo di FillMissingValues trasformazione nel diagramma del lavoro**
1. (Facoltativo) Aprite il pannello Risorse, quindi scegliete di **FillMissingValues**aggiungere una nuova trasformazione al diagramma del lavoro, se necessario.
1. Nella scheda **Node properties** (Proprietà del nodo), inserisci un nome per il nodo nel diagramma del processo. Se non è già selezionato un nodo padre, scegli un nodo dall'elenco **Node parents** (Nodi padre) da utilizzare come origine di input per la trasformazione.
1. Seleziona la scheda **Transform** (Trasformazione).
1. Per **Data field** (Campo dati), scegli il nome della colonna o del campo dai dati di origine da analizzare per i valori mancanti.
1. (Facoltativo) Nel campo **New field name** (Nuovo nome campo), inserisci un nome per il campo aggiunto a ciascun registro che conterrà il valore di sostituzione stimato per il campo analizzato. Se nel campo analizzato non ci sono valori mancanti, il valore nel campo analizzato viene copiato nel nuovo campo.
Se non specifichi un nome per il nuovo campo, il nome predefinito è il nome della colonna analizzata con aggiunta di `_filled`. Ad esempio, se inserisci **Age** per **Data field** (Campo dati) senza specificare un valore per **New field name** (Nuovo nome campo), a ogni registro viene aggiunto un nuovo campo denominato **Age\$1filled**.
1. (Facoltativo) Dopo aver configurato le proprietà del nodo di trasformazione, puoi visualizzare lo schema modificato per i dati scegliendo la scheda **Output schema** (Schema di output) nel pannello dei dettagli del nodo. La prima volta che si sceglie questa scheda per qualsiasi nodo del processo, viene richiesto di fornire un ruolo IAM per accedere ai dati. Se non è stato specificato un ruolo IAM nella scheda **Job details** (Dettagli del processo), viene richiesto di immettere un ruolo IAM a questo punto.
1. (Facoltativo) Dopo aver configurato le proprietà del nodo e le proprietà di trasformazione, puoi visualizzare il set di dati modificato scegliendo la scheda **Data preview** (Anteprima dei dati) nel pannello dei dettagli del nodo. La prima volta che si sceglie questa scheda per qualsiasi nodo del processo, viene richiesto di fornire un ruolo IAM per accedere ai dati. Esiste un costo per l'utilizzo di questa caratteristica e la fatturazione inizia non appena si fornisce un ruolo IAM.
# Filtro delle chiavi all'interno di un set di dati
Utilizzo della trasformazione *Filter* per creare un nuovo set di dati filtrando i registri dal set di dati di input in base a un'espressione regolare. Le righe che non soddisfano la condizione di filtro vengono rimosse dall'output.
+ Per i tipi di dati stringa, è possibile filtrare le righe in cui il valore della chiave corrisponde a una stringa specificata.
+ Per i tipi di dati numerici, è possibile filtrare le righe confrontando il valore della chiave con un valore specificato utilizzando gli operatori di confronto `<`, `>`, `=`, `!=`, `<=` e `>=`.
Se si specificano più condizioni di filtro, i risultati vengono combinati utilizzando `AND` per impostazione predefinita, ma è possibile anche scegliere `OR`.
La trasformazione *Filter* fa distinzione tra maiuscole e minuscole. Aggiungi una *ApplyMapping*trasformazione come nodo principale se hai bisogno di nomi di chiavi di proprietà senza distinzione tra maiuscole e minuscole.
**Per aggiungere un nodo di trasformazione Filter al diagramma di processo**
1. (Facoltativo) Apri il pannello Risorse, quindi scegli **Filtra** per aggiungere una nuova trasformazione al diagramma di processo, se necessario.
1. Nella scheda **Node properties** (Proprietà del nodo), inserisci un nome per il nodo nel diagramma del processo. Se non è già selezionato un nodo padre, scegli un nodo dall'elenco **Node parents** (Nodi padre) da utilizzare come origine di input per la trasformazione.
1. Seleziona la scheda **Transform** (Trasformazione).
1. Scegli **Globale AND** o **Global OR**. Questo determina il modo in cui vengono combinate più condizioni di filtro. Tutte le condizioni sono combinate usando le operazioni `AND` o `OR`. Se hai una condizione di filtro singolo, puoi sceglierne una delle due.
1. Seleziona il pulsante **Add condition** (Aggiungi condizione) nella sezione **Filter condition** (Condizione di filtro) per aggiungere una condizione di filtro.
Nel campo **Key** (Chiave), scegli il nome di una chiave di proprietà dal set di dati. Nel campo **Operation** (Operazione), seleziona l'operatore di confronto. Nel campo **Value** (Valore), inserisci il valore di confronto. Di seguito sono riportate alcuni esempi di condizioni di filtro.
+ `year >= 2018`
+ `State matches 'CA*'`
Quando si filtrano i valori di stringa, è necessario assicurarsi che il valore di confronto utilizzi un formato di espressione regolare che corrisponda al linguaggio di script selezionato nelle proprietà del processo (Python o Scala).
1. Aggiungi ulteriori condizioni di filtro, se necessario.
1. (Facoltativo) Dopo aver configurato le proprietà del nodo di trasformazione, puoi visualizzare lo schema modificato per i dati scegliendo la scheda **Output schema** (Schema di output) nel pannello dei dettagli del nodo. La prima volta che si sceglie questa scheda per qualsiasi nodo del processo, viene richiesto di fornire un ruolo IAM per accedere ai dati. Se non è stato specificato un ruolo IAM nella scheda **Job details** (Dettagli del processo), viene richiesto di immettere un ruolo IAM a questo punto.
1. (Facoltativo) Dopo aver configurato le proprietà del nodo e le proprietà di trasformazione, puoi visualizzare il set di dati modificato scegliendo la scheda **Data preview** (Anteprima dei dati) nel pannello dei dettagli del nodo. La prima volta che si sceglie questa scheda per qualsiasi nodo del processo, viene richiesto di fornire un ruolo IAM per accedere ai dati. Esiste un costo per l'utilizzo di questa caratteristica e la fatturazione inizia non appena si fornisce un ruolo IAM.
# Utilizzo DropNullFields per rimuovere campi con valori nulli
Usa la *DropNullFields*trasformazione per rimuovere i campi dal set di dati se tutti i valori nel campo sono «nulli». Per impostazione predefinita, AWS Glue Studio riconoscerà gli oggetti nulli, ma alcuni valori come stringhe vuote, stringhe "null", -1 interi o altri segnaposto come zeri, non verranno riconosciuti automaticamente come null.
**Per usare il DropNullFields**
1. Aggiungere un DropNullFields nodo al diagramma del lavoro.
1. Nella scheda **Node properties (Proprietà del nodo)**, scegli valori aggiuntivi che rappresentano un valore nullo. È possibile scegliere di selezionare nessuno o tutti i valori:
![\[La schermata mostra la scheda Trasforma per il DropNullFields nodo.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/DropNullFields-transform-tab.png)
+ Stringa vuota ("" or ''): i campi che contengono stringhe vuote verranno eliminati
+ "stringa null": i campi che contengono la stringa con la parola "null" verranno eliminati
+ -1 numero intero: i campi che contengono un numero intero -1 (negativo) verranno eliminati
1. Se necessario, è anche possibile specificare valori nulli personalizzati. Si tratta di valori nulli che potrebbero essere univoci per il set di dati. Per aggiungere un valore nullo personalizzato, scegli **Add new value (Aggiungi nuovo valore)**.
1. Inserisci il valore nullo personalizzato. Ad esempio, questo può essere zero o qualsiasi valore utilizzato per rappresentare un valore nullo nel set di dati.
1. Scegli il tipo di dati nel campo a discesa. I tipi di dati possono essere String o Integer.
**Nota**
I valori nulli personalizzati e i relativi tipi di dati devono corrispondere esattamente, affinché i campi vengano riconosciuti come valori nulli e vengano quindi eliminati. Corrispondenze parziali in cui solo il valore nullo personalizzato corrisponde, ma il tipo di dati non comporta l'eliminazione dei campi.
# Utilizzo di una query SQL per trasformare i dati
Puoi utilizzare una trasformazione **SQL** per scrivere la tua trasformazione sotto forma di query SQL.
Un nodo di trasformazione SQL può avere più set di dati come input, ma produce solo un singolo set di dati come output. Contiene un campo di testo, in cui puoi inserire la query Apache SparkSQL. Puoi assegnare alias a ciascun set di dati utilizzato come input, in modo da semplificare la query SQL. Per ulteriori informazioni sulla sintassi SQL, consulta la [documentazione di Spark SQL](https://spark.apache.org/docs/latest/sql-ref.html).
**Nota**
Se utilizzi una trasformazione SQL Spark con un'origine dati situata in un VPC, aggiungi un endpoint VPC AWS Glue al VPC che contiene l'origine dati. Per ulteriori informazioni sulla configurazione degli endpoint di sviluppo, consulta [Aggiunta di un endpoint di sviluppo](https://docs.aws.amazon.com/glue/latest/dg/add-dev-endpoint.html), [Impostazione dell'ambiente per endpoint di sviluppo](https://docs.aws.amazon.com/glue/latest/dg/start-development-endpoint.html) e [Accesso all'endpoint di sviluppo](https://docs.aws.amazon.com/glue/latest/dg/dev-endpoint-elastic-ip.html) nella *Guida per gli sviluppatori di AWS Glue *.
**Per aggiungere un nodo di trasformazione SQL al diagramma di processo**
1. (Facoltativo) Aggiungi un nodo di trasformazione al diagramma di processo, se necessario. Scegliere **SQL Query** per il tipo di nodo.
**Nota**
Se utilizzi una sessione di anteprima dei dati e un nodo SQL o di codice personalizzato personalizzato, la sessione di anteprima dei dati eseguirà l'SQL o il blocco di codice così com'è per l'intero set di dati.
1. Nella scheda **Node properties** (Proprietà del nodo), inserisci un nome per il nodo nel diagramma del processo. Se non è già selezionato un nodo padre, o se desideri più input per la trasformazione SQL, scegli un nodo dall'elenco **Node parents** (Nodi padre) da utilizzare come origine di input per la trasformazione. Aggiungi nodi padre aggiuntivi in base alle esigenze.
1. Seleziona la scheda **Transform (Trasformazione)** nel pannello dei dettagli del nodo.
1. I set di dati di origine per la query SQL sono identificati dai nomi specificati nel campo **Name** (Nome) per ogni nodo. Se non vuoi utilizzare questi nomi o se i nomi non sono adatti per una query SQL, puoi associare un nome a ciascun set di dati. La console fornisce alias predefiniti, ad esempio `MyDataSource`.
Ad esempio, se un nodo padre per il nodo di trasformazione SQL è denominato `Rename Org PK field`, è possibile associare il nome `org_table` a questo set di dati. Questo alias può quindi essere utilizzato nella query SQL al posto del nome del nodo.
1. Nel campo di immissione testo sotto l'intestazione **Code block** (Blocco di codice), incolla o immetti la query SQL. Il campo di testo mostra la sintassi SQL evidenziata e i suggerimenti per le parole chiave.
1. Con il nodo di trasformazione SQL selezionato, scegli l'opzione **Output schema** (Schema di output), quindi scegli **Edit** (Modifica). Specifica le colonne e i tipi di dati che descrivono i campi di output della query SQL.
Specifica lo schema utilizzando le azioni seguenti nella sezione **Output schema** (Schema di output) della pagina:
+ Per rinominare una colonna, posiziona il cursore nella casella di testo **Key** (Chiave) per la colonna (nota anche come *field* (campo) o *property key* (chiave di proprietà) e inserisci il nuovo nome.
+ Per modificare il tipo di dati per una colonna, seleziona il nuovo tipo di dati per la colonna dall'elenco a discesa.
+ Per aggiungere una nuova colonna di livello superiore allo schema, scegli l'opzione Overflow (![\[\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/edit-schema-actions-button.png)), quindi scegli **Add root key** (Aggiungi chiave root). Vengono aggiunte nuove colonne nella parte superiore dello schema.
+ Per rimuovere una colonna dallo schema, scegli l'icona di eliminazione (![\[\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/delete-icon-black.png)) all'estrema destra del nome della chiave.
1. Una volta terminato di specificare lo schema di output, scegli **Apply** (Applica) per salvare le modifiche e uscire dall'editor dello schema. Se non vuoi salvare le modifiche, scegli **Cancel** (Annulla) per modificare l'editor dello schema.
1. (Facoltativo) Dopo aver configurato le proprietà del nodo e le proprietà di trasformazione, puoi visualizzare il set di dati modificato scegliendo la scheda **Data preview** (Anteprima dei dati) nel pannello dei dettagli del nodo. La prima volta che si sceglie questa scheda per qualsiasi nodo del processo, viene richiesto di fornire un ruolo IAM per accedere ai dati. Esiste un costo per l'utilizzo di questa caratteristica e la fatturazione inizia non appena si fornisce un ruolo IAM.
# Utilizzo di Aggregate per eseguire calcoli di riepilogo sui campi selezionati
**Utilizzo della trasformazione Aggregate**
1. Aggiungi il nodo Aggregate al diagramma del processo.
1. Nella scheda **Node properties (Proprietà del nodo)**, scegli i campi da raggruppare selezionando il campo a discesa (facoltativo). È possibile selezionare più di un campo alla volta o cercare il nome del campo digitando nella barra di ricerca.
Quando i campi sono selezionati, vengono visualizzati il nome e il tipo di dati. Per eliminare un campo, selezionare "X" sul campo.
![\[Lo screenshot mostra la scheda Trasformazioni per il nodo Aggregate.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/Aggregate-transform-tab.png)
1. Scegli **Aggregate another column (Aggrega un'altra colonna)**. È necessario selezionare almeno un campo.
![\[Lo screenshot mostra i campi quando si sceglie Aggregate another column (Aggrega un'altra colonna).\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/Aggregate-fieldtoaggregate.png)
1. Scegli un campo nel menu a discesa **Field to aggregate (Campo da aggregare)**.
1. Scegli la funzione di aggregazione da applicare al campo scelto:
+ avg. calcola la media
+ countDistinct: calcola il numero di valori univoci non nulli
+ count: calcola il numero di valori non null
+ first: restituisce il primo valore che soddisfa i criteri "raggruppa per"
+ last: restituisce l'ultimo valore che soddisfa i criteri "raggruppa per"
+ kurtosis: calcola la nitidezza del picco di una curva di distribuzione della frequenza
+ max: restituisce il valore più alto che soddisfa i criteri "raggruppa per"
+ min: restituisce il valore più basso che soddisfa i criteri "raggruppa per"
+ skewness: misura l'asimmetria della distribuzione di probabilità di una distribuzione normale
+ stddev\$1pop: calcola la deviazione standard della popolazione e restituisce la radice quadrata della varianza di popolazione
+ sum: la somma di tutti i valori del gruppo
+ SumDistinct: la somma di valori distinti nel gruppo
+ var\$1samp: la varianza campione del gruppo (ignora i valori nulli)
+ var\$1pop: la varianza di popolazione del gruppo (ignora i valori nulli)
# Appiattimento di strutture annidate
*Appiattisci* i campi delle strutture annidate nei dati, in modo che diventino campi di primo livello. I nuovi campi vengono denominati utilizzando il nome del campo preceduto dai nomi dei campi della struttura per raggiungerlo, separati da punti.
Ad esempio, prendiamo un caso in cui i dati hanno un campo di tipo Struct denominato "phone\$1numbers", che tra gli altri campi ne ha uno di tipo Struct denominato "home\$1phone" con due campi: "country\$1code" e "number". Una volta appiattiti, questi due campi diventeranno campi di primo livello denominati rispettivamente "phone\$1numbers.home\$1phone.country\$1code" e "phone\$1numbers.home\$1phone.number".
**Aggiunta di un nodo di trasformazione *Appiattisci* nel diagramma di processo**
1. Apri il pannello Risorse, scegli la scheda **Trasformazioni**, quindi **Appiattisci** per aggiungere una nuova trasformazione al diagramma di processo. È inoltre possibile digitare "Appiattisci" nella barra di ricerca e poi fare clic sul nodo Appiattisci. Il nodo selezionato al momento dell'aggiunta del nodo ne sarà il nodo padre.
![\[La schermata mostra il pannello Risorse e la barra di ricerca popolata con la parola "Appiattisci". Il risultato della ricerca mostra la trasformazione Appiattisci.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/transform-flatten.png)
1. (Facoltativo) Nella scheda **Proprietà del nodo**, è possibile inserire un nome per il nodo nel diagramma del processo. Se non è già selezionato un nodo padre, scegli un nodo dall'elenco **Node parents** (Nodi padre) da utilizzare come origine di input per la trasformazione.
1. (Facoltativo) Nella scheda **Trasforma**, puoi limitare l'appiattimento del livello massimo di annidamento. Ad esempio, se si imposta tale valore su 1 significa che solo le strutture di primo livello verranno appiattite. Impostando il valore massimo su 2 verrà appiattito il primo livello e le strutture direttamente sottostanti.
# Aggiunta di una colonna UUID
Quando aggiungi una colonna *UUID* (Universally Unique Identified), a ogni riga verrà assegnata una stringa univoca di 36 caratteri.
**Aggiunta di un nodo di trasformazione *UUID* al diagramma di processo**
1. Apri il pannello Risorse, quindi scegli **UUID** per aggiungere una nuova trasformazione al diagramma di processo. Il nodo selezionato al momento dell'aggiunta del nodo ne sarà il nodo padre.
1. (Facoltativo) Nella scheda **Proprietà del nodo**, è possibile inserire un nome per il nodo nel diagramma del processo. Se non è già selezionato un nodo padre, scegli un nodo dall'elenco **Node parents** (Nodi padre) da utilizzare come origine di input per la trasformazione.
1. (Facoltativo) Nella scheda **Trasforma**, puoi personalizzare il nome della nuova colonna. Per impostazione predefinita, si chiamerà "uuid".
# Aggiunta di una colonna identificativa
Assegna un *Identificatore* numerico per ogni riga del set di dati.
**Aggiunta di un nodo di trasformazione *Identificatore* nel diagramma di processo**
1. Apri il pannello Risorse, quindi scegli **Identificatore** per aggiungere una nuova trasformazione al diagramma di processo. Il nodo selezionato al momento dell'aggiunta del nodo ne sarà il nodo padre.
1. (Facoltativo) Nella scheda **Proprietà del nodo**, è possibile inserire un nome per il nodo nel diagramma del processo. Se non è già selezionato un nodo padre, scegli un nodo dall'elenco **Node parents** (Nodi padre) da utilizzare come origine di input per la trasformazione.
1. (Facoltativo) Nella scheda **Trasforma**, puoi personalizzare il nome della nuova colonna. Per impostazione predefinita, verrà denominata "id".
1. (Facoltativo) Se il processo elabora e archivia i dati in modo incrementale, è necessario evitare che gli stessi ID vengano riutilizzati tra le esecuzioni del processo.
Nella scheda **Trasforma**, seleziona l'opzione della casella di controllo **Univoco**. Includerà il timestamp del processo nell'identificatore, rendendolo univoco tra più esecuzioni. Per consentire l'inserimento di un numero maggiore, la colonna anziché di tipo lungo sarà decimale.
# Conversione di una colonna in tipo timestamp
È possibile utilizzare la trasformazione *A timestamp* per modificare il tipo di dati di una colonna numerica o di stringa in un timestamp, in modo da consentirne l'archiviazione con quel tipo di dati o l'applicazione ad altre trasformazioni che richiedono un timestamp.
**Aggiunta di un nodo di trasformazione *A timestamp* nel diagramma di processo**
1. Apri il pannello Risorse, quindi scegli **A timestamp** per aggiungere una nuova trasformazione al diagramma del processo. Il nodo selezionato al momento dell'aggiunta del nodo ne sarà il nodo padre.
1. (Facoltativo) Nella scheda **Proprietà del nodo**, è possibile inserire un nome per il nodo nel diagramma del processo. Se non è già selezionato un nodo padre, scegli un nodo dall'elenco **Node parents** (Nodi padre) da utilizzare come origine di input per la trasformazione.
1. Nella scheda **Trasforma**, inserisci il nome della colonna da convertire.
1. Nella scheda **Trasforma**, definisci come analizzare la colonna selezionata scegliendo il tipo.
Se il valore è un numero, può essere espresso in secondi (timestamp Unix/Python), millisecondi o microsecondi, scegli l'opzione corrispondente.
Se il valore è una stringa formattata, scegli il tipo "iso"; la stringa deve essere conforme a una delle varianti del formato ISO, ad esempio: "2022-11-02T14:40:59.915Z".
Se a questo punto non conosci il tipo oppure righe diverse utilizzano tipi diversi, puoi scegliere "rilevamento automatico" e il sistema genererà la sua ipotesi migliore, a un costo di prestazioni ridotto.
1. (Facoltativo) Nella scheda **Trasforma**, invece di convertire la colonna selezionata, puoi crearne una nuova e mantenere l'originale inserendo un nome per la nuova colonna.
# Conversione di una colonna di timestamp in una stringa formattata
Formatta una colonna di timestamp in una stringa in base a uno schema. Puoi utilizzare *Formatta timestamp* per ottenere data e ora come stringa con il formato desiderato. Puoi definire il formato utilizzando la [sintassi della data Spark](https://spark.apache.org/docs/latest/sql-ref-datetime-pattern.html) e la maggior parte dei [codici di data Python](https://docs.python.org/3/library/datetime.html#strftime-and-strptime-format-codes).
Ad esempio, se desideri che la stringa della data sia formattata come «2023-01-01 00:00», puoi definire tale formato utilizzando la sintassi Spark come «HH:mm» o i codici data Python equivalenti come «%y-%m-%D %H: %Myyyy-MM-dd »
**Aggiunta di un nodo di trasformazione *Formatta timestamp* nel diagramma di processo**
1. Apri il pannello Risorse, quindi scegli **Formatta timestamp** per aggiungere una nuova trasformazione al diagramma del processo. Il nodo selezionato al momento dell'aggiunta del nodo ne sarà il nodo padre.
1. (Facoltativo) Nella scheda **Proprietà del nodo**, è possibile inserire un nome per il nodo nel diagramma del processo. Se non è già selezionato un nodo padre, scegli un nodo dall'elenco **Node parents** (Nodi padre) da utilizzare come origine di input per la trasformazione.
1. Nella scheda **Trasforma**, inserisci il nome della colonna da convertire.
1. Nella scheda **Trasforma**, inserisci il modello di **formato timestamp** da utilizzare, espresso utilizzando la [sintassi della data Spark](https://spark.apache.org/docs/latest/sql-ref-datetime-pattern.html) o [i codici di data Python](https://docs.python.org/3/library/datetime.html#strftime-and-strptime-format-codes).
1. (Facoltativo) Nella scheda **Trasforma**, invece di convertire la colonna selezionata, puoi crearne una nuova e mantenere l'originale inserendo un nome per la nuova colonna.
# Creazione di una trasformazione router condizionale
La trasformazione router condizionale consente di applicare più condizioni ai dati in ingresso. Ogni riga dei dati in ingresso viene valutata in base a una condizione di filtro di gruppo ed elaborata nel gruppo corrispondente. Se una riga soddisfa più di una condizione di filtro di gruppo, la trasformazione passa la riga a più gruppi. Se una riga non soddisfa alcuna condizione, può essere eliminata o indirizzata a un gruppo di output predefinito.
Questa trasformazione è simile alla trasformazione di filtro, ma utile per gli utenti che desiderano testare gli stessi dati di input su più condizioni.
**Per aggiungere una trasformazione router condizionale:**
1. Scegli un nodo in cui eseguire la trasformazione router condizionale. Può essere un nodo di origine o un'altra trasformazione.
1. Scegli **Azione**, quindi usa la barra di ricerca per trovare e scegliere "Router condizionale". Viene aggiunta una trasformazione **Router condizionale** insieme a due nodi di output. Un nodo di output, "Gruppo predefinito", contiene record che non soddisfano nessuna delle condizioni definite negli altri nodi di output. Il gruppo predefinito non può essere modificato.
![\[Lo screenshot mostra il nodo della trasformazione router condizionale collegato a un nodo di origine. I nodi di output vengono mostrati come diramazioni dal nodo del router condizionale.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/transform-conditional-router-node.png)
Puoi aggiungere altri gruppi di output scegliendo **Aggiungi gruppo**. Per ogni gruppo di output, è possibile assegnare un nome al gruppo e aggiungere condizioni di filtro e un operatore logico.
![\[Lo screenshot mostra la scheda di trasformazione router condizionale con le opzioni per denominare il gruppo di output, l'operatore logico e i filtri condizionali.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/transform-conditional-router-tab.png)
1. Rinomina il nome del gruppo di output inserendo un nuovo nome per il gruppo. AWS Glue Studio assegnerà automaticamente un nome ai tuoi gruppi (ad esempio, "output\$1group\$11").
1. Scegli un operatore logico (**AND**, **OR**) e aggiungi una **condizione di filtro** specificando la **chiave**, l'**operazione** e il **valore**. Gli operatori logici consentono di implementare più di una condizione di filtro ed eseguire l'operatore logico su ogni condizione di filtro specificata.
Quando si specifica la chiave, è possibile scegliere tra le chiavi disponibili nello schema. È quindi possibile scegliere l'operazione disponibile in base al tipo di chiave selezionata. Ad esempio, se il tipo di chiave è "stringa", l'operazione disponibile tra cui scegliere è "corrispondenze".
![\[Lo screenshot mostra la scheda trasformazione router condizionale con i campi delle condizioni del filtro suddivisi per chiave, operazione e valore.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/transform-conditional-router-filter-condition.png)
1. Inserisci il valore nel campo **Valore**. Per aggiungere condizioni di filtro aggiuntive, scegli **Aggiungi condizione** . Per rimuovere condizioni di filtro, scegli l'icona del cestino.
# Utilizzo della trasformazione Concatena colonne per aggiungere colonne
La trasformazione Concatena consente di creare una nuova colonna di stringhe utilizzando i valori di altre colonne con un distanziatore opzionale. Ad esempio, se definiamo una colonna concatenata "data" come concatenazione di "anno", "mese" e "giorno" (in quest'ordine) con "-" come spaziatore, otterremmo:
| giorno | mese | anno | data |
| --- | --- | --- | --- |
| 01 | 01 | 2020 | 2020-01-01 |
| 02 | 01 | 2020 | 2020-01-02 |
| 03 | 01 | 2020 | 2020-01-03 |
| 04 | 01 | 2020 | 2020-01-04 |
**Per aggiungere una trasformazione Concatena:**
1. Aprire il pannello Risorse. Quindi, scegliere **Concatena colonne** per aggiungere una nuova trasformazione al diagramma di processo. Il nodo selezionato al momento dell'aggiunta del nodo ne sarà il nodo padre.
1. (Facoltativo) Nella scheda **Proprietà del nodo**, è possibile inserire un nome per il nodo nel diagramma del processo. Se non è già selezionato un nodo padre, scegliere un nodo dall'elenco Nodi padre da utilizzare come origine di input per la trasformazione.
1. Nella scheda **Trasforma**, inserire il nome della colonna che conterrà la stringa concatenata e le colonne da concatenare. L'ordine in cui si selezionano le colonne nel menu a discesa sarà l'ordine utilizzato.
![\[La schermata mostra la scheda Trasforma per la trasformazione Concatena.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/transforms-concatenate-transform-tab.png)
1. **Spaziatore - facoltativo**: inserire una stringa da inserire tra i campi concatenati. Per impostazione predefinita, non sono previsti spaziatori.
1. **Valore nullo - facoltativo**: inserire una stringa da utilizzare quando il valore di una colonna è nullo. Per impostazione predefinita, nei casi in cui le colonne hanno il valore “NULL” o “NA”, viene utilizzata una stringa vuota.
# Utilizzo della trasformazione Dividi stringa per suddividere una colonna di stringhe
La trasformazione Dividi stringa consente di suddividere una stringa in un array di token utilizzando un'espressione regolare per definire come viene eseguita la suddivisione. È quindi possibile mantenere la colonna come tipo array o applicare una trasformazione **Array a colonne** successivamente a questa per estrarre i valori dell'array in campi di primo livello, supponendo che ogni token abbia un significato che conosciamo in precedenza. Inoltre, se l'ordine dei token è irrilevante (ad esempio, un insieme di categorie), è possibile utilizzare la trasformazione **Espandi** per generare una riga separata per ogni valore.
Ad esempio, è possibile dividere una colonna "categories" utilizzando una virgola come modello per aggiungere una colonna "categories\$1arr".
| product\$1id | categorie | categories\$1arr |
| --- | --- | --- |
| 1 | sport,inverno | [sport, inverno] |
| 2 | giardino, attrezzi | [giardino, attrezzi] |
| 3 | videogiochi | [videogiochi] |
| 4 | gioco,gioco da tavolo,gioco di società | [gioco, gioco da tavolo, gioco di società] |
**Per aggiungere una trasformazione Dividi stringa:**
1. Apri il pannello Risorse, quindi scegli Dividi stringa per aggiungere una nuova trasformazione al diagramma di processo. Il nodo selezionato al momento dell'aggiunta del nodo ne sarà il nodo padre.
1. (Facoltativo) Nella scheda Proprietà del nodo, è possibile inserire un nome per il nodo nel diagramma del processo. Se non è già selezionato un nodo padre, scegliere un nodo dall'elenco Nodi padre da utilizzare come origine di input per la trasformazione.
1. Nella scheda **Trasforma**, scegli la colonna da dividere e inserisci il modello da utilizzare per dividere la stringa. Nella maggior parte dei casi puoi semplicemente inserire i caratteri, a meno che non abbiano un significato speciale come espressione regolare e debbano contenere caratteri di escape. I caratteri che richiedono escape sono `\.[]{}()<>*+-=!?^$|` e occorre aggiungere una barra rovesciata davanti al carattere. Ad esempio, se vuoi utilizzare un punto (".") come separatore, devi inserire `\.`. Tuttavia, la virgola non ha un significato speciale e può essere specificata così com'è: `,`.
![\[La schermata mostra la scheda Trasforma per la trasformazione Dividi stringa.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/transforms-split-string-transform-tab.png)
1. (Facoltativo) Se desideri mantenere la colonna di stringhe originale, puoi inserire un nome per una nuova colonna di array: potrai così mantenere sia la colonna di stringhe originale sia la nuova colonna di array tokenizzata.
# Utilizzo della trasformazione Array a colonne per estrarre gli elementi di un array in colonne di primo livello
La trasformazione Array a colonne consente di estrarre alcuni o tutti gli elementi di una colonna di tipo array in nuove colonne. La trasformazione riempirà le nuove colonne il più possibile se l'array ha un numero sufficiente di valori da estrarre, prendendo facoltativamente gli elementi nelle posizioni specificate.
Ad esempio, se hai una colonna di array "subnet", che è il risultato dell'applicazione della trasformazione "Dividi stringa" su una sottorete ip v4, puoi estrarre la prima e la quarta posizione nelle nuove colonne "first\$1octect" e "fourth\$1octect". L'output della trasformazione in questo esempio sarebbe il seguente; nota che le ultime due righe hanno array più corti del previsto:
| sottorete | first\$1octect | fourth\$1octect |
| --- | --- | --- |
| [54, 240, 197, 238] | 54 | 238 |
| [192, 168, 0, 1] | 192 | 1 |
| [192, 168] | 192 | |
| [] | | |
**Per aggiungere una trasformazione Array a colonne:**
1. Apri il pannello Risorse, quindi scegli **Array a colonne** per aggiungere una nuova trasformazione al diagramma del processo. Il nodo selezionato al momento dell'aggiunta del nodo ne sarà il nodo padre.
1. (Facoltativo) Nella scheda **Proprietà del nodo**, è possibile inserire un nome per il nodo nel diagramma del processo. Se non è già selezionato un nodo padre, scegliere un nodo dall'elenco Nodi padre da utilizzare come origine di input per la trasformazione.
1. Nella scheda **Trasforma**, scegli la colonna dell'array da estrarre e inserisci l'elenco delle nuove colonne per i token estratti.
![\[La schermata mostra la scheda Trasforma per la trasformazione Array a colonne.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/transforms-array-to-columns-transform-tab.png)
1. (Facoltativo) Se non vuoi prendere i token dell'array per assegnarli alle colonne, puoi specificare gli indici da prendere che verranno assegnati all'elenco di colonne nello stesso ordine specificato. Ad esempio, se le colonne di output sono "column1, column2, column3" e gli indici "4, 1, 3", il quarto elemento dell'array andrà alla column1, il primo alla column2 e il terzo alla column3 (se l'array è più corto del numero di indice, verrà impostato un valore NULL).
# Utilizzo della trasformazione Aggiungi timestamp corrente
La trasformazione **Aggiungi timestamp corrente** consente di contrassegnare le righe con l'ora in cui i dati sono stati elaborati. Ciò è utile per scopi di controllo o per tenere traccia della latenza nella pipeline di dati. È possibile aggiungere questa nuova colonna come tipo di dati timestamp o come stringa formattata.
**Per aggiungere una trasformazione Aggiungi timestamp corrente:**
1. Apri il pannello Risorse, quindi scegli **Aggiungi timestamp corrente** per aggiungere una nuova trasformazione al diagramma del processo. Il nodo selezionato al momento dell'aggiunta del nodo ne sarà il nodo padre.
1. (Facoltativo) Nella scheda **Proprietà del nodo**, è possibile inserire un nome per il nodo nel diagramma del processo. Se non è già selezionato un nodo padre, scegliere un nodo dall'elenco Nodi padre da utilizzare come origine di input per la trasformazione.
![\[La schermata mostra la scheda Trasforma per la trasformazione Aggiungi timestamp corrente.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/transforms-add-current-timestamp-transform-tab.png)
1. (Facoltativo) Nella scheda **Trasforma**, inserisci un nome personalizzato per la nuova colonna e un formato se preferisci che la colonna sia una stringa di data formattata.
# Utilizzo della trasformazione Pivot: righe a colonne
La trasformazione **Pivot: righe a colonne** consente di aggregare una colonna numerica ruotando valori univoci su colonne selezionate che diventano nuove colonne. Se sono selezionate più colonne, i valori vengono concatenati per denominare le nuove colonne. In questo modo, le righe vengono consolidate pur avendo più colonne con aggregazioni parziali per ogni valore univoco. Ad esempio, se disponi di questo set di dati sulle vendite per mese e paese (ordinato per facilitare la comprensione):
| anno | mese | paese | quantità |
| --- | --- | --- | --- |
| 2020 | Jan | uk | 32 |
| 2020 | Jan | de | 42 |
| 2020 | Jan | us | 64 |
| 2020 | Feb | uk | 67 |
| 2020 | Feb | de | 4 |
| 2020 | Feb | de | 7 |
| 2020 | Feb | us | 6 |
| 2020 | Feb | us | 12 |
| 2020 | Jan | us | 90 |
Se utilizzi **quantità** e **paese** come colonne di aggregazione, vengono create nuove colonne a partire dalla colonna **paese originale.** Nella tabella seguente sono presenti nuove colonne per **de**, **uk** e **us** anziché la colonna **paese**.
| anno | mese | de | uk | us |
| --- | --- | --- | --- | --- |
| 2020 | Jan | 42 | 32 | 64 |
| 2020 | Jan | 11 | 67 | 18 |
| 2021 | Jan | | | 90 |
Se invece vuoi eseguire il pivot sia sul mese sia sul paese, otterrai una colonna per ogni combinazione dei valori di tali colonne:
| anno | Jan\$1de | Jan\$1uk | Jan\$1us | Feb\$1de | Feb\$1uk | Feb\$1us |
| --- | --- | --- | --- | --- | --- | --- |
| 2020 | 42 | 32 | 64 | 11 | 67 | 18 |
| 2021 | | | 90 | | | |
**Per aggiungere una trasformazione Pivot: righe a colonne:**
1. Apri il pannello Risorse, quindi scegli **Pivot: righe a colonne** per aggiungere una nuova trasformazione al diagramma del processo. Il nodo selezionato al momento dell'aggiunta del nodo ne sarà il nodo padre.
1. (Facoltativo) Nella scheda **Proprietà del nodo**, è possibile inserire un nome per il nodo nel diagramma del processo. Se non è già selezionato un nodo padre, scegliere un nodo dall'elenco Nodi padre da utilizzare come origine di input per la trasformazione.
1. Nella scheda **Trasforma**, sceglie la colonna numerica che verrà aggregata per produrre i valori per le nuove colonne, la funzione di aggregazione da applicare e le colonne per convertire i valori univoci in nuove colonne.
![\[La schermata mostra la scheda Trasforma per la trasformazione Pivot: righe a colonne.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/transforms-pivot-rows-to-columns-transform-tab.png)
# Utilizzo della trasformazione Elimina pivot: colonne a righe
La trasformazione **Elimina pivot** consente di convertire le colonne in valori di nuove colonne generando una riga per ogni valore univoco. È l'opposto del pivot, ma tieni presente che non è equivalente, in quanto non può separare le righe con valori identici che sono state aggregate o suddividere le combinazioni nelle colonne originali. Per fare queste operazioni, puoi utilizzare in seguito una trasformazione Dividi. Ad esempio, in presenza della tabella seguente:
| anno | mese | de | uk | us |
| --- | --- | --- | --- | --- |
| 2020 | Jan | 42 | 32 | 64 |
| 2020 | Feb | 11 | 67 | 18 |
| 2021 | Jan | | | 90 |
È possibile eliminare il pivot dalle colonne "de", "uk" e "us" in una colonna "country" con il valore "amount" e ottenere quanto segue (ordinato qui a scopo illustrativo):
| anno | mese | paese | quantità |
| --- | --- | --- | --- |
| 2020 | Jan | uk | 32 |
| 2020 | Jan | de | 42 |
| 2020 | Jan | us | 64 |
| 2020 | Feb | uk | 67 |
| 2020 | Feb | de | 11 |
| 2020 | Feb | us | 18 |
| 2021 | Jan | us | 90 |
Nota che le colonne con un valore NULL ("de" e "uk" di gennaio 2021) non vengono generate per impostazione predefinita. È possibile abilitare questa opzione per ottenere:
| anno | mese | paese | quantità |
| --- | --- | --- | --- |
| 2020 | Jan | uk | 32 |
| 2020 | Jan | de | 42 |
| 2020 | Jan | us | 64 |
| 2020 | Feb | uk | 67 |
| 2020 | Feb | de | 11 |
| 2020 | Feb | us | 18 |
| 2021 | Jan | us | 90 |
| 2021 | Jan | de | |
| 2021 | Jan | uk | |
**Per aggiungere una trasformazione Elimina pivot: colonne a righe:**
1. Apri il pannello Risorse, quindi scegli **Elimina pivot: colonne a righe** per aggiungere una nuova trasformazione al diagramma del processo. Il nodo selezionato al momento dell'aggiunta del nodo ne sarà il nodo padre.
1. (Facoltativo) Nella scheda **Proprietà del nodo**, è possibile inserire un nome per il nodo nel diagramma del processo. Se non è già selezionato un nodo padre, scegliere un nodo dall'elenco Nodi padre da utilizzare come origine di input per la trasformazione.
1. Nella scheda **Trasforma**, inserisci le nuove colonne da creare per contenere i nomi e i valori delle colonne dalle quali intendi eliminare il pivot.
![\[La schermata mostra la scheda Trasforma per la trasformazione Elimina pivot: colonne a righe.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/transforms-unpivot-columns-to-rows-transform-tab.png)
# Utilizzo della trasformazione Bilancia automaticamente elaborazione per ottimizzare il runtime
La trasformazione **Bilancia automaticamente elaborazione** ridistribuisce i dati tra i worker per migliorare le prestazioni. Ciò è utile nei casi in cui i dati non sono bilanciati o, poiché provengono dall'origine, non consentono un'elaborazione parallela sufficiente. Questo è comune quando l'origine è compressa con gzip o è JDBC. La ridistribuzione dei dati ha un costo prestazionale modesto, quindi l'ottimizzazione potrebbe non sempre compensare tale sforzo se i dati fossero già ben bilanciati. A un livello più basso, la trasformazione utilizza la ripartizione Apache Spark per riassegnare in modo casuale i dati tra una serie di partizioni ottimali per la capacità del cluster. Per gli utenti esperti, è possibile inserire una serie di partizioni manualmente. Inoltre, può essere utilizzato per ottimizzare la scrittura di tabelle partizionate riorganizzando i dati in base a colonne specificate. Ciò si traduce in file di output più consolidati.
****
1. Apri il pannello Risorse, quindi scegli **Bilancia automaticamente elaborazione** per aggiungere una nuova trasformazione al diagramma di processo. Il nodo selezionato al momento dell'aggiunta del nodo ne sarà il nodo padre.
1. (Facoltativo) Nella scheda **Proprietà del nodo**, è possibile inserire un nome per il nodo nel diagramma del processo. Se non è già selezionato un nodo padre, scegliere un nodo dall'elenco Nodi padre da utilizzare come origine di input per la trasformazione.
1. (Facoltativo) Nella scheda **Trasforma** è possibile inserire un numero di partizioni. In generale, si consiglia di lasciare che sia il sistema a decidere questo valore, tuttavia è possibile regolare il moltiplicatore o inserire un valore specifico se è necessario controllarlo. Se intendi salvare i dati partizionati per colonne, puoi scegliere le stesse colonne come colonne di ripartizione. In questo modo ridurrà al minimo il numero di file su ciascuna partizione ed eviterà di avere molti file per partizione, il che ostacolerebbe le prestazioni degli strumenti che eseguono query su tali dati.
![\[La schermata mostra la scheda Trasforma per la trasformazione Bilancia automaticamente elaborazione.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/transforms-autobalance-processing-transform-tab.png)
# Utilizzo della trasformazione Colonna derivata per combinare altre colonne
La trasformazione **Colonna derivata** consente di definire una nuova colonna basata su una formula matematica o un'espressione SQL in cui è possibile utilizzare altre colonne nei dati, oltre a costanti e valori letterali. Ad esempio, per ricavare una colonna "percentage" dalle colonne "success" e "count", puoi inserire l'espressione SQL: "success \$1 100/count \$1\$1 '%'".
Risultato dell'esempio:
| success | count | percentage |
| --- | --- | --- |
| 14 | 100 | 14% |
| 6 | 20 | 3% |
| 3 | 40 | 7,5% |
**Per aggiungere una trasformazione Colonna derivata:**
1. Aprire il pannello Risorse, quindi scegliere **Colonna derivata** per aggiungere una nuova trasformazione al diagramma di processo. Il nodo selezionato al momento dell'aggiunta del nodo ne sarà il nodo padre.
1. (Facoltativo) Nella scheda **Proprietà del nodo**, è possibile inserire un nome per il nodo nel diagramma del processo. Se non è già selezionato un nodo padre, scegliere un nodo dall'elenco Nodi padre da utilizzare come origine di input per la trasformazione.
1. Nella scheda **Trasforma**, inserire il nome della colonna e l'espressione per il relativo contenuto.
![\[La schermata mostra la scheda Trasforma per la trasformazione Colonna derivata.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/transforms-dervied-column-transform-tab.png)
# Utilizzo della trasformazione Ricerca per aggiungere dati corrispondenti da una tabella di catalogo
La trasformazione **Ricerca** consente di aggiungere colonne da una tabella di catalogo definita quando le chiavi corrispondono alle colonne di ricerca definite nei dati. Ciò equivale a eseguire un join esterno sinistro tra i dati e la tabella di ricerca, utilizzando come condizioni le colonne corrispondenti.
**Per aggiungere una trasformazione Ricerca:**
1. Apri il pannello Risorse, quindi scegli **Ricerca** per aggiungere una nuova trasformazione al diagramma di processo. Il nodo selezionato al momento dell'aggiunta del nodo ne sarà il nodo padre.
1. (Facoltativo) Nella scheda **Proprietà del nodo**, è possibile inserire un nome per il nodo nel diagramma del processo. Se non è già selezionato un nodo padre, scegliere un nodo dall'elenco Nodi padre da utilizzare come origine di input per la trasformazione.
1. Nella scheda **Trasforma**, inserisci il nome completo della tabella di catalogo da utilizzare per eseguire le ricerche. Ad esempio, se il tuo database è "mydb" e la tua tabella "mytable", inserisci "mydb.mytable". Inserisci quindi i criteri per trovare una corrispondenza nella tabella di ricerca, se la chiave di ricerca è composta. Inserisci l'elenco delle colonne chiave separate da virgole. Se una o più colonne chiave non hanno lo stesso nome, devi definire la mappatura delle corrispondenze.
Ad esempio, se le colonne di dati sono "user\$1id" e "region" e nella tabella utenti le colonne corrispondenti sono denominate "id" e "region", nel campo **Colonne da abbinare**, inserisci: "user\$1id=id, region". Potresti anche utilizzare region=region, ma non è necessario poiché sono uguali.
1. Infine, inserisci le colonne da estrarre dalla riga corrispondente nella tabella di ricerca per incorporarle nei dati. Se non viene trovata alcuna corrispondenza, tali colonne verranno impostate su NULL.
**Nota**
Sotto la trasformazione **Ricerca**, viene utilizzato un join a sinistra a fini di efficienza. Se la tabella di ricerca ha una chiave primaria composita, assicurati di impostare le colonne di corrispondenza in modo che includano tutte le colonne che fanno parte di tale chiave, così da ottenere una sola corrispondenza. Altrimenti, più righe nella tabella di ricerca corrisponderanno, il che porterà ad aggiungere righe duplicate per ogni corrispondenza trovata.
![\[La schermata mostra la scheda Trasforma per la trasformazione Ricerca.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/transforms-lookup-transform-tab.png)
# Utilizzo della trasformazione Espandi array o mappa in righe
La trasformazione **Espandi** consente di estrarre valori da una struttura nidificata in singole righe più facili da manipolare. Nel caso di un array, la trasformazione genererà una riga per ogni valore dell'array, replicando i valori per le altre colonne della riga. Nel caso di una mappa, la trasformazione genererà una riga per ogni voce con la chiave e il valore come colonne più ogni altra colonna presente nella riga.
Ad esempio, se abbiamo questo set di dati che ha una colonna di array "categoria" con più valori.
| product\$1id | category |
| --- | --- |
| 1 | [sport, inverno] |
| 2 | [giardino, attrezzi] |
| 3 | [videogiochi] |
| 4 | [gioco, gioco da tavolo, gioco di società] |
| 5 | [] |
Se espandi la colonna "category" in una colonna con lo stesso nome, sovrascriverai la colonna. Puoi selezionare quello che desideri NULLs includere per ottenere quanto segue (ordinato a scopo illustrativo):
| product\$1id | category |
| --- | --- |
| 1 | sport |
| 1 | inverno |
| 2 | giardino |
| 2 | strumento |
| 3 | videogiochi |
| 4 | game |
| 4 | gioco da tavolo |
| 4 | gioco di società |
| 5 | |
**Per aggiungere una trasformazione Espandi array o mappa in righe:**
1. Apri il pannello Risorse, quindi scegli **Espandi array o mappa in righe** per aggiungere una nuova trasformazione al diagramma del processo. Il nodo selezionato al momento dell'aggiunta del nodo ne sarà il nodo padre.
1. (Facoltativo) Nella scheda **Proprietà del nodo**, è possibile inserire un nome per il nodo nel diagramma del processo. Se non è già selezionato un nodo padre, scegliere un nodo dall'elenco Nodi padre da utilizzare come origine di input per la trasformazione.
1. Nella scheda **Trasforma**, scegli la colonna da espandere (deve essere di tipo array o mappa). Quindi, specifica un nome per la colonna relativa agli elementi dell'array oppure i nomi delle colonne per chiavi e valori nel caso di espansione di una mappa.
1. (Facoltativo) Nella scheda **Trasforma**, per impostazione predefinita, se la colonna da espandere è NULL o ha una struttura vuota, verrà omessa nel set di dati espanso. Se vuoi mantenere la riga (con le nuove colonne come NULL), seleziona « NULLsIncludi».
![\[La schermata mostra la scheda Trasforma per la trasformazione Espandi array o mappa in righe.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/transforms-explode-array-transform-tab.png)
# Utilizzo della trasformazione Corrispondenza dei record per richiamare una trasformazione di classificazione dei dati esistente
Questa trasformazione richiama una trasformazione di classificazione dei dati di machine learning Corrispondenza dei record esistente.
La trasformazione valuta i dati correnti rispetto al modello addestrato sulla base di etichette. Viene aggiunta una colonna "match\$1id" per assegnare ogni riga a un gruppo di elementi considerati equivalenti in base all'addestramento dell'algoritmo. Per ulteriori informazioni, vedere [Record matching with Lake Formation FindMatches](https://docs.aws.amazon.com/glue/latest/dg/machine-learning.html).
**Nota**
La versione di AWS Glue utilizzata dal visual job deve corrispondere alla versione AWS Glue utilizzata per creare la trasformazione Record Matching.
![\[La schermata mostra l'anteprima dei dati per la trasformazione.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/recording-matching-transform-1.png)
**Aggiunta di un nodo di trasformazione Corrispondenza dei record al diagramma di processo**
1. Apri il pannello Risorse, quindi scegli **Corrispondenza dei record** per aggiungere una nuova trasformazione al diagramma del processo. Il nodo selezionato al momento dell'aggiunta del nodo ne sarà il nodo padre.
1. Nel pannello Proprietà del nodo, è possibile assegnare al nodo un nome nel diagramma del processo. Se non è già selezionato un nodo padre, scegli un nodo dall'elenco **Node parents** (Nodi padre) da utilizzare come origine di input per la trasformazione.
1. Nella scheda **Trasforma**, inserisci l'ID ottenuto dalla pagina delle **Trasformazioni di Machine learning**:
![\[La schermata mostra l'ID della pagina delle trasformazioni di Machine learning.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/recording-matching-transform-2.png)
1. (Facoltativo) Nella scheda **Trasforma**, puoi selezionare l'opzione per aggiungere i punteggi di affidabilità. Al costo di un calcolo aggiuntivo, il modello stimerà un punteggio di affidabilità per ogni corrispondenza sotto forma di colonna aggiuntiva.
# Rimozione di righe nulle
Questa trasformazione rimuove dal set di dati le righe che hanno tutte le colonne come nulle. Inoltre, è possibile estendere questi criteri per includere anche i campi vuoti, in modo da mantenere le righe in cui almeno una colonna non è vuota.
**Aggiunta di un nodo di trasformazione Rimuovi righe nulle al diagramma di processo**
1. Apri il pannello Risorse, quindi scegli **Rimuovi righe nulle** per aggiungere una nuova trasformazione al diagramma del processo. Il nodo selezionato al momento dell'aggiunta del nodo ne sarà il nodo padre.
1. Nel pannello Proprietà del nodo, è possibile assegnare al nodo un nome nel diagramma del processo. Se non è già selezionato un nodo padre, scegli un nodo dall'elenco **Node parents** (Nodi padre) da utilizzare come origine di input per la trasformazione.
1. (Facoltativo) Nella scheda **Trasforma**, seleziona l'opzione **Estesa** se desideri che le righe siano, oltre che non nulle, anche non vuote; in questo modo le stringhe, gli array o le mappe vuote verranno considerati nulli ai fini di questa trasformazione.
# Analisi di una colonna di stringhe contenente dati JSON
Questa trasformazione analizza una colonna di stringhe contenente dati JSON e la converte in una struttura o in una colonna di array, a seconda che il JSON sia rispettivamente un oggetto o un array. Facoltativamente, puoi mantenere sia la colonna analizzata sia quella originale.
Lo schema JSON può essere fornito o dedotto (nel caso di oggetti JSON), con campionamento opzionale.
**Aggiunta di un nodo di trasformazione Analizza colonna JSON al diagramma di processo**
1. Apri il pannello Risorse, quindi scegli **Analizza colonna JSON** per aggiungere una nuova trasformazione al diagramma del processo. Il nodo selezionato al momento dell'aggiunta del nodo ne sarà il nodo padre.
1. Nel pannello Proprietà del nodo, è possibile assegnare al nodo un nome nel diagramma del processo. Se non è già selezionato un nodo padre, scegli un nodo dall'elenco **Node parents** (Nodi padre) da utilizzare come origine di input per la trasformazione.
1. Nella scheda **Trasforma**, seleziona la colonna contenente la stringa JSON.
1. (Facoltativo) Nella scheda **Trasforma**, inserisci lo schema seguito dai dati JSON utilizzando la sintassi SQL, ad esempio "field1 STRING, field2 INT" nel caso di un oggetto oppure "ARRAY" nel caso di un array.
Nel caso di un array, lo schema è richiesto, ma nel caso di un oggetto, se lo schema non è specificato, verrà dedotto utilizzando i dati. Per ridurre l'impatto dell'inferenza dello schema, specialmente su un set di dati di grandi dimensioni, puoi evitare di leggere l'intero dato due volte inserendo un **Rapporto di campioni da utilizzare per dedurre lo schema**. Se il valore è inferiore a 1, viene utilizzato il rapporto corrispondente di campioni casuali per dedurre lo schema. Se i dati sono affidabili e l'oggetto è coerente tra le righe, è possibile utilizzare un rapporto ridotto, ad esempio 0,1, per migliorare le prestazioni.
1. (Facoltativo) Nella scheda **Trasforma**, puoi inserire un nuovo nome di colonna se desideri mantenere sia la colonna di stringa originale sia la colonna analizzata.
# Estrazione di un percorso JSON
Questa trasformazione estrae nuove colonne da una colonna di stringhe JSON. Questa trasformazione è utile quando sono necessari solo pochi elementi di dati e non si desidera importare l'intero contenuto JSON nello schema della tabella.
**Aggiunta di un nodo di trasformazione Estrai percorso JSON nel diagramma di processo**
1. Apri il pannello Risorse, quindi scegli **Estrai percorso JSON** per aggiungere una nuova trasformazione al diagramma del processo. Il nodo selezionato al momento dell'aggiunta del nodo ne sarà il nodo padre.
1. Nel pannello Proprietà del nodo, è possibile assegnare al nodo un nome nel diagramma del processo. Se non è già selezionato un nodo padre, scegli un nodo dall'elenco **Node parents** (Nodi padre) da utilizzare come origine di input per la trasformazione.
1. Nella scheda **Trasforma**, seleziona la colonna contenente la stringa JSON. Inserisci una o più espressioni di percorso JSON separate da virgole, ognuna delle quali fa riferimento a come estrarre un valore dall'array o dall'oggetto JSON. Ad esempio, se la colonna JSON contenesse oggetti con le proprietà "prop\$11" e "prop2", puoi estrarli entrambi specificando i nomi "prop\$11, prop\$12".
Se il campo JSON contiene caratteri speciali, ad esempio per estrarre da questo JSON la proprietà `{"a. a": 1}`, puoi utilizzare il percorso `$['a. a']`. L'eccezione è la virgola perché è riservata a percorsi separati. Inserisci quindi i nomi di colonna corrispondenti per ogni percorso, separati da virgole.
1. (Facoltativo) Nella scheda **Trasforma**, puoi selezionare di eliminare la colonna JSON una volta estratta. Ciò ha senso quando non hai bisogno del resto dei dati JSON dopo aver estratto le parti necessarie.
# Estrazione di frammenti di stringa utilizzando un'espressione regolare
Questa trasformazione estrae frammenti di stringa utilizzando un'espressione regolare e crea a partire da essa una nuova colonna o anche più colonne, se si utilizzano gruppi di regex.
**Aggiunta di un nodo di trasformazione Estrattore regex al diagramma di processo**
1. Apri il pannello Risorse, quindi scegli **Estrattore regex** per aggiungere una nuova trasformazione al diagramma del processo. Il nodo selezionato al momento dell'aggiunta del nodo ne sarà il nodo padre.
1. Nel pannello Proprietà del nodo, è possibile assegnare al nodo un nome nel diagramma del processo. Se non è già selezionato un nodo padre, scegli un nodo dall'elenco **Node parents** (Nodi padre) da utilizzare come origine di input per la trasformazione.
1. Nella scheda **Trasforma**, inserisci l'espressione regolare e la colonna alla quale deve essere applicata. Quindi inserisci il nome della nuova colonna in cui archiviare la stringa corrispondente. La nuova colonna sarà nulla solo se la colonna di origine è nulla, mentre se l'espressione regolare non corrisponde la colonna sarà vuota.
Se l'espressione regolare utilizza gruppi, esiste un nome di colonna corrispondente separato da una virgola, ma è possibile saltare i gruppi lasciando vuoto il nome della colonna.
Ad esempio, poniamo che tu abbia una colonna "purchase\$1date" con una stringa che utilizza formati di data ISO lunghi e brevi e voglia estrarre l'anno, il mese, il giorno e l'ora, se disponibili. Nota che il gruppo delle ore è facoltativo, altrimenti, nelle righe in cui non è disponibile, tutti i gruppi estratti sarebbero stringhe vuote perché l'espressione regolare non corrisponde. In questo caso, non vogliamo che il gruppo renda facoltativo l'orario ma quello interno, quindi lasciamo il nome vuoto ed esso non verrà estratto (il gruppo includerebbe il carattere T).
![\[La schermata mostra la configurazione di un'espressione regolare per l'estrattore regex.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/regex-extractor-1.png)
Risultato dell'anteprima dei dati:
![\[La schermata mostra la configurazione di un'anteprima dei dati per l'estrattore regex.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/regex-extractor-2.png)
# Creazione di una trasformazione personalizzata
Se devi eseguire trasformazioni più complicate sui dati o se vuoi aggiungere chiavi di proprietà dei dati al set di dati, puoi aggiungere una trasformazione **Custom code** al diagramma di processo. Il nodo Custom code permette di immettere uno script che esegue la trasformazione.
Quando si utilizza il codice personalizzato, è necessario utilizzare un editor di schemi per indicare le modifiche apportate all'output tramite il codice personalizzato. Quando modifichi lo schema, puoi eseguire le seguenti operazioni:
+ Aggiungere o rimuovere chiavi di proprietà dei dati
+ Modificare il tipo di dati delle chiavi di proprietà dei dati
+ Modificare il nome delle chiavi di proprietà dei dati.
+ Ristrutturare una chiave di proprietà nidificata
È necessario utilizzare una *SelectFromCollection*trasformazione per sceglierne una `DynamicFrame` dal risultato del nodo di trasformazione personalizzata prima di poter inviare l'output a una posizione di destinazione.
Usa i processi seguenti per aggiungere un nodo di trasformazione personalizzato al diagramma di processo.
## Aggiunta di un nodo di trasformazione di codice personalizzato al diagramma di processo
**Per aggiungere un nodo di trasformazione personalizzato al diagramma di processo**
1. (Facoltativo) Apri il pannello Risorse, quindi scegli **Trasformazione personalizzata** per aggiungere una nuova trasformazione al diagramma del processo.
1. Nella scheda **Node properties** (Proprietà del nodo), inserisci un nome per il nodo nel diagramma del processo. Se non è già selezionato un nodo padre, o se desideri più input per la trasformazione personalizzata, scegli un nodo dall'elenco **Node parents** (Nodi padre) da utilizzare come origine di input per la trasformazione.
## Immissione del codice per il nodo di trasformazione personalizzato
Puoi digitare o copiare il codice in un campo di input. Il processo utilizza questo codice per eseguire la trasformazione dei dati. Puoi fornire un frammento di codice in Python o Scala. Il codice richiede uno o più `DynamicFrames` come input e restituisce una raccolta di `DynamicFrames`.
**Per inserire lo script per un nodo di trasformazione personalizzato**
1. Con il nodo di trasformazione personalizzato selezionato nel diagramma di processo, scegli la casella **Transform** (Trasformazione).
1. Nel campo di immissione testo sotto l'intestazione **Code block** (Blocco di codice), incolla o immetti il codice per la trasformazione. Il codice utilizzato deve corrispondere al linguaggio specificato per il processo nella scheda **Job details** (Dettagli del processo).
Quando si fa riferimento ai nodi di input nel codice, AWS Glue Studio assegna un nome ai `DynamicFrames` restituiti dai nodi del diagramma del processo in modo sequenziale in base all'ordine di creazione. Utilizza uno dei seguenti metodi di denominazione nel codice:
+ Generazione di codice classico: utilizza i nomi funzionali per fare riferimento ai nodi nel diagramma del processo.
+ Nodi di origine dati: `DataSource0`, `DataSource1`, `DataSource2` e così via.
+ Nodi di trasformazione : `Transform0`, `Transform1`, `Transform2` e così via.
+ Nuova generazione di codice: utilizza il nome specificato nella scheda **Node properties** (Proprietà del nodo) di un nodo, aggiunta con "`_node1`","`_node2`" e così via. Ad esempio, `S3bucket_node1`, `ApplyMapping_node2`, `S3bucket_node2`, `MyCustomNodeName_node1`.
Per ulteriori informazioni sul nuovo generatore di codice, consulta [Generazione di codice dello script](job-editor-features.md#code-gen).
Gli esempi seguenti mostrano il formato del codice da inserire nella casella del codice:
------
#### [ Python ]
L'esempio seguente prende il primo `DynamicFrame` ricevuto, lo converte in un `DataFrame` per applicare il metodo di filtro nativo (conservando solo i registri che hanno più di 1000 voti), quindi prima di restituirlo lo converte di nuovo in un `DynamicFrame`.
```
def FilterHighVoteCounts (glueContext, dfc) -> DynamicFrameCollection:
df = dfc.select(list(dfc.keys())[0]).toDF()
df_filtered = df.filter(df["vote_count"] > 1000)
dyf_filtered = DynamicFrame.fromDF(df_filtered, glueContext, "filter_votes")
return(DynamicFrameCollection({"CustomTransform0": dyf_filtered}, glueContext))
```
------
#### [ Scala ]
L'esempio seguente prende il primo `DynamicFrame` ricevuto, lo converte in un `DataFrame` per applicare il metodo di filtro nativo (conservando solo i registri che hanno più di 1000 voti), quindi prima di restituirlo lo converte di nuovo in un `DynamicFrame`.
```
object FilterHighVoteCounts {
def execute(glueContext : GlueContext, input : Seq[DynamicFrame]) : Seq[DynamicFrame] = {
val frame = input(0).toDF()
val filtered = DynamicFrame(frame.filter(frame("vote_count") > 1000), glueContext)
Seq(filtered)
}
}
```
------
## Modifica dello schema in un nodo di trasformazione personalizzato
Quando si utilizza un nodo di trasformazione personalizzato, AWS Glue Studio non può dedurre automaticamente gli schemi di output creati dalla trasformazione. Devi utilizzare l'editor dello schema per descrivere le modifiche allo schema implementate dal codice di trasformazione personalizzato.
Un nodo di codice personalizzato può avere un numero qualsiasi di nodi padre, ognuno dei quali fornisce un `DynamicFrame` come input per il codice personalizzato. Un nodo di codice personalizzato restituisce una raccolta di `DynamicFrames`. Ogni `DynamicFrame` utilizzato come input ha uno schema associato. È necessario aggiungere uno schema che descriva ogni `DynamicFrame` restituito dal nodo di codice personalizzato.
**Nota**
Quando imposti il tuo schema su una trasformazione personalizzata, AWS Glue Studio non eredita schemi dai nodi precedenti. Per aggiornare lo schema, seleziona il nodo di trasformazione personalizzata, quindi sceglie la scheda Data preview (anteprima dati. Una volta generata l'anteprima, scegli “Use Preview Schema” (usa schema di anteprima). Lo schema verrà quindi sostituito dallo schema utilizzando i dati di anteprima.
**Per modificare gli schemi per un nodo di trasformazione personalizzato**
1. Con il nodo di trasformazione personalizzato selezionato nel diagramma di processo, scegli la scheda **Output schema** (Schema di output) nel pannello dei dettagli del nodo.
1. Scegli **Edit** (Modifica) per apportare modifiche allo schema.
Se disponi di chiavi di proprietà dei dati nidificate, ad esempio una matrice o un oggetto, puoi scegliere l'icona **Expand-Rows** (Espandi righe) (![\[\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/expand-rows-icon.png)) in alto a destra di ogni pannello dello schema per espandere l'elenco delle chiavi di proprietà dei dati figlio. Dopo aver selezionato l'icona, questa si trasforma nell'icona **Collapse-Rows** (Comprimi righe) (![\[\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/collapse-rows-icon.png)), che puoi selezionare per comprimere l'elenco delle chiavi di proprietà figlio.
1. Modifica lo schema utilizzando le seguenti operazioni nella sezione a destra della pagina:
+ Per rinominare una chiave di proprietà, posiziona il cursore nella casella di testo **Key** (Chiave) per la chiave di proprietà, quindi immetti il nuovo nome.
+ Per modificare il tipo di dati per una chiave di proprietà dei dati, usa l'elenco per scegliere il nuovo tipo di dati per la chiave di proprietà.
+ Per aggiungere una nuova chiave di proprietà di livello superiore allo schema, scegli l'opzione **Overflow** (![\[\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/edit-schema-actions-button.png)) sulla sinistra del pulsante **Cancel** (Annulla), quindi scegli **Add root key** (Aggiungi chiave root).
+ Per aggiungere una chiave di proprietà figlio allo schema, scegli l'icona **Add-Key** (Aggiungi chiave) ![\[\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/filter-add-icon.png) associata alla chiave padre. Inserisci un nome per la chiave figlio e scegli il tipo di dati.
+ Per rimuovere una colonna dallo schema, scegli l'icona **Remove** (Elimina) (![\[\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/delete-icon-black.png)) all'estrema destra del nome della chiave.
1. Se il codice di trasformazione personalizzato utilizza più `DynamicFrames`, è possibile aggiungere schemi di output aggiuntivi.
+ Per aggiungere un nuovo schema vuoto, scegli l'icona **Overflow** (![\[\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/edit-schema-actions-button.png)), quindi scegli **Add output schema** (Aggiungi schema di output).
+ Per copiare uno schema esistente in un nuovo schema di output, assicurati che lo schema da copiare sia visualizzato nel selettore dello schema. Seleziona l'icona **Overflow** (![\[\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/edit-schema-actions-button.png)), quindi scegli **Duplicate** (Duplica).
Se vuoi rimuovere uno schema di output, assicurati che lo schema da copiare sia visualizzato nel selettore dello schema. Seleziona l'icona **Overflow** (![\[\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/edit-schema-actions-button.png)), quindi scegli **Delete** (Elimina).
1. Aggiungi nuove chiavi radice al nuovo schema o modifica le chiavi duplicate.
1. Quando modifichi gli lo schemi di output, scegli il pulsante **Apply** (Applica) per salvare le modifiche e uscire dall'editor dello schema.
Se non vuoi salvare le modifiche, seleziona il pulsante **Cancel** (Annulla).
## Configurare l'output della trasformazione personalizzata
Una trasformazione di codice personalizzata restituisce una raccolta di `DynamicFrames`, anche se nel set di risultati è presente solo un `DynamicFrame`.
**Per elaborare l'output da un nodo di trasformazione personalizzato**
1. Aggiungi un nodo di *SelectFromCollection*trasformazione, che ha il nodo di trasformazione personalizzato come nodo principale. Aggiorna questa trasformazione per indicare il set di dati da utilizzare. Per ulteriori informazioni, consulta [Utilizzo SelectFromCollection per scegliere quale set di dati conservare](transforms-configure-select-collection.md).
1. Aggiungi *SelectFromCollection*trasformazioni aggiuntive al diagramma del lavoro se desideri utilizzarne altre `DynamicFrames` prodotte dal nodo di trasformazione personalizzato.
Consideriamo uno scenario in cui aggiungi un nodo di trasformazione personalizzato per dividere un set di dati di volo in più set di dati, ma duplichi alcune delle chiavi di proprietà identificative in ciascuno schema di output, ad esempio la data di volo o il numero di volo. Si aggiunge un nodo di *SelectFromCollection*trasformazione per ogni schema di output, con il nodo di trasformazione personalizzato come elemento principale.
1. (Facoltativo) È quindi possibile utilizzare ogni nodo di *SelectFromCollection*trasformazione come input per altri nodi del processo o come genitore per un nodo di destinazione dei dati.