Amazon Redshift non supporterà più la creazione di nuovi Python UDFs a partire dalla Patch 198. Python esistente UDFs continuerà a funzionare fino al 30 giugno 2026. Per ulteriori informazioni, consulta il [post del blog](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/). 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à. # Tutorial: Esecuzione di query su dati nidificati con Amazon Redshift Spectrum In questo tutorial viene dimostrato come eseguire query sui dati annidati con Redshift Spectrum. I dati annidati sono dati che contengono campi annidati. I campi annidati sono campi di cui è stato effettuato il join come un’unica entità, quali array, strutture oppure oggetti. **Topics** + [Panoramica di](#tutorial-nested-data-overview) + [Fase 1: creazione di una tabella esterna contenente dati nidificati](#tutorial-nested-data-create-table) + [Fase 2: Esecuzione di query sui dati nidificati in Amazon S3 con estensioni SQL](#tutorial-query-nested-data-sqlextensions) + [Casi d'uso dei dati nidificati](nested-data-use-cases.md) + [Limitazioni relative ai dati annidati (anteprima)](nested-data-restrictions.md) + [Serializzazione di JSON nidificato complesso](serializing-complex-JSON.md) ## Panoramica di Amazon Redshift Spectrum supporta l'esecuzione di query di dati nidificati nei formati di file Parquet, ORC, JSON e Ion. Redshift Spectrum accede ai dati mediante tabelle esterne. Puoi creare tabelle esterne che utilizzano i tipi di dati complessi `struct`, `array` e `map`. Ad esempio, si supponga che il file di dati contenga i seguenti dati in Amazon S3 all'interno di una cartella denominata `customers`. Anche se non è presente un singolo elemento root, ciascun oggetto JSON in questi dati di esempio rappresenta una riga in una tabella. ``` {"id": 1, "name": {"given": "John", "family": "Smith"}, "phones": ["123-457789"], "orders": [{"shipdate": "2018-03-01T11:59:59.000Z", "price": 100.50}, {"shipdate": "2018-03-01T09:10:00.000Z", "price": 99.12}] } {"id": 2, "name": {"given": "Jenny", "family": "Doe"}, "phones": ["858-8675309", "415-9876543"], "orders": [] } {"id": 3, "name": {"given": "Andy", "family": "Jones"}, "phones": [], "orders": [{"shipdate": "2018-03-02T08:02:15.000Z", "price": 13.50}] } ``` Puoi utilizzare Amazon Redshift Spectrum per eseguire query sui dati nidificati nei file. Il seguente tutorial illustra la procedura da seguire con i dati Apache Parquet. ### Prerequisiti Se ancora non utilizzi Redshift Spectrum, segui la procedura in [Nozioni di base su Amazon Redshift Spectrum](c-getting-started-using-spectrum.md) prima di continuare. Per creare uno schema esterno, sostituire l'ARN del ruolo IAM nel comando seguente con l'ARN del ruolo creato in [Creazione di un ruolo IAM](c-getting-started-using-spectrum.md#c-getting-started-using-spectrum-create-role). Quindi eseguire il comando nel proprio client SQL. ``` create external schema spectrum from data catalog database 'myspectrum_db' iam_role 'arn:aws:iam::123456789012:role/myspectrum_role' create external database if not exists; ``` ## Fase 1: creazione di una tabella esterna contenente dati nidificati È possibile visualizzare i [dati di origine](https://s3.amazonaws.com/redshift-downloads/tickit/spectrum/customers/customer_file1) scaricandoli da Amazon S3. Per creare la tabella esterna per questo tutorial, utilizza il comando seguente. ``` CREATE EXTERNAL TABLE spectrum.customers ( id int, name struct, phones array, orders array> ) STORED AS PARQUET LOCATION 's3://redshift-downloads/tickit/spectrum/customers/'; ``` Nell'esempio precedente, la tabella esterna `spectrum.customers` utilizza i tipi di dati `struct` e `array` per definire colonne con dati nidificati. Amazon Redshift Spectrum supporta l'esecuzione di query di dati nidificati nei formati di file Parquet, ORC, JSON e Ion. Il parametro `STORED AS` è `PARQUET` per i file Apache Parquet. Il parametro `LOCATION` deve fare riferimento alla cartella Amazon S3 che contiene i file o i dati nidificati. Per ulteriori informazioni, consulta [CREATE EXTERNAL TABLE](r_CREATE_EXTERNAL_TABLE.md). Puoi nidificare tipi `array` e `struct` a qualsiasi livello. Ad esempio, puoi definire una colonna denominata `toparray` come mostrato nell'esempio seguente. ``` toparray array>>>> ``` Puoi inoltre nidificare tipi `struct` come mostrato per la colonna `x` nell'esempio seguente. ``` x struct > > ``` ## Fase 2: Esecuzione di query sui dati nidificati in Amazon S3 con estensioni SQL Redshift Spectrum supporta l'esecuzione di query su tipi complessi `array`, `map` e `struct` mediante estensioni alla sintassi SQL di Amazon Redshift. ### Estensione 1: accesso a colonne di struct Puoi estrarre dati da colonne `struct` utilizzando una notazione punto che concatena i nomi dei campi in percorsi. Ad esempio, la query seguente restituisce il nome e il cognome dei clienti. L'accesso al nome viene eseguito dal percorso lungo `c.name.given`. L'accesso al cognome viene eseguito dal percorso lungo `c.name.family`. ``` SELECT c.id, c.name.given, c.name.family FROM spectrum.customers c; ``` La query precedente restituisce i seguenti dati. ``` id | given | family ---|-------|------- 1 | John | Smith 2 | Jenny | Doe 3 | Andy | Jones (3 rows) ``` Uno `struct` può essere una colonna di un altro `struct`, che a sua volta può essere una colonna di un altro `struct`, a qualsiasi livello. I percorsi di accesso alle colonne in `struct` nidificati in modo così profondo possono essere lunghi. Ad esempio, consultare la definizione relativa alla colonna `x` nell'esempio seguente. ``` x struct > > ``` Puoi accedere ai dati in `e` come `x.b.d.e`. ### Estensione 2: matrici estese a una clausola FROM Puoi estrarre dati da colonne `array` (e, per estensione, da colonne `map`) specificando le colonne `array` in una clausola `FROM` al posto dei nomi delle tabelle. L'estensione si applica alla clausola `FROM` della query principale e, inoltre, alle clausole `FROM` delle query secondarie. Puoi fare riferimento a elementi `array` in base alla posizione, ad esempio `c.orders[0]` (anteprima). Combinando `arrays` estese e join, puoi annullare annidamenti in vari modi, come illustrato nei seguenti casi d'uso. #### Annullamento di annidamenti mediante inner join La seguente query seleziona le date di spedizione del cliente IDs e dell'ordine per i clienti che hanno ordini. L'estensione SQL nella clausola FROM `c.orders o` dipende dall'alias `c`. ``` SELECT c.id, o.shipdate FROM spectrum.customers c, c.orders o ``` Per ciascun cliente `c` associato a degli ordini, la clausola `FROM` restituisce una riga per ogni ordine `o` del cliente `c`. La riga in questione combina la riga del cliente `c` e quella dell'ordine `o`. In seguito, la clausola `SELECT` mantiene solo `c.id` e `o.shipdate`. Il risultato è il seguente. ``` id| shipdate --|---------------------- 1 |2018-03-01 11:59:59 1 |2018-03-01 09:10:00 3 |2018-03-02 08:02:15 (3 rows) ``` L'alias `c` fornisce l'accesso ai campi dei clienti, mentre l'alias `o` consente l'accesso ai campi degli ordini. La semantica è simile a quella di SQL standard. È possibile pensare a un processo in cui la clausola `FROM` esegue il loop nidificato mostrato sotto, mentre `SELECT` sceglie i campi da restituire. ``` for each customer c in spectrum.customers for each order o in c.orders output c.id and o.shipdate ``` Pertanto, se un cliente non è associato ad alcun ordine, non verrà mostrato tra i risultati. Puoi pensare anche a un processo in cui la clausola `FROM` esegue un `JOIN` con la tabella `customers` e la matrice `orders`. In effetti, puoi anche scrivere la query, come mostrato nell'esempio seguente. ``` SELECT c.id, o.shipdate FROM spectrum.customers c INNER JOIN c.orders o ON true ``` **Nota** Se è presente uno schema denominato `c` con una tabella chiamata `orders`, allora `c.orders` fa riferimento alla tabella `orders` e non alla colonna della matrice di `customers`. #### Annullamento di annidamenti mediante left join La query seguente restituisce tutti i nomi dei clienti e i loro ordini. Se un cliente non ha effettuato alcun ordine, il suo nome viene comunque restituito. Tuttavia, in questo caso, l'ordine presenta colonne NULL, come mostrato nell'esempio seguente per Jenny Doe. ``` SELECT c.id, c.name.given, c.name.family, o.shipdate, o.price FROM spectrum.customers c LEFT JOIN c.orders o ON true ``` La query precedente restituisce i seguenti dati. ``` id | given | family | shipdate | price ----|---------|---------|----------------------|-------- 1 | John | Smith | 2018-03-01 11:59:59 | 100.5 1 | John | Smith | 2018-03-01 09:10:00 | 99.12 2 | Jenny | Doe | | 3 | Andy | Jones | 2018-03-02 08:02:15 | 13.5 (4 rows) ``` ### Estensione 3: accesso diretto a una matrice di scalari tramite un alias Quando un alias `p` in una clausola `FROM` si estende a una matrice di scalari, la query fa riferimento ai valori di `p` come `p`. Ad esempio, la query seguente genera coppie di nomi e numeri di telefono dei clienti. ``` SELECT c.name.given, c.name.family, p AS phone FROM spectrum.customers c LEFT JOIN c.phones p ON true ``` La query precedente restituisce i seguenti dati. ``` given | family | phone -------|----------|----------- John | Smith | 123-4577891 Jenny | Doe | 858-8675309 Jenny | Doe | 415-9876543 Andy | Jones | (4 rows) ``` ### Estensione 4: accesso agli elementi del tipo di dati map Redshift Spectrum tratta `map` come un tipo di dati `array` che contiene tipi `struct` con una colonna `key` e una colonna `value`. `key` deve essere uno `scalar`; il valore può essere qualunque tipo di dati. Ad esempio, il codice seguente crea una tabella esterna con un tipo `map` per l'archiviazione dei numeri di telefono. ``` CREATE EXTERNAL TABLE spectrum.customers2 ( id int, name struct, phones map, orders array> ) STORED AS PARQUET LOCATION 's3://redshift-downloads/tickit/spectrum/customers/'; ``` Dal momento che un tipo `map` si comporta come un tipo `array` con colonne `key` e `value`, puoi pensare agli schemi precedenti come a quelli riportati di seguito. ``` CREATE EXTERNAL TABLE spectrum.customers3 ( id int, name struct, phones array>, orders array> ) STORED AS PARQUET LOCATION 's3://redshift-downloads/tickit/spectrum/customers/'; ``` La query seguente restituisce i nomi dei clienti con un numero di cellulare e il numero per ciascun nome. La query sul tipo map viene considerata equivalente a una query su un `array` nidificato di tipi `struct`. La query seguente restituisce dati solo se hai creato la tabella esterna come descritto in precedenza. ``` SELECT c.name.given, c.name.family, p.value FROM spectrum.customers c, c.phones p WHERE p.key = 'mobile'; ``` **Nota** La `key` per un tipo `map` è una `string` per i tipi di file Ion e JSON. # Casi d'uso dei dati nidificati In questo argomento vengono illustrati i casi d’uso per i dati annidati. I dati annidati sono dati che contengono campi annidati. I campi annidati sono campi di cui è stato effettuato il join come un’unica entità, quali array, strutture oppure oggetti. Puoi combinare le estensioni descritte in precedenza con le consuete caratteristiche di SQL. I casi d'uso seguenti presentano alcune combinazioni comuni. Questi esempi offrono una dimostrazione dell'utilizzo dei dati nidificati. Non fanno parte del tutorial. **Topics** + [Inserimento di dati nidificati](#ingesting-nested-data) + [Aggregazione di dati nidificati con query secondarie](#aggregating-with-subquery) + [Unione dei dati di Amazon Redshift e dei dati nidificati](#joining-redshift-data) ## Inserimento di dati nidificati Puoi utilizzare l'istruzione `CREATE TABLE AS` per inserire dati da una tabella esterna contenente tipi di dati complessi. La query seguente estrae tutti i clienti e i relativi numeri di telefono dalla tabella esterna mediante `LEFT JOIN` e li archivia nella tabella `CustomerPhones` di Amazon Redshift. ``` CREATE TABLE CustomerPhones AS SELECT c.name.given, c.name.family, p AS phone FROM spectrum.customers c LEFT JOIN c.phones p ON true; ``` ## Aggregazione di dati nidificati con query secondarie Puoi utilizzare una query secondaria per aggregare dati nidificati. Questo approccio viene descritto nell'esempio seguente. ``` SELECT c.name.given, c.name.family, (SELECT COUNT(*) FROM c.orders o) AS ordercount FROM spectrum.customers c; ``` Vengono restituiti i seguenti dati. ``` given | family | ordercount --------|----------|-------------- Jenny | Doe | 0 John | Smith | 2 Andy | Jones | 1 (3 rows) ``` **Nota** Quando aggreghi dati nidificati raggruppandoli in base alla riga padre, il modo più efficiente di procedere è quello illustrato nell'esempio precedente. Nell'esempio in questione, le righe nidificate di `c.orders` sono raggruppate in base alla riga padre `c`. In alternativa, se sai che l'`id` è univoco per ciascun `customer` e `o.shipdate` non è mai null, puoi eseguire l'aggregazione come illustrato nell'esempio seguente. Tuttavia, in genere questo approccio è meno efficiente rispetto a quello dell'esempio precedente. ``` SELECT c.name.given, c.name.family, COUNT(o.shipdate) AS ordercount FROM spectrum.customers c LEFT JOIN c.orders o ON true GROUP BY c.id, c.name.given, c.name.family; ``` Puoi inoltre scrivere la query utilizzando una query secondaria nella clausola `FROM` che fa riferimento a un alias (`c`) della query con predecessore e che estrae i dati della matrice. L'esempio seguente mostra questo approccio. ``` SELECT c.name.given, c.name.family, s.count AS ordercount FROM spectrum.customers c, (SELECT count(*) AS count FROM c.orders o) s; ``` ## Unione dei dati di Amazon Redshift e dei dati nidificati È possibile unire i dati di Amazon Redshift e i dati nidificati in una tabella esterna. Ad esempio, si supponga di avere i seguenti dati nidificati in Amazon S3. ``` CREATE EXTERNAL TABLE spectrum.customers2 ( id int, name struct, phones array, orders array> ); ``` Si supponga inoltre di avere la seguente tabella in Amazon Redshift. ``` CREATE TABLE prices ( id int, price double precision ); ``` La query riportata di seguito restituisce il numero totale e l'importo degli acquisti di ciascun cliente sulla base di quanto indicato in precedenza. L'esempio seguente viene utilizzato soltanto a scopo illustrativo. Restituisce dati solo se hai creato le tabelle descritte in precedenza. ``` SELECT c.name.given, c.name.family, COUNT(o.date) AS ordercount, SUM(p.price) AS ordersum FROM spectrum.customers2 c, c.orders o, prices p ON o.item = p.id GROUP BY c.id, c.name.given, c.name.family; ``` # Limitazioni relative ai dati annidati (anteprima) In questo argomento vengono illustrate le limitazioni per la lettura di dati annidati con Redshift Spectrum. I dati annidati sono dati che contengono campi annidati. I campi annidati sono campi di cui è stato effettuato il join come un’unica entità, quali array, strutture oppure oggetti. **Nota** Le limitazioni contrassegnate con (anteprima) nell’elenco seguente si applicano solo ai cluster di anteprima creati nelle seguenti Regioni. Stati Uniti orientali (Ohio) (us-east-2) Stati Uniti orientali (Virginia settentrionale) (us-east-1) Stati Uniti occidentali (California settentrionale) (us-west-1) Asia Pacifico (Tokyo) (ap-northeast-1) Europa (Irlanda) (eu-west-1) Europa (Stoccolma) (eu-north-1) Per informazioni sulla configurazione di cluster di anteprima, consulta [Creazione di un cluster di anteprima](https://docs.aws.amazon.com/redshift/latest/mgmt/managing-clusters-console.html#cluster-preview) nella *Guida alla gestione di Amazon Redshift*. Le seguenti limitazioni si applicano ai dati nidificati: + Un tipo `array` o `map` può contenere altri tipi `array` o `map`, purché le query su `arrays` o `maps` annidati non restituiscano valori `scalar` (anteprima). + Amazon Redshift Spectrum supporta i tipi di dati complessi solo come tabelle esterne. + Le colonne dei risultati delle query secondarie devono essere di primo livello (anteprima). + Se un'espressione `OUTER JOIN` si riferisce a una tabella nidificata, può fare riferimento solo a quella tabella e alle relative matrici (e mappe) nidificate. Se un'espressione `OUTER JOIN` non si riferisce a una tabella nidificata, può fare riferimento a qualsiasi numero di tabelle non nidificate. + Se una clausola `FROM` in una query secondaria si riferisce a una tabella nidificata, non può fare riferimento a nessun'altra tabella. + Se una query secondaria dipende da una tabella nidificata che si riferisce a una tabella padre, la query secondaria può utilizzare la tabella padre solo nella clausola `FROM`. Non puoi utilizzare l'elemento padre in un'altra clausola, ad esempio una di tipo `SELECT` o `WHERE`. Ad esempio, la seguente query non viene eseguita perché la clausola `SELECT` della query secondaria si riferisce alla tabella padre `c`. ``` SELECT c.name.given FROM spectrum.customers c WHERE (SELECT COUNT(c.id) FROM c.phones p WHERE p LIKE '858%') > 1; ``` La query riportata sotto viene eseguita perché l'elemento `c` è utilizzato solo nella clausola `FROM` della query secondaria. ``` SELECT c.name.given FROM spectrum.customers c WHERE (SELECT COUNT(*) FROM c.phones p WHERE p LIKE '858%') > 1; ``` + Una query secondaria che accede ai dati nidificati non dalla clausola `FROM` deve restituire un unico valore. Fanno eccezione solo gli operatori `(NOT) EXISTS` in una clausola `WHERE`. + `(NOT) IN` non è supportato. + La profondità di nidificazione massima per tutti i tipi nidificati è 100. Questa restrizione si applica a tutti i formati di file (Parquet, ORC, Ion e JSON). + Le query secondarie di aggregazione che accedono a dati nidificati possono fare riferimento solo ad `arrays` e `maps` nella loro clausola `FROM`, non a una tabella esterna. + L'esecuzione di query sulle pseudocolonne di dati nidificati in una tabella di Redshift Spectrum non è supportata. Per ulteriori informazioni, consulta [Pseudocolonne](c-spectrum-external-tables.md#c-spectrum-external-tables-pseudocolumns). + Quando si estraggono i dati da colonne di matrici o mappe specificate in una clausola `FROM`, è possibile selezionare i valori dalle colonne solo se i valori sono `scalar`. Ad esempio, le seguenti query tentano entrambe di eseguire `SELECT` per gli elementi dall'interno di una matrice. La query che seleziona `arr.a` riesce perché `arr.a` è un valore `scalar`. La seconda query non riesce perché `array` è una matrice estratta da `s3.nested table` nella clausola `FROM` (anteprima). ``` SELECT array_column FROM s3.nested_table; array_column ----------------- [{"a":1},{"b":2}] SELECT arr.a FROM s3.nested_table t, t.array_column arr; arr.a ----- 1 --This query fails to run. SELECT array FROM s3.nested_table tab, tab.array_column array; ``` Non è possibile utilizzare una matrice o una mappa nella clausola `FROM` che a sua volta proviene da un'altra matrice o mappa. Per selezionare matrici o altre strutture complesse annidate all'interno di altre matrici, prendi in considerazione di usare gli indici nell'istruzione `SELECT`. # Serializzazione di JSON nidificato complesso In questo argomento viene illustrato come serializzare i dati annidati in formato JSON. I dati annidati sono dati che contengono campi annidati. I campi annidati sono campi di cui è stato effettuato il join come un’unica entità, quali array, strutture oppure oggetti. Un'alternativa ai metodi illustrati in questo tutorial consiste nell'eseguire una query sulle colonne di raccolta nidificate di primo livello come JSON serializzato. È possibile utilizzare la serializzazione per ispezionare, convertire e importare dati nidificati come JSON con Redshift Spectrum. Questo metodo è supportato per i formati ORC, JSON, Ion e Parquet. Utilizzare il parametro di configurazione della sessione `json_serialization_enable` per configurare il comportamento di serializzazione. Se impostato, i tipi di dati JSON complessi sono serializzati in VARCHAR(65535). È possibile accedere al JSON nidificato con [Funzioni JSON](json-functions.md). Per ulteriori informazioni, consultare [json\$1serialization\$1enable](r_json_serialization_enable.md). Ad esempio, senza impostare `json_serialization_enable`, le seguenti query che accedono direttamente alle colonne nidificate avranno esito negativo. ``` SELECT * FROM spectrum.customers LIMIT 1; => ERROR: Nested tables do not support '*' in the SELECT clause. SELECT name FROM spectrum.customers LIMIT 1; => ERROR: column "name" does not exist in customers ``` L'impostazione di `json_serialization_enable` consente di eseguire le query direttamente sulle raccolte di primo livello. ``` SET json_serialization_enable TO true; SELECT * FROM spectrum.customers order by id LIMIT 1; id | name | phones | orders ---+--------------------------------------+----------------+---------------------------------------------------------------------------------------------------------------------- 1 | {"given": "John", "family": "Smith"} | ["123-457789"] | [{"shipdate": "2018-03-01T11:59:59.000Z", "price": 100.50}, {"shipdate": "2018-03-01T09:10:00.000Z", "price": 99.12}] SELECT name FROM spectrum.customers order by id LIMIT 1; name --------- {"given": "John", "family": "Smith"} ``` Considerare quanto segue durante la serializzazione del JSON nidificato. + Quando le colonne di raccolta sono serializzate come VARCHAR(65535), non è possibile accedere direttamente ai relativi sottocampi nidificati come parte della sintassi della query (ad esempio, nella clausola filter). Tuttavia, le funzioni JSON possono essere utilizzate per accedere al JSON nidificato. + Le seguenti rappresentazioni specializzate non sono supportate: + Unioni ORC + Mappe ORC con chiavi di tipo complesso + Datagrammi Ion + SEXP Ion + I timestamp vengono restituiti come stringhe serializzate ISO. + Le chiavi delle mappe primitive sono promosse a stringa (ad esempio, da `1` a `"1"`). + I valori nulli di primo livello vengono serializzati come. NULLs + Se la serializzazione eccede la dimensione massima VARCHAR di 65535, la cella viene impostata su NULL. ## Serializzazione di tipi complessi contenenti stringhe JSON Per impostazione predefinita, i valori stringa contenuti nelle raccolte nidificate vengono serializzati come stringhe JSON con escape. L'escape potrebbe essere indesiderato se le stringhe sono JSON valide. È invece possibile voler scrivere sottoelementi o campi nidificati che sono VARCHAR direttamente come JSON. Abilitare questo comportamento con la configurazione a livello di sessione `json_serialization_parse_nested_strings`. Quando sono impostati sia `json_serialization_enable` che `json_serialization_parse_nested_strings`, i valori JSON validi sono serializzati in linea senza caratteri escape. Se il valore non è JSON valido, viene eseguito l'escape come se il valore di configurazione `json_serialization_parse_nested_strings` non fosse impostato. Per ulteriori informazioni, consultare [json\$1serialization\$1parse\$1nested\$1strings](r_json_serialization_parse_nested_strings.md). Ad esempio, si supponga che i dati dell'esempio precedente contengano JSON come tipo complesso `structs`nel campo `name` VARCHAR(20): ``` name --------- {"given": "{\"first\":\"John\",\"middle\":\"James\"}", "family": "Smith"} ``` Quando è impostato `json_serialization_parse_nested_strings`, la colonna `name` viene serializzata come segue: ``` SET json_serialization_enable TO true; SET json_serialization_parse_nested_strings TO true; SELECT name FROM spectrum.customers order by id LIMIT 1; name --------- {"given": {"first":"John","middle":"James"}, "family": "Smith"} ``` Anziché essere sottoposto a escape in questo modo: ``` SET json_serialization_enable TO true; SELECT name FROM spectrum.customers order by id LIMIT 1; name --------- {"given": "{\"first\":\"John\",\"middle\":\"James\"}", "family": "Smith"} ```