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à. # Documentazione di riferimento SQL per Athena Amazon Athena supporta un sottoinsieme di istruzioni, funzioni, operatori e tipi di dati DDL (Data Definition Language) e DML (Data Manipulation Language). Con alcune eccezioni, Athena DDL si basa su [HiveQL DDL](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+DDL) e Athena DML si basa su [Trino](https://trino.io/docs/current/language.html). Per ulteriori informazioni sulle versioni del motore Athena, consulta [Controllo delle versioni del motore di Athena](engine-versions.md). **Topics** + [Tipi di dati in Athena](data-types.md) + [Query, funzioni e operatori DML](dml-queries-functions-operators.md) + [Istruzioni DDL](ddl-reference.md) + [Considerazioni e limitazioni](other-notable-limitations.md) # Tipi di dati in Amazon Athena Quando si esegue `CREATE TABLE`, si specificano i nomi delle colonne e il tipo di dati che ogni colonna può contenere. Le tabelle create vengono archiviate in AWS Glue Data Catalog. Per facilitare l’interoperabilità con altri motori di query, Athena utilizza i nomi dei tipi di dati [Apache Hive](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+Types) per istruzioni DDL come `CREATE TABLE`. Per le query DML come `SELECT`, `CTAS` e `INSERT INTO` Athena utilizza i nomi dei tipi di dati [Trino](https://trino.io/docs/current/language/types.html). La tabella seguente mostra i tipi di dati supportati in Athena. Laddove i tipi DDL e DML differiscono in termini di nome, disponibilità o sintassi, vengono visualizzati in colonne separate. **** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/data-types.html) **Topics** + [Esempi di tipi di dati](data-types-examples.md) + [Considerazioni sui tipi di dati](data-types-considerations.md) + [Utilizzo dei dati con timestamp](data-types-timestamps.md) # Esempi di tipi di dati La tabella seguente mostra un esempio di valori letterali per i tipi di dati DML. **** | Tipo di dati | Esempi | | --- | --- | | BOOLEAN | `true` `false ` | | TINYINT | `TINYINT '123'` | | SMALLINT | `SMALLINT '123'` | | INT, INTEGER | `123456790` | | BIGINT | `BIGINT '1234567890'` `2147483648` | | REAL | `'123456.78'` | | DOUBLE | `1.234` | | DECIMALE (,) precision scale | `DECIMAL '123.456'` | | CARATTERE, CARATTERE () length | `CHAR 'hello world'`, `CHAR 'hello ''world''!'` | | VARCHAR, VARCHAR () length | `VARCHAR 'hello world'`, `VARCHAR 'hello ''world''!'` | | VARBINARY | `X'00 01 02'` | | TEMPO, TEMPO () precision | `TIME '10:11:12'`, `TIME '10:11:12.345'` | | TIME WITH TIME ZONE | `TIME '10:11:12.345 -06:00'` | | DATE | `DATE '2024-03-25'` | | TIMESTAMP, TIMESTAMP SENZA FUSO ORARIO, TIMESTAMP (), TIMESTAMP (*precision*) SENZA FUSO ORARIO *precision* | `TIMESTAMP '2024-03-25 11:12:13'`, `TIMESTAMP '2024-03-25 11:12:13.456'` | | TIMESTAMP CON FUSO ORARIO, TIMESTAMP () CON FUSO ORARIO precision | `TIMESTAMP '2024-03-25 11:12:13.456 Europe/Berlin'` | | INTERVAL YEAR TO MONTH | `INTERVAL '3' MONTH` | | INTERVAL DAY TO SECOND | `INTERVAL '2' DAY` | | element\$1typeMATRICE [] | `ARRAY['one', 'two', 'three']` | | MAPPA (key\$1type,value\$1type) | `MAP(ARRAY['one', 'two', 'three'], ARRAY[1, 2, 3])` Nota che le mappe vengono create da una matrice di chiavi e da una matrice di valori. L’esempio seguente crea una tabella che mappa le stringhe su numeri interi. 
CREATE TABLE map_table(col1 map) LOCATION '...';
INSERT INTO map_table values(MAP(ARRAY['foo', 'bar'], ARRAY[1, 2]));
| | RIGA (field\$1name\$11field\$1type\$11, field\$1name\$12field\$1type\$12,...) | `ROW('one', 'two', 'three')` Nota che le righe create in questo modo non hanno nomi di colonna. Per aggiungere nomi di colonna, puoi usare`CAST`, come nell’esempio seguente: 
CAST(ROW(1, 2, 3) AS ROW(one INT, two INT, three INT))
| | JSON | `JSON '{"one":1, "two": 2, "three": 3}'` | | UUID | `UUID '12345678-90ab-cdef-1234-567890abcdef'` | | IpAddress | `IPADDRESS '10.0.0.1'` `IPADDRESS '2001:db8::1'` | # Considerazioni sui tipi di dati ## Limiti di dimensione Per i tipi di dati che non specificano un limite di dimensione, tieni presente che esiste un limite pratico di 32 MB per tutti i dati in una singola riga. Per ulteriori informazioni, consulta [Row or column size limitation](other-notable-limitations.md#sql-limitations-rowsize) in [Considerazioni e restrizioni per le query SQL in Amazon Athena](other-notable-limitations.md). ## CHAR e VARCHAR Un `CHAR(n)` valore ha sempre un numero di caratteri. `n` Ad esempio, se si trasmette 'abc' a`CHAR(7)`, vengono aggiunti 4 spazi finali. I confronti di `CHAR` valori includono gli spazi iniziali e finali. Se viene specificata una lunghezza per `CHAR` o`VARCHAR`, le stringhe vengono troncate alla lunghezza specificata durante la lettura. Se la stringa di dati sottostante è più lunga, la stringa di dati sottostante rimane invariata. Per evitare una virgoletta singola in una `CHAR` o`VARCHAR`, usa una virgoletta singola aggiuntiva. Per eseguire il cast di un tipo di dati non stringa in una stringa in una query DML, `VARCHAR` esegui il cast sul tipo di dati. Per utilizzare la funzione `substr` per restituire una sottostringa di lunghezza specificata da un tipo di dati `CHAR`, è necessario innanzitutto eseguire il cast del valore `CHAR` come `VARCHAR`, come mostrato nell’esempio seguente. Nell’esempio seguente, `col1` utilizzo il tipo di dati `CHAR`. ``` substr(CAST(col1 AS VARCHAR), 1, 4) ``` ## DECIMAL Per specificare valori decimali come letterali, ad esempio durante la selezione delle righe con un determinato valore decimale nell’espressione di una query DDL, specifica la definizione di tipo `SELECT` e indica il valore decimale come letterale (tra virgolette singole) nella query, come in questo esempio: `DECIMAL`. ``` SELECT * FROM my_table WHERE decimal_value = DECIMAL '0.12' ``` ``` SELECT DECIMAL '44.6' + DECIMAL '77.2' ``` # Utilizzo dei dati con timestamp Questa sezione descrive alcune considerazioni sull'utilizzo dei dati con timestamp in Athena. **Nota** Il trattamento dei timestamp è leggermente cambiato tra le versioni precedenti e la versione 3 del motore Athena. Per informazioni sugli errori relativi ai timestamp che possono verificarsi nella versione 3 del motore Athena e sulle soluzioni suggerite, consultare [Modifiche al timestamp](engine-versions-reference-0003.md#engine-versions-reference-0003-timestamp-changes) nei riferimenti [Versione 3 del motore Athena](engine-versions-reference-0003.md). ## Formato per la scrittura di dati timestamp su oggetti Amazon S3 Il formato in cui i dati timestamp devono essere scritti negli oggetti Amazon S3 dipende sia dal tipo di dati della colonna che [SerDedalla libreria utilizzata](https://docs.aws.amazon.com/athena/latest/ug/supported-serdes.html). + Se hai una colonna di tabella di tipo `DATE`, Athena si aspetta che la colonna o la proprietà corrispondente dei dati sia una stringa in formato `YYYY-MM-DD` ISO o un tipo di data integrato come quelli per Parquet o ORC. + Se hai una colonna di tabella di tipo `TIME`, Athena si aspetta che la colonna o la proprietà corrispondente dei dati sia una stringa in formato `HH:MM:SS` ISO o un tipo di ora integrato come quelli per Parquet o ORC. + Se hai una colonna di tabella di tipo `TIMESTAMP`, Athena si aspetta che la colonna o la proprietà corrispondente dei dati sia una stringa nel formato `YYYY-MM-DD HH:MM:SS.SSS` (nota lo spazio tra la data e l'ora) o un tipo di ora integrato come quelli per Parquet, ORC o Ion. Nota che Athena non garantisce il comportamento per i timestamp non validi (ad esempio,). `0000-00-00 08:00:00.000` **Nota** I timestamp Open CSVSer De sono un'eccezione e devono essere codificati come epoche UNIX con risoluzione in millisecondi. ## Come garantire che i dati partizionati nel tempo corrispondano al campo timestamp di un record Il produttore dei dati deve assicurarsi che i valori della partizione siano allineati con i dati all'interno della partizione. Ad esempio, se i dati hanno una `timestamp` proprietà e si utilizza Firehose per caricare i dati in Amazon S3, è necessario [utilizzare il partizionamento dinamico](https://docs.aws.amazon.com/firehose/latest/dev/dynamic-partitioning.html) perché il partizionamento predefinito di Firehose è. wall-clock-based ## Usa string come tipo di dati per le chiavi di partizione Per motivi di prestazioni, è preferibile utilizzare `STRING` come tipo di dati per le chiavi di partizione. Anche se Athena riconosce i valori delle partizioni nel formato `YYYY-MM-DD` come date quando si utilizza il tipo `DATE`, ciò può portare a prestazioni scadenti. Per questo motivo, si consiglia di utilizzare invece il tipo di dati `STRING` per le chiavi di partizione. ## Come scrivere query per campi timestamp che sono anche partizionati in base all'ora Il modo in cui si scrivono le query per i campi di indicazione temporale che sono partizionati in base all'ora dipende dal tipo di tabella su cui si intende eseguire la query. ### Tavoli Hive Con le tabelle Hive più comunemente utilizzate in Athena, il motore di query non conosce le relazioni tra colonne e chiavi di partizione. Per questo motivo, devi sempre aggiungere predicati nelle tue query sia per la colonna che per la chiave di partizione. Ad esempio, supponi di avere una colonna `event_time` e una chiave di partizione `event_date` e di voler eseguire query sugli eventi tra le 23:00 e le 03:00. In questo caso, è necessario includere i predicati nella query sia per la colonna che per la chiave di partizione, come nell'esempio seguente. ``` WHERE event_time BETWEEN start_time AND end_time AND event_date BETWEEN start_time_date AND end_time_date ``` ### Tavoli Iceberg Con le tabelle Iceberg, puoi utilizzare valori di partizione calcolati, il che semplifica le tue query. Ad esempio, supponiamo che la tabella Iceberg sia stata creata con una clausola come la seguente: `PARTITIONED BY` ``` PARTITIONED BY (event_date month(event_time)) ``` In questo caso, il motore di query elimina automaticamente le partizioni in base ai valori dei predicati `event_time`. Per questo motivo, la query deve solo specificare un predicato per `event_time`, come nell'esempio seguente. ``` WHERE event_time BETWEEN start_time AND end_time ``` Per ulteriori informazioni, consulta [Creazione di una tabella Iceberg](querying-iceberg-creating-tables.md). Quando si utilizza il partizionamento nascosto di Iceberg per una colonna di timestamp, Iceberg potrebbe creare una partizione su una colonna di tabella costruita derivata da una colonna di timestamp e trasformata in una data per un partizionamento più efficace. Ad esempio, potrebbe creare dalla colonna timestamp e ripartire automaticamente. `event_date` `event_time` `event_date` **In questo caso, il **tipo** di partizione è una data.** Per prestazioni di query ottimali quando usi la partizione, filtra in base a intervalli di giorni interi per abilitare il pushdown dei predicati. Ad esempio, la seguente query non verrebbe rimandata perché l’intervallo non può essere convertito in una singola partizione di date, anche se rientra nell’arco di un solo giorno: ``` WHERE event_time >= TIMESTAMP '2024-04-18 00:00:00' AND event_time < TIMESTAMP '2024-04-18 12:00:00' ``` Utilizzate invece un intervallo di giorni completi per consentire il pushdown dei predicati e migliorare le prestazioni delle query, come nell’esempio seguente. ``` WHERE event_time >= TIMESTAMP '2024-04-18 00:00:00' AND event_time < TIMESTAMP '2024-04-19 00:00:00' ``` Puoi anche utilizzare la `BETWEEN start_time AND end_time` sintassi o utilizzare gli intervalli di più giorni purché le porzioni relative ai timestamp lo siano. `00:00:00` Per ulteriori informazioni, leggi il [post del blog di Trino](https://trino.io/blog/2023/04/11/date-predicates.html). # Query, funzioni e operatori DML Il motore di query DML Athena supporta in genere la sintassi Trino e Presto, aggiungendo inoltre i propri miglioramenti. Athena non supporta tutte le funzioni di Trino e Presto. Per ulteriori informazioni, consulta gli argomenti per le specifiche istruzioni in questa sezione e in [Considerazioni e limitazioni](other-notable-limitations.md). Per informazioni sulle funzioni, consulta [Funzioni in Amazon Athena](functions.md). Per ulteriori informazioni sulle versioni del motore Athena, consulta [Controllo delle versioni del motore di Athena](engine-versions.md). Per informazioni sulle istruzioni DDL, consulta [Istruzioni DDL](ddl-reference.md). Per un elenco delle istruzioni DDL non supportate, consulta [DDL non supportato](unsupported-ddl.md). **Topics** + [SELECT](select.md) + [INSERT INTO](insert-into.md) + [VALUES](values-statement.md) + [DELETE](delete-statement.md) + [UPDATE](update-statement.md) + [MERGE INTO](merge-into-statement.md) + [OPTIMIZE](optimize-statement.md) + [VACUUM](vacuum-statement.md) + [EXPLAIN e EXPLAIN ANALYZE](athena-explain-statement.md) + [PREPARE](sql-prepare.md) + [UNLOAD](unload.md) + [Funzioni](functions.md) + [Utilizzare fusi orari supportati](athena-supported-time-zones.md) # SELECT Recupera righe di dati da zero o più tabelle. **Nota** In questo argomento vengono fornite informazioni di riepilogo per riferimento. Informazioni complete sull'utilizzo di `SELECT` e il linguaggio SQL non rientrano nell'ambito di questa documentazione. Per informazioni sull'utilizzo di SQL specifico per Athena, consulta [Considerazioni e restrizioni per le query SQL in Amazon Athena](other-notable-limitations.md) e [Esecuzione di query SQL con Amazon Athena](querying-athena-tables.md). Per vedere esempio di creazione di un database o di una tabella e di esecuzione di una query `SELECT` sulla tabella di Athena, consulta [Nozioni di base](getting-started.md). ## Riepilogo ``` [ WITH with_query [, ...] ] SELECT [ ALL | DISTINCT ] select_expression [, ...] [ FROM from_item [, ...] ] [ WHERE condition ] [ GROUP BY [ ALL | DISTINCT ] grouping_element [, ...] ] [ HAVING condition ] [ { UNION | INTERSECT | EXCEPT } [ ALL | DISTINCT ] select ] [ ORDER BY expression [ ASC | DESC ] [ NULLS FIRST | NULLS LAST] [, ...] ] [ OFFSET count [ ROW | ROWS ] ] [ LIMIT [ count | ALL ] ] ``` **Nota** Le parole riservate nelle istruzioni SQL SELECT devono essere racchiuse tra virgolette doppie. Per ulteriori informazioni, consulta [Parole chiave riservate per le quali impostare il carattere escape nelle istruzioni SQL SELECT](reserved-words.md#list-of-reserved-words-sql-select). ## Parameters **[ WITH with\$1query [, ....] ]** È possibile utilizzare `WITH` per appiattire query nidificate o per semplificare le sottoquery. L'utilizzo della clausola `WITH` per creare query ricorsive è supportato a partire dalla versione 3 del motore Athena. La profondità massima di ricorsione è pari a 10. La clausola `WITH` precede l'elenco `SELECT` in una query e definisce una o più sottoquery da usare all'interno della query `SELECT`. Ogni sottoquery definisce una tabella temporanea, simile a una definizione vista, cui è possibile fare riferimento nella clausola `FROM`. Le tabelle vengono utilizzate solo quando la query è in esecuzione. La sintassi `with_query` è: ``` subquery_table_name [ ( column_name [, ...] ) ] AS (subquery) ``` Dove: + `subquery_table_name` è un univoco per una tabella temporanea che definisce i risultati della sottoquery della clausola `WITH`. A ogni `subquery` deve essere assegnato un nome di tabella a cui è possibile fare riferimento nella clausola `FROM`. + `column_name [, ...]` è un elenco opzionale dei nomi di colonna di output. Il numero dei nomi di colonna specificati deve essere uguale o inferiore al numero delle colonne definite dalla `subquery`. + `subquery` è un'istruzione di query. **[ ALL \$1 DISTINCT ] select\$1expr** `select_expression` determina la righe da selezionare. Un `select_expression` può utilizzare uno dei seguenti formati: ``` expression [ [ AS ] column_alias ] [, ...] ``` ``` row_expression.* [ AS ( column_alias [, ...] ) ] ``` ``` relation.* ``` ``` * ``` + La sintassi `expression [ [ AS ] column_alias ]` specifica una colonna di output. La sintassi opzionale `[AS] column_alias` specifica un nome di titolo personalizzato da utilizzare per la colonna nell’output. + For `row_expression.* [ AS ( column_alias [, ...] ) ]`, `row_expression` è un'espressione arbitraria del tipo di dati `ROW`. I campi della riga definiscono le colonne di output da includere nel risultato. + Per `relation.*`, le colonne di `relation` sono incluse nel risultato. Questa sintassi non consente l’uso di alias di colonna. + L’asterisco `*` specifica che tutte le colonne devono essere incluse nel set di risultati. + Nel set di risultati, l’ordine delle colonne è lo stesso dell’ordine specificato dall’espressione select. Se un’espressione select restituisce più colonne, l’ordine delle colonne segue l’ordine utilizzato nella relazione di origine o nell’espressione del tipo di riga. + Quando vengono specificati alias di colonna, gli alias sostituiscono i nomi di campi di colonna o riga preesistenti. Se l’espressione select non ha nomi di colonna, nell’output vengono visualizzati i nomi di colonna anonimi con indicizzazione zero (`_col0`, `_col1`, `_col2, ...`). + Il valore predefinito è `ALL`. L'utilizzo di `ALL` viene gestito come se fosse omesso; vengono selezionate tutte le righe per tutte le colonne e duplicati vengono conservati. + Usa `DISTINCT` per restituire solo i valori distinti quando una colonna contiene valori duplicati. **FROM from\$1item [, ...]** Indica l'input alla query, dove `from_item` può essere una vista, un costrutto JOIN o una sottoquery, come descritto di seguito. `from_item` può essere: + `table_name [ [ AS ] alias [ (column_alias [, ...]) ] ]` Dove `table_name` è il nome della tabella di destinazione da cui selezionare le righe; `alias` è il nome da assegnare all'output dell'istruzione `SELECT` e `column_alias` definisce le colonne per l'`alias` specificato. **-O-** + `join_type from_item [ ON join_condition | USING ( join_column [, ...] ) ]` Dove `join_type` è una tra le seguenti opzioni: + `[ INNER ] JOIN` + `LEFT [ OUTER ] JOIN` + `RIGHT [ OUTER ] JOIN` + `FULL [ OUTER ] JOIN` + `CROSS JOIN` + `ON join_condition | USING (join_column [, ...])` Dove l'utilizzo di `join_condition` consente di specificare nomi di colonna per le chiavi JOIN in più tabelle e l'utilizzo di `join_column` richiede che `join_column` esista in entrambe le tabelle. **[ condizione WHERE ]** Filtra i risultati in base alla `condition` specificata, dove `condition` in genere ha la seguente sintassi. ``` column_name operator value [[[AND | OR] column_name operator value] ...] ``` *operator*Può essere uno dei comparatori`=`,,`>`,`<`,`>=`, `<=``<>`,`!=`. Le seguenti espressioni di sottoquery possono essere utilizzate anche nella clausola `WHERE`. + `[NOT] BETWEEN integer_A AND integer_B` — Specifica un intervallo tra due numeri interi, come nell'esempio seguente. Se il tipo di dati della colonna è `varchar`, la colonna deve essere prima creata su un numero intero. ``` SELECT DISTINCT processid FROM "webdata"."impressions" WHERE cast(processid as int) BETWEEN 1500 and 1800 ORDER BY processid ``` + `[NOT] LIKE value`— Cerca il modello specificato. Utilizza il segno di percentuale (`%`) come carattere jolly, come nell'esempio seguente. ``` SELECT * FROM "webdata"."impressions" WHERE referrer LIKE '%.org' ``` + `[NOT] IN (value[, value[, ...])` – Specifica un elenco di possibili valori per una colonna, come nell'esempio seguente. ``` SELECT * FROM "webdata"."impressions" WHERE referrer IN ('example.com','example.net','example.org') ``` **[GROUP BY [ALL \$1 DISTINCT] grouping\$1expressions [,...]]** Suddivide l'output dell'istruzione `SELECT` in righe con valori corrispondenti. `ALL` e `DISTINCT` determinano se i set duplicati di set di raggruppamento producono ciascuno righe di output diverse. Se omesso, viene utilizzato `ALL`. `grouping_expressions` consente di eseguire operazioni di raggruppamento complesse. È possibile utilizzare operazioni di raggruppamento complesse per eseguire un'analisi che richiede di aggregare più serie di colonne in una query singola. L'elemento `grouping_expressions` può essere qualsiasi funzione, come `SUM`, `AVG` o `COUNT`, eseguita sulle colonne di input. Le espressioni `GROUP BY` possono raggruppare l'output in base ai nomi di colonna di input che non appaiono nell'output dell'istruzione `SELECT`. Tutte le espressioni di output devono essere funzioni aggregate o colonne presenti nella clausola `GROUP BY`. È possibile utilizzare una singola query per eseguire un'analisi che richiede di aggregare più serie di colonne. Athena supporta aggregazioni complesse usando `GROUPING SETS`, `CUBE` e `ROLLUP`. `GROUP BY GROUPING SETS` specifica più elenchi di colonne su cui eseguire il raggruppamento. `GROUP BY CUBE` genera tutti i possibili set di raggruppamento per un determinato set di colonne. `GROUP BY ROLLUP` genera tutti i possibili subtotali per un determinato set di colonne. Le operazioni di raggruppamento complesse non supportano il raggruppamento su espressioni composte da colonne di input. Solo ammessi solo i nomi di colonna. Spesso è possibile utilizzare `UNION ALL` per ottenere gli stessi risultati ottenuti in queste operazioni `GROUP BY`, ma le query che utilizzano `GROUP BY` hanno il vantaggio di leggere i dati una sola volta, mentre `UNION ALL` legge i dati sottostanti tre volte e potrebbe produrre risultati incoerenti quando l'origine dati è soggetta a modifiche. **[ condizione HAVING ]** Utilizzata con funzioni aggregate e con la clausola `GROUP BY`. Controlla quali gruppi sono selezionati, eliminando i gruppi che non soddisfano la `condition`. Questo filtraggio si verifica dopo che i gruppi e gli aggregati sono stati calcolati. **[ \$1 UNION \$1 INTERSECT \$1 EXCEPT \$1 [ ALL \$1 DISTINCT ] union\$1query] ]** `UNION`, `INTERSECT` e `EXCEPT` combinano i risultati di più di un'istruzione `SELECT` in una singola query. `ALL` o `DISTINCT` controlla l'unicità delle righe incluse nel set finale di risultati. `UNION` combina le righe risultanti dalla prima query con le righe risultanti dalla seconda query. Per eliminare i duplicati, `UNION` crea una tabella hash, che consuma memoria. Per prestazioni migliori, prendere in considerazione l'utilizzo di `UNION ALL` se la query non richiede l'eliminazione dei duplicati. Più clausole `UNION` vengono elaborate da sinistra a destra, a meno che non si utilizzino le parentesi per definire esplicitamente l'ordine di elaborazione. `INTERSECT` restituisce solo le righe presenti nei risultati sia della prima che della seconda query. `EXCEPT` restituisce le righe dai risultati della prima query, escludendo le righe trovate dalla seconda query. `ALL` fa sì che tutte le righe siano incluse, anche se le righe sono identiche. `DISTINCT` fa sì che solo righe univoche siano incluse nel set di risultati combinati. **[ espressione ORDER BY [ ASC \$1 DESC ] [ NULLS FIRST \$1 NULLS LAST] [, ...] ]** Ordina un set di risultati da uno o più output `expression`. Quando la clausola contiene più espressioni, il set di risultati è ordinato in base alla prima `expression`. Quindi la seconda `expression` viene applicata a righe con valori corrispondenti dalla prima espressione e così via. Ogni `expression` può specificare colonne di output da `SELECT` o un numero ordinale per una colonna di output per posizione, a partire da uno. `ORDER BY` viene valutato come ultimo passaggio dopo qualsiasi clausola `GROUP BY` o `HAVING`. `ASC` e `DESC` determinano se i risultati sono in ordine crescente o decrescente. Per impostazione predefinita, l’ordinamento è crescente (`ASC`). L'ordine predefinito nullo è `NULLS LAST`, indipendentemente dall'ordinamento crescente o decrescente. **[ OFFSET count [ ROW \$1 ROWS ] ]** Utilizzare la clausola `OFFSET` per eliminare un certo numero di righe iniziali dal set di risultati. Se la clausola `ORDER BY` è presente, la clausola `OFFSET` viene valutata su un set di risultati ordinato e il set rimane ordinato dopo che le righe ignorate sono state scartate. Se la query non ha la clausola `ORDER BY`, è arbitrario quali righe vengono scartate. Se il conteggio specificato da `OFFSET` è uguale o maggiore delle dimensioni del set di risultati, il risultato finale è vuoto. **LIMIT [count \$1 ALL]** Limita il numero di righe del set di risultati a `count`. `LIMIT ALL` è lo stesso omettendo la clausola `LIMIT`. Se la query non dispone di alcuna clausola `ORDER BY`, i risultati sono arbitrari. **TABLESAMPLE [ BERNOULLI \$1 SYSTEM ] (percentuale)** Operatore facoltativo per selezionare righe da una tabella in base a un metodo di campionamento. `BERNOULLI` seleziona ogni riga che deve essere nella tabella di esempio con una probabilità di `percentage`. Tutti i blocchi fisici della tabella vengono scansionati e determinate righe vengono ignorate in base a un confronto tra la `percentage` del campione e un valore casuale calcolato in fase di runtime. Con `SYSTEM`, la tabella viene suddivisa in segmenti logici di dati e viene campionata a questa granularità. Vengono selezionate tutte le righe da un determinato segmento oppure il segmento viene ignorato in base a un confronto tra la `percentage` campione e un valore casuale calcolato in fase di runtime. Il campionamento `SYSTEM` dipende dal connettore. Questo metodo non garantisce la campionatura indipendente delle probabilità. **[ UNNEST (array\$1or\$1map) [WITH ORDINALITY] ]** Espande una matrice o una mappa in una relazione. Le matrice vengono espanse in una singola colonna. Le mappe vengono espanse in due colonne (*chiave*, *valore*). È possibile utilizzare `UNNEST` con più argomenti, che vengono espansi in più colonne con un numero di righe pari all'argomento di cardinalità più alto. Alle altre colonne vengono aggiunti degli zeri. La clausola `WITH ORDINALITY` aggiunge un colonna di ordinalità alla fine. `UNNEST` viene in genere utilizzato con un `JOIN` e può fare riferimento a colonne dalle relazioni a sinistra del `JOIN`. ## Ottenere le posizioni dei file per i dati di origine in Amazon S3 Per visualizzare la posizione del file Amazon S3 per i dati in una riga di tabella, puoi utilizzare `"$path"` in una query `SELECT`, come nell'esempio seguente: ``` SELECT "$path" FROM "my_database"."my_table" WHERE year=2019; ``` Questa query restituisce un risultato come il seguente: ``` s3://amzn-s3-demo-bucket/datasets_mytable/year=2019/data_file1.json ``` Per restituire un elenco ordinato e univoco dei percorsi del nome file S3 per i dati in una tabella, è possibile utilizzare `SELECT DISTINCT` e `ORDER BY`, come nell'esempio seguente. ``` SELECT DISTINCT "$path" AS data_source_file FROM sampledb.elb_logs ORDER By data_source_file ASC ``` Per restituire solo i nomi dei file senza il percorso, è possibile trasmettere `"$path"` come parametro per una funzione `regexp_extract`, come nell'esempio seguente. ``` SELECT DISTINCT regexp_extract("$path", '[^/]+$') AS data_source_file FROM sampledb.elb_logs ORDER By data_source_file ASC ``` Per restituire i dati da un file specifico, specificare il file nella clausola `WHERE`, come nell'esempio seguente. ``` SELECT *,"$path" FROM my_database.my_table WHERE "$path" = 's3://amzn-s3-demo-bucket/my_table/my_partition/file-01.csv' ``` Per ulteriori informazioni ed esempi, consulta l'articolo del Portale del sapere [In che modo è possibile visualizzare il file sorgente Amazon S3 per cercare una riga di una tabella Athena?](https://aws.amazon.com/premiumsupport/knowledge-center/find-s3-source-file-athena-table-row/). **Nota** In Athena, le colonne di metadati nascoste Hive o Iceberg e `$bucket`, `$file_modified_time`, `$file_size` e `$partition` non sono supportate per le viste. ## Escape delle virgolette singole Per eseguire una procedura di escape di virgolette singole, precederla con altre virgolette, come nell'esempio seguente. Non confondere questo con doppie virgolette. ``` Select 'O''Reilly' ``` **Risultati** `O'Reilly` ## Risorse aggiuntive Per ulteriori informazioni sull'utilizzo delle istruzioni `SELECT` in Athena, consulta le seguenti risorse. | Per informazioni su questo | Consulta questo | | --- | --- | | Esecuzione di query in Athena | [Esecuzione di query SQL con Amazon Athena](querying-athena-tables.md) | | Utilizzo di SELECT per creare una tabella | [Creare una tabella dai risultati delle query (CTAS)](ctas.md) | | Inserimento di dati da una query SELECT in un'altra tabella | [INSERT INTO](insert-into.md) | | Utilizzo di funzioni integrate nelle istruzioni SELECT | [Funzioni in Amazon Athena](functions.md) | | Utilizzo di funzioni definite dall'utente nelle istruzioni SELECT | [Eseguire query con funzioni definite dall’utente](querying-udf.md) | | Esecuzione di query sui metadati del catalogo dati | [Interroga il AWS Glue Data Catalog](querying-glue-catalog.md) | # INSERT INTO Inserisce nuove righe in una tabella di destinazione in base a un'istruzione di query `SELECT` eseguita su una tabella di origine o in base a un set di `VALUES` fornito come parte dell'istruzione. Quando la tabella di origine si basa sui dati sottostanti in un formato, ad esempio CSV o JSON, e la tabella di destinazione si basa su un altro formato, ad esempio Parquet o ORC, puoi utilizzare le query `INSERT INTO` per trasformare i dati selezionati nel formato della tabella di destinazione. ## Considerazioni e limitazioni Considera le informazioni seguenti durante l'utilizzo delle query `INSERT` con Athena. + Quando si esegue una query `INSERT` su una tabella con i dati sottostanti crittografati in Amazon S3, i file di output scritti dalla query `INSERT` non vengono crittografati per impostazione predefinita. Ti consigliamo di crittografare i risultati delle query `INSERT` se stai inserendo nelle tabelle dati crittografati. Per ulteriori informazioni sulla crittografia dei risultati delle query tramite la console, consulta [Crittografare i risultati di query Athena archiviati in Amazon S3](encrypting-query-results-stored-in-s3.md). Per abilitare la crittografia utilizzando l'API AWS CLI o Athena, utilizza `EncryptionConfiguration` le proprietà dell'[StartQueryExecution](https://docs.aws.amazon.com/athena/latest/APIReference/API_StartQueryExecution.html)azione per specificare le opzioni di crittografia di Amazon S3 in base ai tuoi requisiti. + Per le istruzioni `INSERT INTO`, l'impostazione prevista per il proprietario del bucket non si applica alla posizione della tabella di destinazione in Amazon S3. L'impostazione prevista per il proprietario del bucket si applica solo al percorso di output di Amazon S3 specificato per i risultati delle query di Athena. Per ulteriori informazioni, consulta [Specificare una posizione dei risultati delle query utilizzando la console Athena](query-results-specify-location-console.md). + Per le istruzioni `INSERT INTO` conformi all'ACID, consulta la sezione `INSERT INTO` della pagina [Aggiornare dati di tabelle Iceberg](querying-iceberg-updating-iceberg-table-data.md). ### Formati supportati e SerDes È possibile eseguire un'`INSERT`interrogazione su tabelle create a partire da dati con i seguenti formati e SerDes. | Formato dei dati | SerDe | | --- | --- | | Avro | org.apache.hadoop.hive.serde2.avro. AvroSerDe | | Ion | com.amazon.ionhiveserde. IonHiveSerDe | | JSON | org.apache.hive.hcatalog.data. JsonSerDe | | ORC | org.apache.hadoop.hive.ql.io.orc. OrcSerde | | Parquet | org.apache.hadoop.hive.ql.io.parquet.serde. ParquetHiveSerDe | | File di testo | org.apache.hadoop.hive.serde2.lazy. LazySimpleSerDe Sono supportati file TSV e file con delimitatori personalizzati. | | CSV | org.apache.hadoop.hive.serde 2.open CSVSerde Le scritture sono supportate solo per i tipi di stringa. Da Athena, non è possibile scrivere su tabelle che contengono tipi non stringhe nello schema Glue. [Per ulteriori informazioni, consulta CSV. SerDe](csv-serde.md#csv-serde-opencsvserde-considerations-non-string) | ### Tabelle con bucket non supportate `INSERT INTO` non è supportato nelle tabelle con bucket. Per ulteriori informazioni, consulta [Utilizzare partizionamento e bucketing](ctas-partitioning-and-bucketing.md). ### Query federate non supportate `INSERT INTO` non è supportato per le query federate. Il tentativo di eseguire questa operazione potrebbe generare il messaggio di errore This operation is currently not supported for external catalogs (Questa operazione non è attualmente supportata per i cataloghi esterni). Per informazioni sulle query federate, consultare [Utilizza Amazon Athena Federated Query](federated-queries.md). ### Partizionamento Tieni in considerazione i punti esposti in questa sezione quando utilizzi il partizionamento con le query `INSERT INTO` o `CREATE TABLE AS SELECT`. #### Limits L'istruzione `INSERT INTO` supporta la scrittura di un massimo di 100 partizioni nella tabella di destinazione. Se si esegue la clausola `SELECT` su una tabella con più di 100 partizioni, la query non riesce a meno che la query `SELECT` non sia limitata a massimo 100 partizioni. Per informazioni su una soluzione alternativa per questa limitazione, consulta [Utilizzare CTAS e INSERT INTO per aggirare il limite di 100 partizioni](ctas-insert-into.md). #### Ordinamento colonne Le istruzioni `INSERT INTO` o `CREATE TABLE AS SELECT` prevedono che la colonna partizionata sia l'ultima colonna dell'elenco delle colonne proiettate in un'istruzione `SELECT`. Se la tabella di origine non è partizionata o partizionata su colonne diverse rispetto alla tabella di destinazione, query come `INSERT INTO destination_table SELECT * FROM source_table` considerano i valori nell'ultima colonna della tabella di origine come valori per una colonna di partizione nella tabella di destinazione. Tieni presenti queste informazioni quando provi a creare una tabella partizionata da una tabella non partizionata. #### Resources Per ulteriori informazioni sull'utilizzo di `INSERT INTO` con il partizionamento, consulta le seguenti risorse. + Per l'inserimento di dati partizionati in una tabella partizionata, consulta [Utilizzare CTAS e INSERT INTO per aggirare il limite di 100 partizioni](ctas-insert-into.md). + Per l'inserimento di dati non partizionati in una tabella partizionata, consulta [Utilizzare CTAS e INSERT INTO per ETL e analisi dei dati](ctas-insert-into-etl.md). ### File scritti su Amazon S3 Athena scrive file nelle posizioni dei dati di origine in Amazon S3 come risultato del comando `INSERT`. Ogni operazione `INSERT` crea un nuovo file, anziché aggiungere i dati a un file esistente. Le posizioni dei file dipendono dalla struttura della tabella e dalla query `SELECT`, se presente. Athena genera un file manifesto di dati per ogni query `INSERT`. Il manifesto tiene traccia dei file scritti dalla query. Viene salvato nella posizione dei risultati di query Athena in Amazon S3. Per ulteriori informazioni, consulta [Identificazione dei file di output delle query](querying-finding-output-files.md#querying-identifying-output-files). ### Evita aggiornamenti altamente transazionali Quando aggiungi righe `INSERT INTO` a una tabella in Amazon S3, Athena non riscrive o modifica i file esistenti. Al contrario, scrive le righe come uno o più file nuovi. Poiché le tabelle con [ molti file di piccole dimensioni riducono le prestazioni delle query](performance-tuning-data-optimization-techniques.md#performance-tuning-avoid-having-too-many-files) e le operazioni di scrittura e lettura come `PutObject` e `GetObject` comportano costi più elevati da Amazon S3, considera le seguenti opzioni quando utilizzi `INSERT INTO`: + Esegui le operazioni `INSERT INTO` meno frequentemente su batch di righe più grandi. + Per grandi volumi di importazione dei dati, prendi in considerazione l’utilizzo di un servizio come [Amazon Data Firehose](https://docs.aws.amazon.com/firehose/latest/dev/what-is-this-service.html). + Evita di utilizzare `INSERT INTO` del tutto. Invece, accumula le righe in file più grandi e caricale direttamente su Amazon S3, dove Athena potrà interrogarle. ### Individuazione di file orfani Se un'istruzione `CTAS` o `INSERT INTO` ha esito negativo, i dati orfani possono essere lasciati nella posizione dei dati e potrebbero essere letti nelle query successive. Per individuare i file orfani per l'ispezione o l'eliminazione, è possibile utilizzare il file manifesto dati fornito da Athena per tenere traccia dell'elenco dei file da scrivere. Per ulteriori informazioni, consultare [Identificazione dei file di output delle query](querying-finding-output-files.md#querying-identifying-output-files) e [DataManifestLocation](https://docs.aws.amazon.com/athena/latest/APIReference/API_QueryExecutionStatistics.html#athena-Type-QueryExecutionStatistics-DataManifestLocation). ## INSERT INTO...SELECT Specifica la query da eseguire su una tabella, `source_table`, che determina le righe da inserire in una seconda tabella, `destination_table`. Se la query `SELECT` specifica le colonne in `source_table`, le colonne devono corrispondere esattamente a quelle in `destination_table`. Per ulteriori informazioni sulle query `SELECT`, consulta [SELECT](select.md). ### Riepilogo ``` INSERT INTO destination_table SELECT select_query FROM source_table_or_view ``` ### Esempi Seleziona tutte le righe nella tabella `vancouver_pageviews` e inseriscile nella tabella `canada_pageviews`: ``` INSERT INTO canada_pageviews SELECT * FROM vancouver_pageviews; ``` Seleziona solo le righe nella tabella `vancouver_pageviews` in cui la colonna `date` ha un valore compreso tra `2019-07-01` e `2019-07-31`, quindi inseriscile in `canada_july_pageviews`: ``` INSERT INTO canada_july_pageviews SELECT * FROM vancouver_pageviews WHERE date BETWEEN date '2019-07-01' AND '2019-07-31'; ``` Seleziona i valori nelle colonne `state` e `city` nella tabella `cities_world` solo dalle righe con il valore `usa` nella colonna `country` e inseriscile nelle colonne `state` e `city` della tabella `cities_usa`: ``` INSERT INTO cities_usa (city,state) SELECT city,state FROM cities_world WHERE country='usa' ``` ## INSERT INTO...VALUES Inserisce le righe in una tabella esistente specificando colonne e valori. Le colonne specificate e i tipi di dati associati devono corrispondere esattamente alle colonne e ai tipi di dati nella tabella di destinazione. **Importante** Non è consigliabile inserire righe utilizzando `VALUES` perché Athena genera file per ogni operazione `INSERT`. Questo può causare la creazione di molti file di piccole dimensioni e il peggioramento delle prestazioni delle query della tabella. Per identificare i file creati da una query `INSERT`, esamina il file manifesto dei dati. Per ulteriori informazioni, consulta [Lavora con i risultati delle query e le query recenti](querying.md). ### Riepilogo ``` INSERT INTO destination_table [(col1,col2,...)] VALUES (col1value,col2value,...)[, (col1value,col2value,...)][, ...] ``` ### Esempi Negli esempi seguenti, la tabella delle città ha tre colonne: `id`, `city`, `state`, `state_motto`. La colonna `id` è di tipo `INT` e tutte le altre colonne sono di tipo `VARCHAR`. Inserisci una singola riga nella tabella `cities`, con tutti i valori di colonna specificati: ``` INSERT INTO cities VALUES (1,'Lansing','MI','Si quaeris peninsulam amoenam circumspice') ``` Inserisci due righe nella tabella `cities`: ``` INSERT INTO cities VALUES (1,'Lansing','MI','Si quaeris peninsulam amoenam circumspice'), (3,'Boise','ID','Esto perpetua') ``` # VALUES Creare una tabella letterale in linea. La tabella può essere anonima oppure è possibile utilizzare la frase `AS` per specificare il nome di una tabella, i nomi delle colonne o entrambi. ## Riepilogo ``` VALUES row [, ...] ``` ## Parameters **riga** Il parametro `row` può essere una singola espressione o `( column_expression [, ...] )`. ## Esempi Restituisce una tabella con una colonna e tre righe: ``` VALUES 1, 2, 3 ``` Restituisce una tabella con due colonne e tre righe: ``` VALUES (1, 'a'), (2, 'b'), (3, 'c') ``` Restituisce una tabella con le colonne `id` e `name`: ``` SELECT * FROM ( VALUES (1, 'a'), (2, 'b'), (3, 'c') ) AS t (id, name) ``` Creare una tabella chiamata `customers` con le colonne `id` e `name`: ``` CREATE TABLE customers AS SELECT * FROM ( VALUES (1, 'a'), (2, 'b'), (3, 'c') ) AS t (id, name) ``` ## Consulta anche [INSERT INTO...VALUES](insert-into.md#insert-into-values) # DELETE Elimina le righe di una tabella Apache Iceberg. `DELETE` è transazionale ed è supportato solo per le tabelle Apache Iceberg. ## Riepilogo Per eliminare le righe di una tabella Iceberg, utilizza la sintassi seguente. ``` DELETE FROM [db_name.]table_name [WHERE predicate] ``` Per ulteriori informazioni, consulta la sezione `DELETE` della pagina [Aggiornare dati di tabelle Iceberg](querying-iceberg-updating-iceberg-table-data.md). # UPDATE Aggiorna le righe di una tabella Apache Iceberg. `UPDATE` è transazionale ed è supportato solo per le tabelle Apache Iceberg. L’istruzione funziona solo su righe esistenti e non può essere usata per inserire o aggiungere una riga. ## Riepilogo Per aggiornare le righe di una tabella Iceberg, utilizza la sintassi seguente. ``` UPDATE [db_name.]table_name SET xx=yy[,...] [WHERE predicate] ``` Per ulteriori informazioni, consulta la sezione `UPDATE` della pagina [Aggiornare dati di tabelle Iceberg](querying-iceberg-updating-iceberg-table-data.md). # MERGE INTO Aggiorna, elimina o inserisce in modo condizionale righe in una tabella Apache Iceberg. Una singola istruzione può combinare operazioni di aggiornamento, eliminazione e inserimento. **Nota** L'istruzione `MERGE INTO` è transazionale ed è supportata solo per le tabelle Apache Iceberg nella versione 3 del motore Athena. ## Riepilogo Per aggiornare, eliminare o inserire in modo condizionale righe di una tabella Iceberg, utilizza la sintassi seguente. ``` MERGE INTO target_table [ [ AS ] target_alias ] USING { source_table | query } [ [ AS ] source_alias ] ON search_condition when_clause [...] ``` *when\$1clause*È una delle seguenti: ``` WHEN MATCHED [ AND condition ] THEN DELETE ``` ``` WHEN MATCHED [ AND condition ] THEN UPDATE SET ( column = expression [, ...] ) ``` ``` WHEN NOT MATCHED [ AND condition ] THEN INSERT (column_name[, column_name ...]) VALUES (expression, ...) ``` `MERGE` supporta un numero arbitrario di clausole `WHEN` con condizioni `MATCHED` diverse. Le clausole condizionali eseguono l'operazione `DELETE`, `UPDATE` o `INSERT` nella prima clausola `WHEN` selezionata dallo stato `MATCHED` e dalla condizione corrispondente. Per ogni riga di origine, le clausole `WHEN` vengono elaborate in ordine. Viene eseguita solo la prima clausola `WHEN` corrispondente. Le clausole successive vengono ignorate. Viene generato un errore utente quando una singola riga della tabella di destinazione corrisponde a più di una riga di origine. Se una riga di origine non corrisponde ad alcuna clausola `WHEN` e non è presente alcuna clausola `WHEN NOT MATCHED`, la riga di origine viene ignorata. Nelle clausole `WHEN` che prevedono operazioni `UPDATE`, le espressioni dei valori delle colonne possono fare riferimento a qualsiasi campo della destinazione o dell'origine. Nel caso di `NOT MATCHED`, le espressioni `INSERT` possono fare riferimento a qualsiasi campo dell'origine. **Esempio** L'esempio seguente unisce le righe della seconda tabella alla prima tabella se le righe non esistono nella prima tabella. Tieni presente che le colonne elencate nella clausola `VALUES` devono essere precedute dall'alias della tabella di origine. Le colonne di destinazione elencate nella clausola `INSERT` *non* devono avere questo prefisso. ``` MERGE INTO iceberg_table_sample as ice1 USING iceberg2_table_sample as ice2 ON ice1.col1 = ice2.col1 WHEN NOT MATCHED THEN INSERT (col1) VALUES (ice2.col1) ``` Per ulteriori esempi `MERGE INTO`, consulta [Aggiornare dati di tabelle Iceberg](querying-iceberg-updating-iceberg-table-data.md). # OPTIMIZE Ottimizza le righe in una tabella Apache Iceberg riscrivendo i file di dati in un layout più ottimizzato in base alle dimensioni e al numero di file di eliminazione associati. **Nota** `OPTIMIZE` è transazionale ed è supportato solo per le tabelle Apache Iceberg. ## Sintassi Il riepilogo della sintassi seguente mostra come ottimizzare il layout dei dati per una tabella Iceberg. ``` OPTIMIZE [db_name.]table_name REWRITE DATA USING BIN_PACK [WHERE predicate] ``` **Nota** Nella `WHERE` clausola *predicate* sono consentite solo le colonne di partizione. Se viene specificata una colonna non di partizione, la query avrà esito negativo. L'azione di compattazione viene addebitata dalla quantità di dati scansionati durante il processo di riscrittura. L'operazione `REWRITE DATA` utilizza i predicati per selezionare i file che contengono righe corrispondenti. Se una riga del file corrisponde al predicato, il file viene selezionato per l'ottimizzazione. Pertanto, per controllare il numero di file interessati dall'operazione di compattazione, è possibile specificare una clausola `WHERE`. ## Configurazione delle proprietà di compattazione Per controllare la dimensione dei file da selezionare per la compattazione e la dimensione del file risultante dopo la compattazione, è possibile utilizzare i parametri delle proprietà della tabella. Puoi utilizzare il comando [ALTER TABLE SET TBLPROPERTIES](querying-iceberg-alter-table-set-properties.md) per configurare le seguenti [proprietà della tabella](querying-iceberg-creating-tables.md#querying-iceberg-table-properties): ## Risorse aggiuntive [Ottimizzare le tabelle Iceberg](querying-iceberg-data-optimization.md) # VACUUM L’istruzione `VACUUM` esegue la manutenzione delle tabelle Apache Iceberg eseguendo la [scadenza degli snapshot](https://iceberg.apache.org/docs/latest/spark-procedures/#expire_snapshots) e la [rimozione di file orfani](https://iceberg.apache.org/docs/latest/spark-procedures/#remove_orphan_files). **Nota** L'istruzione `VACUUM` è transazionale ed è supportata solo per le tabelle Apache Iceberg nella versione 3 del motore Athena. L’istruzione `VACUUM` ottimizza le tabelle Iceberg riducendo il consumo di storage. Per ulteriori informazioni sull’utilizzo di `VACUUM`, consultare [Ottimizzare le tabelle Iceberg](querying-iceberg-data-optimization.md). Tieni presente che, poiché l'istruzione `VACUUM` effettua chiamate API ad Amazon S3, vengono addebitati costi per le richieste associate ad Amazon S3. **avvertimento** Se si esegue un'operazione di scadenza delle snapshot, non è più possibile accedere alle snapshot scadute. ## Riepilogo Per rimuovere i file di dati non più necessari per una tabella Iceberg, utilizza la sintassi seguente. ``` VACUUM [database_name.]target_table ``` + `VACUUM` prevede che i dati Iceberg si trovino in una cartella Amazon S3 anziché in un bucket Amazon S3. Ad esempio, se i dati di Iceberg si trovano in `s3://amzn-s3-demo-bucket`/anziché in`s3://amzn-s3-demo-bucket/myicebergfolder/`, l’istruzione `VACUUM` ha esito negativo e viene visualizzato il messaggio di errore GENERIC\$1INTERNAL\$1ERROR: Path missing in file system location: `s3://amzn-s3-demo-bucket`. + Affinché `VACUUM` possa eliminare i file di dati, il ruolo di esecuzione delle query deve disporre delle autorizzazioni `s3:DeleteObject` sul bucket in cui si trovano le tabelle, i metadati, le istantanee e i file di dati Iceberg. Se l’autorizzazione non è presente, la query `VACUUM` avrà esito positivo, ma i file non verranno eliminati. + Per eseguire `VACUUM` su una tabella il cui nome inizia con un carattere di sottolineatura (ad esempio, `_mytable`), racchiudere il nome della tabella tra segni di spunta rovesciati, come nell’esempio seguente. Se si antepone un nome di database al nome della tabella, non racchiudere il nome del database tra segni di spunta rovesciati. Nota che le virgolette doppie non funzioneranno al posto dei segni di spunta rovesciati. Questo comportamento è specifico di `VACUUM`. Le istruzioni `CREATE` e `INSERT INTO` non richiedono il segno di spunta rovesciato per i nomi di tabella che iniziano con caratteri di sottolineatura. ``` VACUUM `_mytable` VACUUM my_database.`_mytable` ``` ## Operazioni eseguite `VACUUM` esegue le seguenti operazioni: + Rimuove gli snapshot che sono più vecchi del periodo di tempo specificato dalla proprietà della tabella `vacuum_max_snapshot_age_seconds`. Per impostazione predefinita, questa proprietà è impostata su 432.000 secondi (5 giorni). + Rimuove gli snapshot che non rientrano nel periodo da mantenere e che superano il numero specificato dalla proprietà della tabella `vacuum_min_snapshots_to_keep`. Il valore di default è 1. Puoi specificare queste proprietà della tabella nell'istruzione `CREATE TABLE`. Dopo aver creato la tabella, puoi utilizzare l'istruzione [ALTER TABLE SET TBLPROPERTIES](querying-iceberg-alter-table-set-properties.md) per aggiornarle. + Rimuove tutti i metadati e i file di dati che non sono raggiungibili a seguito della rimozione dello snapshot. Puoi configurare il numero di vecchi file di metadati da conservare impostando la proprietà della tabella `vacuum_max_metadata_files_to_keep`. Il valore predefinito è 100. + Rimuove i file orfani più vecchi del tempo specificato nella proprietà della tabella `vacuum_max_snapshot_age_seconds`. I file orfani sono file nella directory dei dati della tabella che non fanno parte dello stato della tabella. Per ulteriori informazioni sulla creazione e sulla gestione delle tabelle Apache Iceberg in Athena, consulta le sezioni [Creazione di una tabella Iceberg](querying-iceberg-creating-tables.md) e [Gestione di tabelle Iceberg](querying-iceberg-managing-tables.md). # Utilizzo di EXPLAIN e EXPLAIN ANALYZE in Athena L'istruzione `EXPLAIN` mostra il piano di esecuzione logico o distribuito di un'istruzione SQL specificata o convalida l'istruzione SQL. È possibile generare i risultati in formato testo o in formato dati per il rendering in un grafico. **Nota** È possibile visualizzare rappresentazioni grafiche di piani logici e distribuiti per le proprie query nella console Athena senza utilizzare la sintassi `EXPLAIN`. Per ulteriori informazioni, consulta [Visualizzare i piani di esecuzione per query SQL](query-plans.md). L'istruzione `EXPLAIN ANALYZE` mostra sia il piano di esecuzione distribuito di un'istruzione SQL specificata che il costo computazionale di ciascuna operazione in una query SQL. È possibile eseguire l'output dei risultati in formato testo o JSON. ## Considerazioni e limitazioni Le istruzioni `EXPLAIN` e `EXPLAIN ANALYZE` in Athena hanno le seguenti limitazioni. + Poiché le query `EXPLAIN` non scansionano alcun dato, Athena non addebita alcun costo per loro. Tuttavia, poiché le query `EXPLAIN` effettuano chiamate a AWS Glue per recuperare i metadati della tabella, potresti ricevere addebiti da Glue se le chiamate superano il [limite del piano gratuito per Glue](https://aws.amazon.com/free/?all-free-tier.sort-by=item.additionalFields.SortRank&all-free-tier.sort-order=asc&awsf.Free%20Tier%20Categories=categories%23analytics&all-free-tier.q=glue&all-free-tier.q_operator=AND). + Poiché vengono eseguite le query `EXPLAIN ANALYZE`, viene eseguita la scansione dei dati e Athena addebita la quantità di dati scansionati. + Le informazioni sul filtraggio di righe o celle definite in Lake Formation e le informazioni sulle statistiche delle query non vengono visualizzate nell'output di `EXPLAIN` e `EXPLAIN ANALYZE`. ## Sintassi EXPLAIN ``` EXPLAIN [ ( option [, ...]) ] statement ``` *option*Il valore di può essere uno dei seguenti: ``` FORMAT { TEXT | GRAPHVIZ | JSON } TYPE { LOGICAL | DISTRIBUTED | VALIDATE | IO } ``` Se l'opzione `FORMAT` non è specificata, l'output avrà il formato di default `TEXT`. Il tipo `IO` fornisce informazioni sulle tabelle e sugli schemi letti dalla query. ## Sintassi EXPLAIN ANALYZE Oltre all'output incluso in `EXPLAIN`, l'output `EXPLAIN ANALYZE` include anche statistiche del runtime per la query specificata, ad esempio l'utilizzo della CPU, l'input del numero di righe e l'output del numero di righe. ``` EXPLAIN ANALYZE [ ( option [, ...]) ] statement ``` *option*Il valore di può essere uno dei seguenti: ``` FORMAT { TEXT | JSON } ``` Se l'opzione `FORMAT` non è specificata, l'output avrà il formato di default `TEXT`. Perché tutte le query per `EXPLAIN ANALYZE` sono `DISTRIBUTED`, l'opzione `TYPE` non è disponibile per `EXPLAIN ANALYZE`. *statement*Il valore di può essere uno dei seguenti: ``` SELECT CREATE TABLE AS SELECT INSERT UNLOAD ``` ## Esempi di EXPLAIN Gli esempi seguenti per l'avanzamento di `EXPLAIN` vanno dai più semplici ai più complessi. ### Esempio 1: utilizza l’istruzione EXPLAIN per mostrare un piano di query in formato testo. Nell'esempio seguente, `EXPLAIN` mostra il piano di esecuzione per una query `SELECT` nei log di Elastic Load Balancing. Il formato viene impostato per impostazione predefinita sull'output di testo. ``` EXPLAIN SELECT request_timestamp, elb_name, request_ip FROM sampledb.elb_logs; ``` #### Risultati ``` - Output[request_timestamp, elb_name, request_ip] => [[request_timestamp, elb_name, request_ip]] - RemoteExchange[GATHER] => [[request_timestamp, elb_name, request_ip]] - TableScan[awsdatacatalog:HiveTableHandle{schemaName=sampledb, tableName=elb_logs, analyzePartitionValues=Optional.empty}] => [[request_timestamp, elb_name, request_ip]] LAYOUT: sampledb.elb_logs request_ip := request_ip:string:2:REGULAR request_timestamp := request_timestamp:string:0:REGULAR elb_name := elb_name:string:1:REGULAR ``` ### Esempio 2: utilizza l’istruzione EXPLAIN per eseguire un grafico del piano di query Puoi usare la console Athena per eseguire un grafico su un piano di query. Inserisci un'istruzione `SELECT` come la seguente nell'editor di query, quindi seleziona **Run** (Esegui). ``` SELECT c.c_custkey, o.o_orderkey, o.o_orderstatus FROM tpch100.customer c JOIN tpch100.orders o ON c.c_custkey = o.o_custkey ``` La pagina **Explain** dell'editor di query Athena si apre e mostra un piano distribuito e un piano logico per la query. Il seguente grafico mostra il piano logico per l'esempio. ![\[Grafico del piano di query reso dall'editor di query Athena.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/athena-explain-statement-tpch.png) **Importante** Attualmente, alcuni filtri di partizione potrebbero non essere visibili nel grafico ad albero degli operatori annidato anche se Athena li applica alla tua query. Per verificare l'effetto di tali filtri, esegui `EXPLAIN` o `EXPLAIN ANALYZE` sulla query e visualizza i risultati. Per ulteriori informazioni sull'utilizzo delle funzionalità grafiche del piano di query nella console Athena, consulta [Visualizzare i piani di esecuzione per query SQL](query-plans.md). ### Esempio 3: utilizza l’istruzione EXPLAIN per verificare la cesura delle partizioni. Quando si utilizza un predicato di filtro in una chiave partizionata per eseguire una query su una tabella partizionata, il motore di query applica il predicato alla chiave partizionata per ridurre la quantità di dati letti. Nell'esempio seguente viene utilizzato una query `EXPLAIN` per verificare la cesura delle partizioni per una query `SELECT` su una tabella partizionata. Innanzitutto, un'istruzione `CREATE TABLE`crea la tabella `tpch100.orders_partitioned`. La tabella è partizionata sulla colonna `o_orderdate`. ``` CREATE TABLE `tpch100.orders_partitioned`( `o_orderkey` int, `o_custkey` int, `o_orderstatus` string, `o_totalprice` double, `o_orderpriority` string, `o_clerk` string, `o_shippriority` int, `o_comment` string) PARTITIONED BY ( `o_orderdate` string) ROW FORMAT SERDE 'org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe' STORED AS INPUTFORMAT 'org.apache.hadoop.hive.ql.io.parquet.MapredParquetInputFormat' OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.parquet.MapredParquetOutputFormat' LOCATION 's3://amzn-s3-demo-bucket//' ``` La tabella `tpch100.orders_partitioned` ha diverse partizioni su `o_orderdate`, come mostrato dal comando `SHOW PARTITIONS`. ``` SHOW PARTITIONS tpch100.orders_partitioned; o_orderdate=1994 o_orderdate=2015 o_orderdate=1998 o_orderdate=1995 o_orderdate=1993 o_orderdate=1997 o_orderdate=1992 o_orderdate=1996 ``` La seguente query `EXPLAIN` verifica la cesura delle partizioni sull'istruzione `SELECT`specificata. ``` EXPLAIN SELECT o_orderkey, o_custkey, o_orderdate FROM tpch100.orders_partitioned WHERE o_orderdate = '1995' ``` #### Risultati ``` Query Plan - Output[o_orderkey, o_custkey, o_orderdate] => [[o_orderkey, o_custkey, o_orderdate]] - RemoteExchange[GATHER] => [[o_orderkey, o_custkey, o_orderdate]] - TableScan[awsdatacatalog:HiveTableHandle{schemaName=tpch100, tableName=orders_partitioned, analyzePartitionValues=Optional.empty}] => [[o_orderkey, o_custkey, o_orderdate]] LAYOUT: tpch100.orders_partitioned o_orderdate := o_orderdate:string:-1:PARTITION_KEY :: [[1995]] o_custkey := o_custkey:int:1:REGULAR o_orderkey := o_orderkey:int:0:REGULAR ``` Il testo in grassetto nel risultato mostra che il predicato `o_orderdate = '1995'` è stato applicato su `PARTITION_KEY`. ### Esempio 4: utilizza una query EXPLAIN per verificare l’ordine e il tipo di join. La seguente query `EXPLAIN` verifica l'ordine di join e il tipo di join dell'istruzione `SELECT`. Utilizzare una query come questa per esaminare l'utilizzo della memoria della query in modo da ridurre le possibilità di ottenere un errore `EXCEEDED_LOCAL_MEMORY_LIMIT`. ``` EXPLAIN (TYPE DISTRIBUTED) SELECT c.c_custkey, o.o_orderkey, o.o_orderstatus FROM tpch100.customer c JOIN tpch100.orders o ON c.c_custkey = o.o_custkey WHERE c.c_custkey = 123 ``` #### Risultati ``` Query Plan Fragment 0 [SINGLE] Output layout: [c_custkey, o_orderkey, o_orderstatus] Output partitioning: SINGLE [] Stage Execution Strategy: UNGROUPED_EXECUTION - Output[c_custkey, o_orderkey, o_orderstatus] => [[c_custkey, o_orderkey, o_orderstatus]] - RemoteSource[1] => [[c_custkey, o_orderstatus, o_orderkey]] Fragment 1 [SOURCE] Output layout: [c_custkey, o_orderstatus, o_orderkey] Output partitioning: SINGLE [] Stage Execution Strategy: UNGROUPED_EXECUTION - CrossJoin => [[c_custkey, o_orderstatus, o_orderkey]] Distribution: REPLICATED - ScanFilter[table = awsdatacatalog:HiveTableHandle{schemaName=tpch100, tableName=customer, analyzePartitionValues=Optional.empty}, grouped = false, filterPredicate = ("c_custkey" = 123)] => [[c_custkey]] LAYOUT: tpch100.customer c_custkey := c_custkey:int:0:REGULAR - LocalExchange[SINGLE] () => [[o_orderstatus, o_orderkey]] - RemoteSource[2] => [[o_orderstatus, o_orderkey]] Fragment 2 [SOURCE] Output layout: [o_orderstatus, o_orderkey] Output partitioning: BROADCAST [] Stage Execution Strategy: UNGROUPED_EXECUTION - ScanFilterProject[table = awsdatacatalog:HiveTableHandle{schemaName=tpch100, tableName=orders, analyzePartitionValues=Optional.empty}, grouped = false, filterPredicate = ("o_custkey" = 123)] => [[o_orderstatus, o_orderkey]] LAYOUT: tpch100.orders o_orderstatus := o_orderstatus:string:2:REGULAR o_custkey := o_custkey:int:1:REGULAR o_orderkey := o_orderkey:int:0:REGULAR ``` La query di esempio è stata ottimizzata in un cross join per prestazioni migliori. I risultati mostrano che `tpch100.orders` sarà distribuito come tipo di distribuzione `BROADCAST`. Ciò implica che la tabella `tpch100.orders` verrà distribuita a tutti i nodi che eseguono l'operazione di join. Il tipo di distribuzione `BROADCAST` richiederà che tutti i risultati filtrati della tabella `tpch100.orders` siano inseriti nella memoria di ogni nodo che esegue l'operazione di join. Tuttavia, la tabella `tpch100.customer` è più piccola di `tpch100.orders`. Poiché `tpch100.customer` richiede meno memoria, è possibile riscrivere la query su `BROADCAST tpch100.customer` invece che su `tpch100.orders`. In questo modo si riduce la possibilità che la query riceva l'errore `EXCEEDED_LOCAL_MEMORY_LIMIT`. La strategia presuppone i seguenti punti: + `tpch100.customer.c_custkey` è unico nella tabella `tpch100.customer`. + Esiste una relazione di one-to-many mappatura tra `tpch100.customer` e`tpch100.orders`. L'esempio seguente mostra la query riscritta. ``` SELECT c.c_custkey, o.o_orderkey, o.o_orderstatus FROM tpch100.orders o JOIN tpch100.customer c -- the filtered results of tpch100.customer are distributed to all nodes. ON c.c_custkey = o.o_custkey WHERE c.c_custkey = 123 ``` ### Esempio 5: utilizza una query EXPLAIN per rimuovere i predicati che non hanno effetto Puoi utilizzare una query `EXPLAIN` per verificare l'efficacia dei predicati di filtraggio. È possibile utilizzare i risultati per rimuovere i predicati che non hanno alcun effetto, come nell'esempio seguente. ``` EXPLAIN SELECT c.c_name FROM tpch100.customer c WHERE c.c_custkey = CAST(RANDOM() * 1000 AS INT) AND c.c_custkey BETWEEN 1000 AND 2000 AND c.c_custkey = 1500 ``` #### Risultati ``` Query Plan - Output[c_name] => [[c_name]] - RemoteExchange[GATHER] => [[c_name]] - ScanFilterProject[table = awsdatacatalog:HiveTableHandle{schemaName=tpch100, tableName=customer, analyzePartitionValues=Optional.empty}, filterPredicate = (("c_custkey" = 1500) AND ("c_custkey" = CAST(("random"() * 1E3) AS int)))] => [[c_name]] LAYOUT: tpch100.customer c_custkey := c_custkey:int:0:REGULAR c_name := c_name:string:1:REGULAR ``` `filterPredicate` nei risultati mostra che l'ottimizzatore ha unito i tre predicati originali in due predicati e ha cambiato il loro ordine di applicazione. ``` filterPredicate = (("c_custkey" = 1500) AND ("c_custkey" = CAST(("random"() * 1E3) AS int))) ``` Poiché i risultati mostrano che il predicato `AND c.c_custkey BETWEEN 1000 AND 2000` non ha alcun effetto, è possibile rimuovere questo predicato senza modificare i risultati della query. Per informazioni sui termini utilizzati nei risultati delle query `EXPLAIN`, consulta [Capire i risultati dell’istruzione EXPLAIN di Athena](athena-explain-statement-understanding.md). ## Esempi di EXPLAIN ANALYZE Gli esempi seguenti mostrano query e output `EXPLAIN ANALYZE` di esempio. ### Esempio 1: utilizza EXPLAIN ANALYZE per mostrare il piano di una query e il costo computazionale in formato di testo. Nell'esempio seguente, vengono `EXPLAIN ANALYZE` illustrati il piano di esecuzione e i costi di calcolo per una `SELECT` query sui CloudFront log. Il formato viene impostato per impostazione predefinita sull'output di testo. ``` EXPLAIN ANALYZE SELECT FROM cloudfront_logs LIMIT 10 ``` #### Risultati ``` Fragment 1 CPU: 24.60ms, Input: 10 rows (1.48kB); per task: std.dev.: 0.00, Output: 10 rows (1.48kB) Output layout: [date, time, location, bytes, requestip, method, host, uri, status, referrer,\ os, browser, browserversion] Limit[10] => [[date, time, location, bytes, requestip, method, host, uri, status, referrer, os,\ browser, browserversion]] CPU: 1.00ms (0.03%), Output: 10 rows (1.48kB) Input avg.: 10.00 rows, Input std.dev.: 0.00% LocalExchange[SINGLE] () => [[date, time, location, bytes, requestip, method, host, uri, status, referrer, os,\ browser, browserversion]] CPU: 0.00ns (0.00%), Output: 10 rows (1.48kB) Input avg.: 0.63 rows, Input std.dev.: 387.30% RemoteSource[2] => [[date, time, location, bytes, requestip, method, host, uri, status, referrer, os,\ browser, browserversion]] CPU: 1.00ms (0.03%), Output: 10 rows (1.48kB) Input avg.: 0.63 rows, Input std.dev.: 387.30% Fragment 2 CPU: 3.83s, Input: 998 rows (147.21kB); per task: std.dev.: 0.00, Output: 20 rows (2.95kB) Output layout: [date, time, location, bytes, requestip, method, host, uri, status, referrer, os,\ browser, browserversion] LimitPartial[10] => [[date, time, location, bytes, requestip, method, host, uri, status, referrer, os,\ browser, browserversion]] CPU: 5.00ms (0.13%), Output: 20 rows (2.95kB) Input avg.: 166.33 rows, Input std.dev.: 141.42% TableScan[awsdatacatalog:HiveTableHandle{schemaName=default, tableName=cloudfront_logs,\ analyzePartitionValues=Optional.empty}, grouped = false] => [[date, time, location, bytes, requestip, method, host, uri, st CPU: 3.82s (99.82%), Output: 998 rows (147.21kB) Input avg.: 166.33 rows, Input std.dev.: 141.42% LAYOUT: default.cloudfront_logs date := date:date:0:REGULAR referrer := referrer:string:9:REGULAR os := os:string:10:REGULAR method := method:string:5:REGULAR bytes := bytes:int:3:REGULAR browser := browser:string:11:REGULAR host := host:string:6:REGULAR requestip := requestip:string:4:REGULAR location := location:string:2:REGULAR time := time:string:1:REGULAR uri := uri:string:7:REGULAR browserversion := browserversion:string:12:REGULAR status := status:int:8:REGULAR ``` ### Esempio 2: utilizza EXPLAIN ANALYZE per mostrare un piano di query in formato JSON. L'esempio seguente mostra il piano di esecuzione e i costi di calcolo per una `SELECT` query sui log. CloudFront L'esempio specifica JSON come formato di output. ``` EXPLAIN ANALYZE (FORMAT JSON) SELECT * FROM cloudfront_logs LIMIT 10 ``` #### Risultati ``` { "fragments": [{ "id": "1", "stageStats": { "totalCpuTime": "3.31ms", "inputRows": "10 rows", "inputDataSize": "1514B", "stdDevInputRows": "0.00", "outputRows": "10 rows", "outputDataSize": "1514B" }, "outputLayout": "date, time, location, bytes, requestip, method, host,\ uri, status, referrer, os, browser, browserversion", "logicalPlan": { "1": [{ "name": "Limit", "identifier": "[10]", "outputs": ["date", "time", "location", "bytes", "requestip", "method", "host",\ "uri", "status", "referrer", "os", "browser", "browserversion"], "details": "", "distributedNodeStats": { "nodeCpuTime": "0.00ns", "nodeOutputRows": 10, "nodeOutputDataSize": "1514B", "operatorInputRowsStats": [{ "nodeInputRows": 10.0, "nodeInputRowsStdDev": 0.0 }] }, "children": [{ "name": "LocalExchange", "identifier": "[SINGLE] ()", "outputs": ["date", "time", "location", "bytes", "requestip", "method", "host",\ "uri", "status", "referrer", "os", "browser", "browserversion"], "details": "", "distributedNodeStats": { "nodeCpuTime": "0.00ns", "nodeOutputRows": 10, "nodeOutputDataSize": "1514B", "operatorInputRowsStats": [{ "nodeInputRows": 0.625, "nodeInputRowsStdDev": 387.2983346207417 }] }, "children": [{ "name": "RemoteSource", "identifier": "[2]", "outputs": ["date", "time", "location", "bytes", "requestip", "method", "host",\ "uri", "status", "referrer", "os", "browser", "browserversion"], "details": "", "distributedNodeStats": { "nodeCpuTime": "0.00ns", "nodeOutputRows": 10, "nodeOutputDataSize": "1514B", "operatorInputRowsStats": [{ "nodeInputRows": 0.625, "nodeInputRowsStdDev": 387.2983346207417 }] }, "children": [] }] }] }] } }, { "id": "2", "stageStats": { "totalCpuTime": "1.62s", "inputRows": "500 rows", "inputDataSize": "75564B", "stdDevInputRows": "0.00", "outputRows": "10 rows", "outputDataSize": "1514B" }, "outputLayout": "date, time, location, bytes, requestip, method, host, uri, status,\ referrer, os, browser, browserversion", "logicalPlan": { "1": [{ "name": "LimitPartial", "identifier": "[10]", "outputs": ["date", "time", "location", "bytes", "requestip", "method", "host", "uri",\ "status", "referrer", "os", "browser", "browserversion"], "details": "", "distributedNodeStats": { "nodeCpuTime": "0.00ns", "nodeOutputRows": 10, "nodeOutputDataSize": "1514B", "operatorInputRowsStats": [{ "nodeInputRows": 83.33333333333333, "nodeInputRowsStdDev": 223.60679774997897 }] }, "children": [{ "name": "TableScan", "identifier": "[awsdatacatalog:HiveTableHandle{schemaName=default,\ tableName=cloudfront_logs, analyzePartitionValues=Optional.empty},\ grouped = false]", "outputs": ["date", "time", "location", "bytes", "requestip", "method", "host", "uri",\ "status", "referrer", "os", "browser", "browserversion"], "details": "LAYOUT: default.cloudfront_logs\ndate := date:date:0:REGULAR\nreferrer :=\ referrer: string:9:REGULAR\nos := os:string:10:REGULAR\nmethod := method:string:5:\ REGULAR\nbytes := bytes:int:3:REGULAR\nbrowser := browser:string:11:REGULAR\nhost :=\ host:string:6:REGULAR\nrequestip := requestip:string:4:REGULAR\nlocation :=\ location:string:2:REGULAR\ntime := time:string:1: REGULAR\nuri := uri:string:7:\ REGULAR\nbrowserversion := browserversion:string:12:REGULAR\nstatus :=\ status:int:8:REGULAR\n", "distributedNodeStats": { "nodeCpuTime": "1.62s", "nodeOutputRows": 500, "nodeOutputDataSize": "75564B", "operatorInputRowsStats": [{ "nodeInputRows": 83.33333333333333, "nodeInputRowsStdDev": 223.60679774997897 }] }, "children": [] }] }] } }] } ``` ## Risorse aggiuntive Per ulteriori informazioni consulta le seguenti risorse. + [Capire i risultati dell’istruzione EXPLAIN di Athena](athena-explain-statement-understanding.md) + [Visualizzare i piani di esecuzione per query SQL](query-plans.md) + [Visualizzazione di statistiche e dettagli di esecuzione per le query completate](query-stats.md) + Documentazione [https://trino.io/docs/current/sql/explain.html](https://trino.io/docs/current/sql/explain.html) di Trino + Documentazione [https://trino.io/docs/current/sql/explain-analyze.html](https://trino.io/docs/current/sql/explain-analyze.html) di Trino + [Ottimizzazione delle prestazioni delle query federate con EXPLAIN e EXPLAIN ANALYZE in Amazon Athena](https://aws.amazon.com/blogs/big-data/optimize-federated-query-performance-using-explain-and-explain-analyze-in-amazon-athena/) nel *Blog sui Big Data di AWS *. [![AWS Videos](http://img.youtube.com/vi/https://www.youtube.com/embed/7JUyTqglmNU/0.jpg)](http://www.youtube.com/watch?v=https://www.youtube.com/embed/7JUyTqglmNU) # Capire i risultati dell’istruzione EXPLAIN di Athena Questo argomento fornisce una breve guida ai termini operativi utilizzati nei risultati dell'istruzione `EXPLAIN` di Athena. ## Tipi di output dell'istruzione EXPLAIN Gli output dell'istruzione `EXPLAIN` possono essere uno dei due tipi: + **Piano logico**: mostra il piano logico utilizzato dal motore SQL per eseguire un'istruzione. La sintassi per quest'opzione è `EXPLAIN` o `EXPLAIN (TYPE LOGICAL)`. + **Piano distribuito**: mostra un piano di esecuzione in un ambiente distribuito. L'output mostra frammenti che stanno elaborando fasi. Ogni frammento del piano viene elaborato da uno o più nodi. I dati possono essere scambiati tra i nodi che elaborano i frammenti. La sintassi per quest'opzione è `EXPLAIN (TYPE DISTRIBUTED)`. Nell'output di un piano distribuito, i frammenti (fasi di elaborazione) sono indicati da `Fragment` *number* [*fragment\$1type*], dove *number* è un numero intero a base zero e *fragment\$1type* specifica come il frammento viene eseguito dai nodi. I tipi di frammento che forniscono informazioni dettagliate sul layout dello scambio di dati sono descritti nella tabella seguente. **Tipi di frammento del piano distribuito** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/athena-explain-statement-understanding.html) ## Exchange I termini relativi a Exchange descrivono il modo in cui i dati vengono scambiati tra i nodi di lavoro. I trasferimenti possono essere locali o remoti. **LocalExchange [*exchange\$1type*] ** Trasferisce i dati localmente all'interno dei nodi di lavoro per le diverse fasi di una query. Il valore per *exchange\$1type* può essere uno dei tipi di scambio logico o distribuito, come descritto più avanti in questa sezione. **RemoteExchange [*exchange\$1type*] ** Trasferisce i dati tra i nodi di lavoro per le diverse fasi di una query. Il valore per *exchange\$1type* può essere uno dei tipi di scambio logico o distribuito, come descritto più avanti in questa sezione. ### Tipi di scambio logico I seguenti tipi di scambio descrivono le operazioni intraprese durante la fase di scambio di un piano logico. + **`GATHER`** – un singolo nodo worker raccoglie l'output da tutti gli altri nodi di lavoro. Ad esempio, l'ultima fase di una query di selezione raccoglie i risultati da tutti i nodi e li scrive su Amazon S3. + **`REPARTITION`**: invia i dati di riga a un dipendente specifico in base allo schema di partizionamento necessario per applicare all'operatore successivo. + **`REPLICATE`**: copia i dati della riga per tutti i lavoratori. ### Tipi di scambio distribuiti I seguenti tipi di scambio indicano il layout dei dati quando vengono scambiati tra nodi in un piano distribuito. + **`HASH`**: lo scambio distribuisce i dati a più destinazioni utilizzando una funzione hash. + **`SINGLE`**: Lo scambio distribuisce i dati a una singola destinazione. ## Scansione I seguenti termini descrivono come vengono analizzati i dati durante una query. **TableScan ** Analizza i dati di origine di una tabella da Amazon S3 o da un connettore Apache Hive e applica la potatura delle partizioni generata dal predicato del filtro. **ScanFilter ** Esegue la scansione dei dati di origine di una tabella da Amazon S3 o da un connettore Hive e applica la cesura delle partizioni generata dal predicato filtro e da predicati filtro aggiuntivi non applicati tramite la cesura delle partizioni. **ScanFilterProject ** Per prima cosa esegue la scansione dei dati di origine di una tabella da Amazon S3 o da un connettore Hive e applica la cesura delle partizioni generata dal predicato filtro e da predicati filtro aggiuntivi non applicati tramite la cesura delle partizioni. Quindi, modifica il layout di memoria dei dati di output in una nuova proiezione per migliorare le prestazioni delle fasi successive. ## Join Unisce i dati tra due tabelle. I join possono essere classificati in base al tipo di join e al tipo di distribuzione. ### Tipi di join I tipi di join definiscono il modo in cui si verifica l'operazione di join. **CrossJoin**— Produce il prodotto cartesiano delle due tavole unite. **InnerJoin**— Seleziona i record con valori corrispondenti in entrambe le tabelle. **LeftJoin**— Seleziona tutti i record dalla tabella di sinistra e i record corrispondenti dalla tabella di destra. Se non sussiste alcuna corrispondenza, il risultato sul lato destro è NULL. **RightJoin**— Seleziona tutti i record dalla tabella di destra e i record corrispondenti dalla tabella di sinistra. Se non sussiste alcuna corrispondenza, il risultato sul lato sinistro è NULL. **FullJoin**— Seleziona tutti i record in cui è presente una corrispondenza nei record della tabella sinistra o destra. La tabella unita contiene tutti i record di entrambe le tabelle e sostituisce le corrispondenze mancanti su entrambi i lati. NULLs **Nota** Per motivi di prestazioni, il motore di query può riscrivere una query di join in un tipo di join diverso per produrre gli stessi risultati. Ad esempio, una query inner join con predicato su una tabella può essere riscritta in `CrossJoin`. In questo modo il predicato viene spostato fino alla fase di scansione della tabella in modo che vengano scansionati meno dati. ### Tipi di distribuzione join I tipi di distribuzione definiscono il modo in cui i dati vengono scambiati tra i nodi di lavoro quando viene eseguita l'operazione di join. **Partizionata**: sia la tabella sinistra che quella destra sono partizionate in hash-su tutti i nodi (worker). La distribuzione partizionata consuma meno memoria in ogni nodo. La distribuzione partizionata può essere molto più lenta dei join replicati. I join partizionati sono adatti quando si uniscono due tabelle di grandi dimensioni. **Replicata**: una tabella è partizionata in hash su tutti i nodi di lavoro e l'altra tabella viene replicata in tutti i nodi di lavoro per eseguire l'operazione di join. La distribuzione replicata può essere molto più veloce dei join partizionati, ma consuma più memoria in ogni nodo worker. Se la tabella replicata è troppo grande, il nodo di lavoro può riscontrare un out-of-memory errore. I join replicati sono adatti quando una delle tabelle unite è piccola. # PREPARE Crea un'istruzione SQL con il nome `statement_name` da eseguire in un secondo momento. L'istruzione può includere parametri rappresentati da punti interrogativi. Per fornire valori per i parametri ed eseguire l'istruzione preparata, utilizza [EXECUTE](sql-execute.md). ## Riepilogo ``` PREPARE statement_name FROM statement ``` Nella tabella seguente vengono descritti questi parametri. **** | Parametro | Description | | --- | --- | | statement\$1name | Il nome dell'istruzione da preparare. Il nome deve essere univoco all'interno del gruppo di lavoro. | | statement | Una query SELECT, CTAS o INSERT INTO. | **Nota** Il numero massimo di istruzioni preparate in un gruppo di lavoro è 1.000. ## Esempi L'esempio seguente prepara una query di selezione senza parametri. ``` PREPARE my_select1 FROM SELECT * FROM nation ``` L'esempio seguente prepara una query di selezione che include i parametri. I valori per `productid` e `quantity` verranno forniti dalla clausola `USING` di un’istruzione `EXECUTE`: ``` PREPARE my_select2 FROM SELECT order FROM orders WHERE productid = ? and quantity < ? ``` L'esempio seguente prepara una query insert. ``` PREPARE my_insert FROM INSERT INTO cities_usa (city, state) SELECT city, state FROM cities_world WHERE country = ? ``` ## Risorse aggiuntive [Utilizzare istruzioni preparate](querying-with-prepared-statements-querying.md) [EXECUTE](sql-execute.md) [DEALLOCATE PREPARE](sql-deallocate-prepare.md) [INSERT INTO](insert-into.md) # EXECUTE Esegue un'istruzione preparata con il nome `statement_name`. I valori dei parametri per i punti interrogativi nell’istruzione preparata sono definiti nella clausola `USING` in un'elenco separato da virgole. Per creare un'istruzione preparata, utilizza [PREPARE](sql-prepare.md). ## Riepilogo ``` EXECUTE statement_name [ USING parameter1[, parameter2, ... ] ] ``` ## Esempi L'esempio seguente prepara ed esegue una query di selezione senza parametri. ``` PREPARE my_select1 FROM SELECT name FROM nation EXECUTE my_select1 ``` L'esempio seguente prepara ed esegue una query di selezione con un parametro. ``` PREPARE my_select2 FROM SELECT * FROM "my_database"."my_table" WHERE year = ? EXECUTE my_select2 USING 2012 ``` Ciò equivale a: ``` SELECT * FROM "my_database"."my_table" WHERE year = 2012 ``` L'esempio seguente prepara ed esegue una query di selezione con due parametri. ``` PREPARE my_select3 FROM SELECT order FROM orders WHERE productid = ? and quantity < ? EXECUTE my_select3 USING 346078, 12 ``` ## Risorse aggiuntive [Utilizzare istruzioni preparate](querying-with-prepared-statements-querying.md) [PREPARE](sql-prepare.md) [INSERT INTO](insert-into.md) # DEALLOCATE PREPARE Rimuove l'istruzione preparata con il nome specificato dalle istruzioni preparate nel gruppo di lavoro corrente. ## Riepilogo ``` DEALLOCATE PREPARE statement_name ``` ## Esempi L'esempio seguente rimuove l'istruzione preparata `my_select1` dal gruppo di lavoro corrente. ``` DEALLOCATE PREPARE my_select1 ``` ## Risorse aggiuntive [Utilizzare istruzioni preparate](querying-with-prepared-statements-querying.md) [PREPARE](sql-prepare.md) # UNLOAD Scrive i risultati delle query da un'istruzione `SELECT` al formato di dati specificato. I formati supportati per `UNLOAD` includono Apache Parquet, ORC, Apache Avro e JSON. CSV è l’unico formato di output supportato dal comando `SELECT` Athena, ma è possibile utilizzare `UNLOAD` il comando, che supporta diversi formati di output, per racchiudere `SELECT` la query e riscriverne l’output in uno dei formati supportati. `UNLOAD` Sebbene sia possibile utilizzare l’istruzione `CREATE TABLE AS` (CTAS) per generare dati in formati diversi da CSV, le istruzioni CTAS richiedono anche la creazione di una tabella in Athena. L’istruzione `UNLOAD` è utile quando si desidera generare i risultati di una query `SELECT` in un formato non CSV ma non richiedono la tabella associata. Ad esempio, un'applicazione downstream potrebbe richiedere i risultati di una query `SELECT` in formato JSON, e Parquet o ORC potrebbe fornire un vantaggio in termini di prestazioni rispetto a CSV se si intende utilizzare i risultati della query `SELECT` per ulteriori analisi. ## Considerazioni e limitazioni Quando utilizzi l'istruzione `UNLOAD` in Athena, devi considerare quanto segue: + **Nessun ordine globale dei file** – I risultati `UNLOAD` vengono scritti in più file in parallelo. Se la query `SELECT` nell'istruzione `UNLOAD` specifica un ordine, il contenuto di ogni file è in ordine ordinato, ma i file non sono ordinati l'uno rispetto all'altro. + **Dati orfani non eliminati** — In caso di guasto, Athena non tenta di eliminare i dati orfani. Questo comportamento è lo stesso per CTAS e per le istruzioni `INSERT INTO`. + **Partizioni massime**: Il numero massimo di partizioni che possono essere utilizzate con `UNLOAD` è 100. + **File manifest e metadati** — Athena genera un file di metadati e un file manifesto di dati per ogni query `UNLOAD`. Il manifesto tiene traccia dei file scritti dalla query. Entrambi i file vengono salvati nella posizione dei risultati della query Athena in Amazon S3. Per ulteriori informazioni, consulta [Identificazione dei file di output delle query](querying-finding-output-files.md#querying-identifying-output-files). + **Crittografia** – `UNLOAD` vengono crittografati in base alla configurazione di crittografia utilizzata per Amazon S3. Per configurare la configurazione di crittografia per crittografare i `UNLOAD` risultati, puoi utilizzare l'[EncryptionConfiguration API](https://docs.aws.amazon.com/athena/latest/APIReference/API_EncryptionConfiguration.html). + **Istruzioni preparate** – `UNLOAD` può essere utilizzato con istruzioni preparate. Per informazioni sulle istruzioni preparate in Athena, consulta [Utilizzare query parametrizzate](querying-with-prepared-statements.md). + **Service quotas**: `UNLOAD` utilizza le quote di query DML. Per informazioni sulle quote, consulta [Service Quotas](service-limits.md). + **Proprietario previsto del bucket**: l'impostazione relativa al proprietario previsto del bucket non si applica al percorso del bucket Amazon S3 di destinazione specificato nella query `UNLOAD`. L'impostazione attesa relativa al proprietario del bucket si applica solo al percorso di output di Amazon S3 specificato per i risultati delle query di Athena. Per ulteriori informazioni, consulta [Specificare una posizione dei risultati delle query utilizzando la console Athena](query-results-specify-location-console.md). ## Sintassi L'istruzione `UNLOAD` utilizza la sintassi seguente. ``` UNLOAD (SELECT col_name[, ...] FROM old_table) TO 's3://amzn-s3-demo-bucket/my_folder/' WITH ( property_name = 'expression' [, ...] ) ``` La destinazione `TO` deve specificare una posizione in Amazon S3 che non contiene dati. Prima che la query `UNLOAD` scrive nella posizione specificata, verifica che la posizione del bucket sia vuota. Poiché `UNLOAD` non scrive i dati nella posizione specificata se la posizione contiene già dati, `UNLOAD` non sovrascrive i dati esistenti. Per riutilizzare una posizione bucket come destinazione per `UNLOAD`, elimina i dati nella posizione del bucket e quindi esegui nuovamente la query. Notate che quando si `UNLOAD` scrive su partizioni, questo comportamento è diverso. Se esegui la stessa `UNLOAD` query più volte con la stessa `SELECT` istruzione, la stessa `TO` posizione e le stesse partizioni, ogni `UNLOAD` query scarica i dati in Amazon S3 nella posizione e nelle partizioni specificate. ### Parameters I valori possibili di *property\$1name* sono indicati di seguito. ** formato = '' *file\$1format* ** Obbligatorio. Specifica il formato di file dell'output. I valori possibili per *file\$1format* sono `ORC``PARQUET`,`AVRO`,`JSON`, o`TEXTFILE`. ** compressione = '*compression\$1format*' ** Opzionale. Questa opzione è specifica per i formati ORC e Parquet. Per ORC il valore predefinito è `zlib` e per Parquet il valore predefinito è `gzip`. Per informazioni sui formati di compressione supportati, consulta [Supporto alla compressione Athena](https://docs.aws.amazon.com/athena/latest/ug/compression-formats.html). Questa opzione non è valida per il formato `AVRO`. Athena utilizza `gzip` per i formati `JSON` e `TEXTFILE`. **livello\$1compressione = *compression\$1level* ** Opzionale. Il livello di compressione da utilizzare per la compressione ZSTD. Questa proprietà si applica solo alla compressione ZSTD. Per ulteriori informazioni, consulta [Usa i livelli di compressione ZSTD](compression-support-zstd-levels.md). ** field\$1delimiter = '' *delimiter* ** Opzionale. Specifica un delimitatore di campo a carattere singolo per file in CSV, TSV e altri formati di testo. L'esempio seguente specifica la virgola come separatore decimale. ``` WITH (field_delimiter = ',') ``` Attualmente, i delimitatori di campo multicarattere non sono supportati. Se non si specifica un separatore di campo, viene usato il carattere ottale `\001` (^A). ** partizionato\$1da = ARRAY [[,...]] *col\$1name* ** Opzionale. Un elenco matrice di colonne in base al quale l'output è partizionato. Nell'istruzione `SELECT`, assicurati che i nomi delle colonne partizionate siano elencati per ultimi nell'elenco delle colonne. ## Esempi L'esempio seguente scrive l'output di una query `SELECT` per la posizione Amazon S3 `s3://amzn-s3-demo-bucket/unload_test_1/` utilizzando il formato JSON. ``` UNLOAD (SELECT * FROM old_table) TO 's3://amzn-s3-demo-bucket/unload_test_1/' WITH (format = 'JSON') ``` L'esempio seguente scrive l'output di una query `SELECT` in formato Parquet utilizzando la compressione Snappy. ``` UNLOAD (SELECT * FROM old_table) TO 's3://amzn-s3-demo-bucket/' WITH (format = 'PARQUET',compression = 'SNAPPY') ``` Nell'esempio seguente vengono scritte quattro colonne in formato testo, con l'output partizionato dall'ultima colonna. ``` UNLOAD (SELECT name1, address1, comment1, key1 FROM table1) TO 's3://amzn-s3-demo-bucket/ partitioned/' WITH (format = 'TEXTFILE', partitioned_by = ARRAY['key1']) ``` L'esempio seguente scarica i risultati della query nella posizione specificata utilizzando il formato file Parquet, la compressione ZSTD e il livello di compressione ZSTD 4. ``` UNLOAD (SELECT * FROM old_table) TO 's3://amzn-s3-demo-bucket/' WITH (format = 'PARQUET', compression = 'ZSTD', compression_level = 4) ``` ## Risorse aggiuntive + [Semplifica le tue pipeline ETL e ML utilizzando la funzionalità Amazon Athena UNLOAD](https://aws.amazon.com/blogs/big-data/simplify-your-etl-and-ml-pipelines-using-the-amazon-athena-unload-feature/) nel *Blog sui Big Data di AWS *. # Funzioni in Amazon Athena Per modifiche alle funzioni tra le diverse versioni del motore Athena, consultare [Controllo delle versioni del motore di Athena](engine-versions.md). Per un elenco dei fusi orari che possono essere utilizzati con l'operatore `AT TIME ZONE`, consulta [Utilizzare fusi orari supportati](athena-supported-time-zones.md). **Topics** + [Versione 3 del motore Athena](functions-env3.md) # Funzioni della versione 3 del motore Athena Le funzioni nella versione 3 del motore Athena sono basate su Trino. Per informazioni su funzioni, operatori ed espressioni di Trino, consulta [Funzioni e operatori](https://trino.io/docs/current/functions.html) e le seguenti sezioni specifiche della documentazione di Trino. + [Aggregazione](https://trino.io/docs/current/functions/aggregate.html) + [Array](https://trino.io/docs/current/functions/array.html) + [Binary](https://trino.io/docs/current/functions/binary.html) + [Bit per bit](https://trino.io/docs/current/functions/bitwise.html) + [Color](https://trino.io/docs/current/functions/color.html) (Colore) + [Confronto](https://trino.io/docs/current/functions/comparison.html) + [Condizionale](https://trino.io/docs/current/functions/conditional.html) + [Conversione](https://trino.io/docs/current/functions/conversion.html) + [Data e ora](https://trino.io/docs/current/functions/datetime.html) + [Decimale](https://trino.io/docs/current/functions/decimal.html) + [Dati geospaziali](https://trino.io/docs/current/functions/geospatial.html) + [HyperLogLog](https://trino.io/docs/current/functions/hyperloglog.html) + [Indirizzo IP](https://trino.io/docs/current/functions/ipaddress.html) + [JSON](https://trino.io/docs/current/functions/json.html) + [Lambda](https://trino.io/docs/current/functions/lambda.html) + [Logica](https://trino.io/docs/current/functions/logical.html) + [Machine learning](https://trino.io/docs/current/functions/ml.html) + [Mappa](https://trino.io/docs/current/functions/map.html) + [Math](https://trino.io/docs/current/functions/math.html) (Matematica) + [Digest quantile](https://trino.io/docs/current/functions/qdigest.html) + [Espressione regolare](https://trino.io/docs/current/functions/regexp.html) + [Sessione](https://trino.io/docs/current/functions/session.html) + [Set Digest](https://trino.io/docs/current/functions/setdigest.html) + [Stringa](https://trino.io/docs/current/functions/string.html) + [Tabella](https://trino.io/docs/current/functions/table.html) + [Teradata](https://trino.io/docs/current/functions/teradata.html) + [T-Digest](https://trino.io/docs/current/functions/tdigest.html) + [URL](https://trino.io/docs/current/functions/url.html) + [UUID](https://trino.io/docs/current/functions/uuid.html) + [Window](https://trino.io/docs/current/functions/window.html) ## funzione invoker\$1principal () La funzione `invoker_principal` è esclusiva della versione 3 del motore Athena e non si trova in Trino. Restituisce un valore `VARCHAR` che contiene l’ARN del principale (ruolo IAM o Identity Center identity) che ha eseguito la query che chiama la funzione. Ad esempio, se chi invoca la query utilizza le autorizzazioni di un ruolo IAM per eseguire la query, la funzione restituisce l’ARN del ruolo IAM. Il ruolo che esegue la query deve consentire l’azione `LakeFormation:GetDataLakePrincipal`. ### Utilizzo ``` SELECT invoker_principal() ``` Il risultato è illustrato nel seguente screenshot. **** | \$1 | \$1col0 | | --- | --- | | 1 | arn:aws:iam: ::ruolo/admin 111122223333 | # Utilizzare fusi orari supportati Puoi utilizzare l'operatore `AT TIME ZONE` in un'istruzione `SELECT timestamp` per specificare il fuso orario per la marca temporale restituita, come nell'esempio seguente: ``` SELECT timestamp '2012-10-31 01:00 UTC' AT TIME ZONE 'America/Los_Angeles' AS la_time; ``` **Risultati** ``` la_time 2012-10-30 18:00:00.000 America/Los_Angeles ``` Per un elenco dei fusi orari supportati in Athena, espandere [Elenco dei fusi orari supportati](#athena-supported-time-zones-list) alla fine di questo argomento. ## Funzioni ed esempi del fuso orario Qui di seguito è possibile trovare ulteriori funzioni ed esempi relativi al fuso orario. + **at\$1timezone (*timestamp*,*zone*)** — Restituisce il valore di *timestamp* nell'ora locale corrispondente per. *zone* **Esempio** ``` SELECT at_timezone(timestamp '2021-08-22 00:00 UTC', 'Canada/Newfoundland') ``` **Risultato** ``` 2021-08-21 21:30:00.000 Canada/Newfoundland ``` + **timezone\$1hour (*timestamp*)** — Restituisce l'ora del fuso orario scostata dal timestamp come a. `bigint` **Esempio** ``` SELECT timezone_hour(timestamp '2021-08-22 04:00 UTC' AT TIME ZONE 'Canada/Newfoundland') ``` **Risultato** ``` -2 ``` + **timezone\$1minute (*timestamp*) — Restituisce il minuto** dell'offset del fuso orario rispetto a. *timestamp* `bigint` **Esempio** ``` SELECT timezone_minute(timestamp '2021-08-22 04:00 UTC' AT TIME ZONE 'Canada/Newfoundland') ``` **Risultato** ``` -30 ``` + **with\$1timezone (*timestamp*,*zone*)** — Restituisce un timestamp con il fuso orario compreso tra quelli specificati e i valori. *timestamp* *zone* **Esempio** ``` SELECT with_timezone(timestamp '2021-08-22 04:00', 'Canada/Newfoundland') ``` **Risultato** ``` 2021-08-22 04:00:00.000 Canada/Newfoundland ``` ## Elenco dei fusi orari supportati L'elenco seguente contiene i fusi orari che possono essere utilizzati con l'operatore `AT TIME ZONE` in Athena. Per ulteriori funzioni ed esempi relativi al fuso orario, consulta [Funzioni ed esempi del fuso orario](#athena-supported-time-zones-functions-examples). ``` Africa/Abidjan Africa/Accra Africa/Addis_Ababa Africa/Algiers Africa/Asmara Africa/Asmera Africa/Bamako Africa/Bangui Africa/Banjul Africa/Bissau Africa/Blantyre Africa/Brazzaville Africa/Bujumbura Africa/Cairo Africa/Casablanca Africa/Ceuta Africa/Conakry Africa/Dakar Africa/Dar_es_Salaam Africa/Djibouti Africa/Douala Africa/El_Aaiun Africa/Freetown Africa/Gaborone Africa/Harare Africa/Johannesburg Africa/Juba Africa/Kampala Africa/Khartoum Africa/Kigali Africa/Kinshasa Africa/Lagos Africa/Libreville Africa/Lome Africa/Luanda Africa/Lubumbashi Africa/Lusaka Africa/Malabo Africa/Maputo Africa/Maseru Africa/Mbabane Africa/Mogadishu Africa/Monrovia Africa/Nairobi Africa/Ndjamena Africa/Niamey Africa/Nouakchott Africa/Ouagadougou Africa/Porto-Novo Africa/Sao_Tome Africa/Timbuktu Africa/Tripoli Africa/Tunis Africa/Windhoek America/Adak America/Anchorage America/Anguilla America/Antigua America/Araguaina America/Argentina/Buenos_Aires America/Argentina/Catamarca America/Argentina/ComodRivadavia America/Argentina/Cordoba America/Argentina/Jujuy America/Argentina/La_Rioja America/Argentina/Mendoza America/Argentina/Rio_Gallegos America/Argentina/Salta America/Argentina/San_Juan America/Argentina/San_Luis America/Argentina/Tucuman America/Argentina/Ushuaia America/Aruba America/Asuncion America/Atikokan America/Atka America/Bahia America/Bahia_Banderas America/Barbados America/Belem America/Belize America/Blanc-Sablon America/Boa_Vista America/Bogota America/Boise America/Buenos_Aires America/Cambridge_Bay America/Campo_Grande America/Cancun America/Caracas America/Catamarca America/Cayenne America/Cayman America/Chicago America/Chihuahua America/Coral_Harbour America/Cordoba America/Costa_Rica America/Creston America/Cuiaba America/Curacao America/Danmarkshavn America/Dawson America/Dawson_Creek America/Denver America/Detroit America/Dominica America/Edmonton America/Eirunepe America/El_Salvador America/Ensenada America/Fort_Nelson America/Fort_Wayne America/Fortaleza America/Glace_Bay America/Godthab America/Goose_Bay America/Grand_Turk America/Grenada America/Guadeloupe America/Guatemala America/Guayaquil America/Guyana America/Halifax America/Havana America/Hermosillo America/Indiana/Indianapolis America/Indiana/Knox America/Indiana/Marengo America/Indiana/Petersburg America/Indiana/Tell_City America/Indiana/Vevay America/Indiana/Vincennes America/Indiana/Winamac America/Indianapolis America/Inuvik America/Iqaluit America/Jamaica America/Jujuy America/Juneau America/Kentucky/Louisville America/Kentucky/Monticello America/Knox_IN America/Kralendijk America/La_Paz America/Lima America/Los_Angeles America/Louisville America/Lower_Princes America/Maceio America/Managua America/Manaus America/Marigot America/Martinique America/Matamoros America/Mazatlan America/Mendoza America/Menominee America/Merida America/Metlakatla America/Mexico_City America/Miquelon America/Moncton America/Monterrey America/Montevideo America/Montreal America/Montserrat America/Nassau America/New_York America/Nipigon America/Nome America/Noronha America/North_Dakota/Beulah America/North_Dakota/Center America/North_Dakota/New_Salem America/Ojinaga America/Panama America/Pangnirtung America/Paramaribo America/Phoenix America/Port-au-Prince America/Port_of_Spain America/Porto_Acre America/Porto_Velho America/Puerto_Rico America/Punta_Arenas America/Rainy_River America/Rankin_Inlet America/Recife America/Regina America/Resolute America/Rio_Branco America/Rosario America/Santa_Isabel America/Santarem America/Santiago America/Santo_Domingo America/Sao_Paulo America/Scoresbysund America/Shiprock America/Sitka America/St_Barthelemy America/St_Johns America/St_Kitts America/St_Lucia America/St_Thomas America/St_Vincent America/Swift_Current America/Tegucigalpa America/Thule America/Thunder_Bay America/Tijuana America/Toronto America/Tortola America/Vancouver America/Virgin America/Whitehorse America/Winnipeg America/Yakutat America/Yellowknife Antarctica/Casey Antarctica/Davis Antarctica/DumontDUrville Antarctica/Macquarie Antarctica/Mawson Antarctica/McMurdo Antarctica/Palmer Antarctica/Rothera Antarctica/South_Pole Antarctica/Syowa Antarctica/Troll Antarctica/Vostok Arctic/Longyearbyen Asia/Aden Asia/Almaty Asia/Amman Asia/Anadyr Asia/Aqtau Asia/Aqtobe Asia/Ashgabat Asia/Ashkhabad Asia/Atyrau Asia/Baghdad Asia/Bahrain Asia/Baku Asia/Bangkok Asia/Barnaul Asia/Beirut Asia/Bishkek Asia/Brunei Asia/Calcutta Asia/Chita Asia/Choibalsan Asia/Chongqing Asia/Chungking Asia/Colombo Asia/Dacca Asia/Damascus Asia/Dhaka Asia/Dili Asia/Dubai Asia/Dushanbe Asia/Gaza Asia/Harbin Asia/Hebron Asia/Ho_Chi_Minh Asia/Hong_Kong Asia/Hovd Asia/Irkutsk Asia/Istanbul Asia/Jakarta Asia/Jayapura Asia/Jerusalem Asia/Kabul Asia/Kamchatka Asia/Karachi Asia/Kashgar Asia/Kathmandu Asia/Katmandu Asia/Khandyga Asia/Kolkata Asia/Krasnoyarsk Asia/Kuala_Lumpur Asia/Kuching Asia/Kuwait Asia/Macao Asia/Macau Asia/Magadan Asia/Makassar Asia/Manila Asia/Muscat Asia/Nicosia Asia/Novokuznetsk Asia/Novosibirsk Asia/Omsk Asia/Oral Asia/Phnom_Penh Asia/Pontianak Asia/Pyongyang Asia/Qatar Asia/Qyzylorda Asia/Rangoon Asia/Riyadh Asia/Saigon Asia/Sakhalin Asia/Samarkand Asia/Seoul Asia/Shanghai Asia/Singapore Asia/Srednekolymsk Asia/Taipei Asia/Tashkent Asia/Tbilisi Asia/Tehran Asia/Tel_Aviv Asia/Thimbu Asia/Thimphu Asia/Tokyo Asia/Tomsk Asia/Ujung_Pandang Asia/Ulaanbaatar Asia/Ulan_Bator Asia/Urumqi Asia/Ust-Nera Asia/Vientiane Asia/Vladivostok Asia/Yakutsk Asia/Yangon Asia/Yekaterinburg Asia/Yerevan Atlantic/Azores Atlantic/Bermuda Atlantic/Canary Atlantic/Cape_Verde Atlantic/Faeroe Atlantic/Faroe Atlantic/Jan_Mayen Atlantic/Madeira Atlantic/Reykjavik Atlantic/South_Georgia Atlantic/St_Helena Atlantic/Stanley Australia/ACT Australia/Adelaide Australia/Brisbane Australia/Broken_Hill Australia/Canberra Australia/Currie Australia/Darwin Australia/Eucla Australia/Hobart Australia/LHI Australia/Lindeman Australia/Lord_Howe Australia/Melbourne Australia/NSW Australia/North Australia/Perth Australia/Queensland Australia/South Australia/Sydney Australia/Tasmania Australia/Victoria Australia/West Australia/Yancowinna Brazil/Acre Brazil/DeNoronha Brazil/East Brazil/West CET CST6CDT Canada/Atlantic Canada/Central Canada/Eastern Canada/Mountain Canada/Newfoundland Canada/Pacific Canada/Saskatchewan Canada/Yukon Chile/Continental Chile/EasterIsland Cuba EET EST5EDT Egypt Eire Europe/Amsterdam Europe/Andorra Europe/Astrakhan Europe/Athens Europe/Belfast Europe/Belgrade Europe/Berlin Europe/Bratislava Europe/Brussels Europe/Bucharest Europe/Budapest Europe/Busingen Europe/Chisinau Europe/Copenhagen Europe/Dublin Europe/Gibraltar Europe/Guernsey Europe/Helsinki Europe/Isle_of_Man Europe/Istanbul Europe/Jersey Europe/Kaliningrad Europe/Kiev Europe/Kirov Europe/Lisbon Europe/Ljubljana Europe/London Europe/Luxembourg Europe/Madrid Europe/Malta Europe/Mariehamn Europe/Minsk Europe/Monaco Europe/Moscow Europe/Nicosia Europe/Oslo Europe/Paris Europe/Podgorica Europe/Prague Europe/Riga Europe/Rome Europe/Samara Europe/San_Marino Europe/Sarajevo Europe/Simferopol Europe/Skopje Europe/Sofia Europe/Stockholm Europe/Tallinn Europe/Tirane Europe/Tiraspol Europe/Ulyanovsk Europe/Uzhgorod Europe/Vaduz Europe/Vatican Europe/Vienna Europe/Vilnius Europe/Volgograd Europe/Warsaw Europe/Zagreb Europe/Zaporozhye Europe/Zurich GB GB-Eire Hongkong Iceland Indian/Antananarivo Indian/Chagos Indian/Christmas Indian/Cocos Indian/Comoro Indian/Kerguelen Indian/Mahe Indian/Maldives Indian/Mauritius Indian/Mayotte Indian/Reunion Iran Israel Jamaica Japan Kwajalein Libya MET MST7MDT Mexico/BajaNorte Mexico/BajaSur Mexico/General NZ NZ-CHAT Navajo PRC PST8PDT Pacific/Apia Pacific/Auckland Pacific/Bougainville Pacific/Chatham Pacific/Chuuk Pacific/Easter Pacific/Efate Pacific/Enderbury Pacific/Fakaofo Pacific/Fiji Pacific/Funafuti Pacific/Galapagos Pacific/Gambier Pacific/Guadalcanal Pacific/Guam Pacific/Honolulu Pacific/Johnston Pacific/Kiritimati Pacific/Kosrae Pacific/Kwajalein Pacific/Majuro Pacific/Marquesas Pacific/Midway Pacific/Nauru Pacific/Niue Pacific/Norfolk Pacific/Noumea Pacific/Pago_Pago Pacific/Palau Pacific/Pitcairn Pacific/Pohnpei Pacific/Ponape Pacific/Port_Moresby Pacific/Rarotonga Pacific/Saipan Pacific/Samoa Pacific/Tahiti Pacific/Tarawa Pacific/Tongatapu Pacific/Truk Pacific/Wake Pacific/Wallis Pacific/Yap Poland Portugal ROK Singapore Turkey US/Alaska US/Aleutian US/Arizona US/Central US/East-Indiana US/Eastern US/Hawaii US/Indiana-Starke US/Michigan US/Mountain US/Pacific US/Pacific-New US/Samoa W-SU WET ``` # Istruzioni DDL Utilizza le istruzioni DDL (Data Definition Language) supportate qui presentate direttamente in Athena. Il motore di query Athena è basato in parte su [HiveQL DDL](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+DDL). Athena non supporta tutte le istruzioni DDL e ci sono alcune differenze tra HiveQL DDL e Athena DDL. Per ulteriori informazioni, consulta gli argomenti di riferimento in questa sezione e in [DDL non supportato](unsupported-ddl.md). **Topics** + [DDL non supportato](unsupported-ddl.md) + [ALTER DATABASE SET DBPROPERTIES](alter-database-set-dbproperties.md) + [ALTER TABLE ADD COLUMNS](alter-table-add-columns.md) + [ALTER TABLE ADD PARTITION](alter-table-add-partition.md) + [ALTER TABLE CHANGE COLUMN](alter-table-change-column.md) + [ALTER TABLE DROP PARTITION](alter-table-drop-partition.md) + [ALTER TABLE RENAME PARTITION](alter-table-rename-partition.md) + [ALTER TABLE REPLACE COLUMNS](alter-table-replace-columns.md) + [ALTER TABLE SET LOCATION](alter-table-set-location.md) + [ALTER TABLE SET TBLPROPERTIES](alter-table-set-tblproperties.md) + [ALTER VIEW DIALECT](alter-view-dialect.md) + [CREATE DATABASE](create-database.md) + [CREATE TABLE](create-table.md) + [CREATE TABLE AS](create-table-as.md) + [CREATE VIEW](create-view.md) + [DESCRIBE](describe-table.md) + [DESCRIBE VIEW](describe-view.md) + [DROP DATABASE](drop-database.md) + [DROP TABLE](drop-table.md) + [DROP VIEW](drop-view.md) + [MSCK REPAIR TABLE](msck-repair-table.md) + [SHOW COLUMNS](show-columns.md) + [SHOW CREATE TABLE](show-create-table.md) + [SHOW CREATE VIEW](show-create-view.md) + [SHOW DATABASES](show-databases.md) + [SHOW PARTITIONS](show-partitions.md) + [SHOW TABLES](show-tables.md) + [SHOW TBLPROPERTIES](show-tblproperties.md) + [SHOW VIEWS](show-views.md) # DDL non supportato Le seguenti istruzioni DDL non sono supportate da Athena SQL: Per istruzioni DDL supportate per tabelle Iceberg in Athena, consultare [Evoluzione dello schema della tabella Iceberg](querying-iceberg-evolving-table-schema.md) e [Esecuzione di altre operazioni DDL sulle tabelle Iceberg](querying-iceberg-additional-operations.md). + ALTER INDEX + ALTER TABLE *table\$1name* ARCHIVE PARTITION + ALTER TABLE *table\$1name* CLUSTERED BY + ALTER TABLE *table\$1name* DROP COLUMN (supportato per le tabelle Iceberg) + ALTER TABLE *table\$1name* EXCHANGE PARTITION + ALTER TABLE *table\$1name* NOT CLUSTERED + ALTER TABLE *table\$1name* NOT SKEWED + ALTER TABLE *table\$1name* NOT SORTED + ALTER TABLE *table\$1name* NOT STORED AS DIRECTORIES + ALTER TABLE *table\$1name* partitionSpec CHANGE COLUMNS + ALTER TABLE *table\$1name* partitionSpec COMPACT + ALTER TABLE *table\$1name* partitionSpec CONCATENATE + ALTER TABLE *table\$1name* partitionSpec SET FILEFORMAT + ALTER TABLE *table\$1name* RENAME TO (supportato per le tabelle Iceberg) + ALTER TABLE SET SERDEPROPERTIES *table\$1name* + ALTER TABLE *table\$1name* SET SKEWED LOCATION + ALTER TABLE *table\$1name* SKEWED BY + ALTER TABLE *table\$1name* TOUCH + ALTER TABLE *table\$1name* UNARCHIVE PARTITION + COMMIT + CREATE INDEX + CREATE ROLE + CREATE TABLE *table\$1name* LIKE *existing\$1table\$1name* + CREATE TEMPORARY MACRO + DELETE FROM + DESCRIBE DATABASE + DFS + DROP INDEX + DROP ROLE + DROP TEMPORARY MACRO + EXPORT TABLE + GRANT ROLE + IMPORT TABLE + LOCK DATABASE + LOCK TABLE + REVOKE ROLE + ROLLBACK + SHOW COMPACTIONS + SHOW CURRENT ROLES + SHOW GRANT + SHOW INDEXES + SHOW LOCKS + SHOW PRINCIPALS + SHOW ROLE GRANT + SHOW ROLES + SHOW STATS + SHOW TRANSACTIONS + START TRANSACTION + UNLOCK DATABASE + UNLOCK TABLE # ALTER DATABASE SET DBPROPERTIES Crea una o più proprietà per un database. I codici `DATABASE` e `SCHEMA` sono utilizzabili in modo intercambiabile, poiché significano la stessa cosa. ## Riepilogo ``` ALTER {DATABASE|SCHEMA} database_name SET DBPROPERTIES ('property_name'='property_value' [, ...] ) ``` ## Parameters **SET DBPROPERTIES ('property\$1name'='property\$1value' [, ...]** Specifica una o più proprietà per il database denominato `property_name` e stabilisce il valore per ciascuna proprietà rispettivamente come `property_value`. Se `property_name` è già presente, il vecchio valore viene sovrascritto con `property_value`. ## Esempi ``` ALTER DATABASE jd_datasets SET DBPROPERTIES ('creator'='John Doe', 'department'='applied mathematics'); ``` ``` ALTER SCHEMA jd_datasets SET DBPROPERTIES ('creator'='Jane Doe'); ``` # ALTER TABLE ADD COLUMNS Aggiunge una o più colonne a una tabella esistente. Quando si utilizza la sintassi `PARTITION` facoltativa, aggiorna i metadati della partizione. ## Riepilogo ``` ALTER TABLE table_name [PARTITION (partition_col1_name = partition_col1_value [,partition_col2_name = partition_col2_value][,...])] ADD COLUMNS (col_name data_type) ``` ## Parameters **PARTITION (partition\$1col\$1name = partition\$1col\$1value [,...])** Crea una partizione con le name/value combinazioni di colonne specificate. Racchiudere `partition_col_value` tra virgolette solo se il tipo di dati della colonna è una stringa. **ADD COLUMNS (col\$1name data\$1type [,col\$1name data\$1type,…])** Aggiunge colonne dopo le colonne esistenti, ma prima delle colonne delle partizioni. ## Esempi ``` ALTER TABLE events ADD COLUMNS (eventowner string) ``` ``` ALTER TABLE events PARTITION (awsregion='us-west-2') ADD COLUMNS (event string) ``` ``` ALTER TABLE events PARTITION (awsregion='us-west-2') ADD COLUMNS (eventdescription string) ``` ## Note + Per visualizzare una nuova colonna della tabella nel pannello di navigazione dell'editor di query Athena dopo l'esecuzione di `ALTER TABLE ADD COLUMNS`, aggiornare manualmente l'elenco di tabelle nell'editor e quindi espandere nuovamente la tabella. + `ALTER TABLE ADD COLUMNS` non funziona per le colonne con il tipo di dati `date`. Per risolvere questo problema, utilizzare invece il tipo di dati `timestamp`. # ALTER TABLE ADD PARTITION Crea una o più colonne di partizione per la tabella. Ogni partizione è composta da una o più name/value combinazioni di colonne distinte. Viene creata una directory di dati separata per ciascuna combinazione specificata; in alcune circostanze ciò può migliorare le prestazioni delle query. Le colonne partizionate non sono presenti all'interno della tabella di dati stessa, perciò se si utilizza un nome di colonna uguale a un nome di una colonna nella tabella, si riceverà un messaggio di errore. Per ulteriori informazioni, consulta [Come partizionare i dati](partitions.md). In Athena, una tabella e le relative partizioni devono utilizzare gli stessi formati di dati, tuttavia i loro schemi possono differire. Per ulteriori informazioni, consulta [Aggiornare tabelle con partizioni](updates-and-partitions.md). Per informazioni sulle autorizzazioni a livello di risorsa richieste nelle policy IAM (incluse `glue:CreatePartition`), consulta [Autorizzazioni API AWS Glue : documentazione di riferimento su operazioni e risorse](https://docs.aws.amazon.com/glue/latest/dg/api-permissions-reference.html) e [Configurare l'accesso a database e tabelle in AWS Glue Data Catalog](fine-grained-access-to-glue-resources.md). Per informazioni sulla risoluzione dei problemi relativi alle autorizzazioni quando si utilizza Athena, consulta la sezione [Permissions](troubleshooting-athena.md#troubleshooting-athena-permissions) dell'argomento [Risoluzione dei problemi in Athena](troubleshooting-athena.md). ## Riepilogo ``` ALTER TABLE table_name ADD [IF NOT EXISTS] PARTITION (partition_col1_name = partition_col1_value [,partition_col2_name = partition_col2_value] [,...]) [LOCATION 'location1'] [PARTITION (partition_colA_name = partition_colA_value [,partition_colB_name = partition_colB_value [,...])] [LOCATION 'location2'] [,...] ``` ## Parameters Quando aggiungi una partizione, specifichi una o più name/value coppie di colonne per la partizione e il percorso Amazon S3 in cui risiedono i file di dati per quella partizione. **[IF NOT EXISTS]** Provoca l'errore da sopprimere se una partizione con la stessa definizione è già esistente. **PARTITION (partition\$1col\$1name = partition\$1col\$1value [,...])** Crea una partizione con le combinazioni di colonne specificate. name/value Racchiudere `partition_col_value` in caratteri di stringa solo se il tipo di dati della colonna è una stringa. **[LOCATION 'location']** Specifica la directory in cui memorizzare la partizione definita dalla dichiarazione precedente. La clausola `LOCATION` è facoltativa quando i dati utilizzano il partizionamento in modalità Hive (`pk1=v1/pk2=v2/pk3=v3`). Con il partizionamento in modalità Hive, l'URI completo di Amazon S3 è creato automaticamente dalla posizione della tabella, dai nomi delle chiavi di partizione e dai valori delle chiavi di partizione. Per ulteriori informazioni, consulta [Come partizionare i dati](partitions.md). ## Considerazioni Amazon Athena non impone un limite preciso al numero di partizioni che è possibile aggiungere in una singola istruzione DDL `ALTER TABLE ADD PARTITION`. Tuttavia, se bisogna aggiungere un numero significativo di partizioni, si consiglia di prendere in considerazione la possibilità di suddividere l’operazione in batch più piccoli per evitare potenziali problemi di prestazione. Il seguente esempio utilizza comandi in sequenza per aggiungere partizioni singolarmente e utilizza comandi `IF NOT EXISTS` per evitare l’aggiunta di duplicati. ``` ALTER TABLE table_name ADD IF NOT EXISTS PARTITION (ds='2023-01-01') ALTER TABLE table_name ADD IF NOT EXISTS PARTITION (ds='2023-01-02') ALTER TABLE table_name ADD IF NOT EXISTS PARTITION (ds='2023-01-03') ``` Quando si lavora con partizioni in Athena, è anche importante considerare quanto segue: + Sebbene Athena supporti l'interrogazione di AWS Glue tabelle con 10 milioni di partizioni, Athena non è in grado di leggere più di 1 milione di partizioni in una singola scansione. + Per ottimizzare le query e ridurre il numero di partizioni analizzate, si consiglia di prendere in considerazione strategie come l’eliminazione delle partizioni o l’utilizzo di indici delle partizioni. Per ulteriori considerazioni sull’utilizzo delle partizioni in Athena, consultare [Come partizionare i dati](partitions.md). ## Esempi L'esempio seguente aggiunge una singola partizione a una tabella di dati partizionati in modalità Hive. ``` ALTER TABLE orders ADD PARTITION (dt = '2016-05-14', country = 'IN'); ``` L'esempio seguente aggiunge più partizioni a una tabella per dati partizionati in stile Hive. ``` ALTER TABLE orders ADD PARTITION (dt = '2016-05-31', country = 'IN') PARTITION (dt = '2016-06-01', country = 'IN'); ``` Quando la tabella non è per dati partizionati in stile Hive, la `LOCATION` clausola è obbligatoria e deve essere l'URI completo di Amazon S3 per il prefisso che contiene i dati della partizione. ``` ALTER TABLE orders ADD PARTITION (dt = '2016-05-31', country = 'IN') LOCATION 's3://amzn-s3-demo-bucket/path/to/INDIA_31_May_2016/' PARTITION (dt = '2016-06-01', country = 'IN') LOCATION 's3://amzn-s3-demo-bucket/path/to/INDIA_01_June_2016/'; ``` Per ignorare gli errori quando la partizione già esiste, utilizza la clausola `IF NOT EXISTS`, come nell'esempio seguente. ``` ALTER TABLE orders ADD IF NOT EXISTS PARTITION (dt = '2016-05-14', country = 'IN'); ``` ## File `_$folder$` di zero byte Se esegui un'istruzione `ALTER TABLE ADD PARTITION` e specifichi erroneamente una partizione già esistente e una posizione Amazon S3 errata, vengono creati in Amazon S3 i file segnaposto di zero byte del formato `partition_value_$folder$`. È necessario rimuovere questi file manualmente. Per evitare che ciò accada, utilizza la sintassi `ADD IF NOT EXISTS` nella dichiarazione `ALTER TABLE ADD PARTITION`, come nell'esempio seguente. ``` ALTER TABLE table_name ADD IF NOT EXISTS PARTITION […] ``` # ALTER TABLE CHANGE COLUMN Modifica il nome, il tipo, l’ordine o il commento per una colonna in una tabella. ## Riepilogo ``` ALTER TABLE [db_name.]table_name CHANGE [COLUMN] col_old_name col_new_name column_type [COMMENT col_comment] [FIRST|AFTER column_name] ``` ## Esempi L’esempio seguente modifica il nome della colonna `area` in `zip`, rende il tipo di dati come numero intero e inserisce la colonna rinominata dopo la colonna `id`. ``` ALTER TABLE example_table CHANGE COLUMN area zip int AFTER id ``` Nell’esempio seguente viene aggiunto un commento alla colonna `zip` nei metadati per `example_table`. Per vedere il commento, usa il AWS CLI [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/athena/get-table-metadata.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/athena/get-table-metadata.html)comando o visita lo schema della tabella nella AWS Glue console. ``` ALTER TABLE example_table CHANGE COLUMN zip zip int COMMENT 'USA zipcode' ``` # ALTER TABLE DROP PARTITION Rimuove una o più partizioni specificate per la tabella denominata. ## Riepilogo ``` ALTER TABLE table_name DROP [IF EXISTS] PARTITION (partition_spec) [, PARTITION (partition_spec)] ``` ## Parameters **[IF EXISTS]** Sopprime il messaggio di errore se la partizione specificata non esiste. **PARTITION (partition\$1spec)** Ciascuno `partition_spec` specifica una name/value combinazione di colonne nel modulo`partition_col_name = partition_col_value [,...]`. ## Esempi ``` ALTER TABLE orders DROP PARTITION (dt = '2014-05-14', country = 'IN'); ``` ``` ALTER TABLE orders DROP PARTITION (dt = '2014-05-14', country = 'IN'), PARTITION (dt = '2014-05-15', country = 'IN'); ``` ## Note L'istruzione `ALTER TABLE DROP PARTITION` non fornisce una singola sintassi per eliminare tutte le partizioni contemporaneamente o supporta i criteri di filtraggio per specificare un intervallo di partizioni da eliminare. Come soluzione alternativa, puoi utilizzare l' AWS Glue API [GetPartitions](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-catalog-partitions.html#aws-glue-api-catalog-partitions-GetPartitions)e [BatchDeletePartition](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-catalog-partitions.html#aws-glue-api-catalog-partitions-BatchDeletePartition)le azioni negli script. L'operazione `GetPartitions` supporta espressioni di filtro complesse come quelle presenti in un'espressione `WHERE` SQL. Dopo aver utilizzato `GetPartitions` per creare un elenco filtrato di partizioni da eliminare, è possibile utilizzare l'operazione `BatchDeletePartition` per eliminare le partizioni in batch di 25. # ALTER TABLE RENAME PARTITION Rinomina un valore di partizione. **Nota** ALTER TABLE RENAME PARTITION non rinomina le colonne delle partizioni. Per modificare il nome di una colonna di partizione, puoi usare la AWS Glue console. Per ulteriori informazioni, consultare [Rinominare una colonna di partizione in AWS Glue](#alter-table-rename-partition-column-name) riportata di seguito in questo documento. ## Riepilogo Per la tabella denominata `table_name`, rinomina il valore di partizione specificato da `partition_spec` al valore specificato da `new_partition_spec`. ``` ALTER TABLE table_name PARTITION (partition_spec) RENAME TO PARTITION (new_partition_spec) ``` ## Parameters **PARTITION (partition\$1spec)** Ciascuno `partition_spec` specifica una name/value combinazione di colonne nel modulo. `partition_col_name = partition_col_value [,...]` ## Esempi ``` ALTER TABLE orders PARTITION (dt = '2014-05-14', country = 'IN') RENAME TO PARTITION (dt = '2014-05-15', country = 'IN'); ``` ## Rinominare una colonna di partizione in AWS Glue Seguire questa procedura per rinominare una colonna di partizione nella console AWS Glue . **Per rinominare una colonna di partizione della tabella nella console AWS Glue** 1. Accedi a Console di gestione AWS e apri la AWS Glue console all'indirizzo. [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/) 1. Nel pannello di navigazione, seleziona **Tabelle**. 1. Nella pagina **Tabelle**, utilizzare la casella di ricerca **Filtra tabelle** per trovare la tabella che si desidera modificare. 1. Nella colonna **Nome**, selezionare il link della tabella che si desidera modificare. 1. Nella pagina dei dettagli per la tabella, nella sezione **Schema**, fare una delle seguenti cose: + Per modificare il nome in formato JSON, scegliere **Modifica schema come JSON**. + Per modificare direttamente il nome, scegliere **Modifica schema**. In questa procedura viene scelto **Modifica schema**. 1. Selezionare la casella di controllo per la colonna divisa in partizioni che si desidera rinominare, quindi selezionare **Modifica**. 1. Nella finestra di dialogo **Modifica voce schema**, in **Nome**, inserire il nuovo nome per la colonna della partizione. 1. Selezionare **Salva come nuova versione della tabella**. Questa azione aggiorna il nome della colonna di partizione e conserva la cronologia dell’evoluzione dello schema senza creare una copia fisica separata dei dati. 1. Per confrontare le versioni della tabella, nella pagina dei dettagli della tabella, selezionare **Azioni**, quindi scegliere **Confronta versioni**. ## Risorse aggiuntive Per ulteriori informazioni sulle partizioni, consulta [Come partizionare i dati](partitions.md). # ALTER TABLE REPLACE COLUMNS Rimuove tutte le colonne esistenti da una tabella creata con [LazySimpleSerDe](lazy-simple-serde.md)e le sostituisce con il set di colonne specificato. Quando si utilizza la sintassi `PARTITION` facoltativa, aggiorna i metadati della partizione. È possibile utilizzare anche `ALTER TABLE REPLACE COLUMNS` per eliminare le colonne specificando solo le colonne che si desidera mantenere. ## Riepilogo ``` ALTER TABLE table_name [PARTITION (partition_col1_name = partition_col1_value [,partition_col2_name = partition_col2_value][,...])] REPLACE COLUMNS (col_name data_type [, col_name data_type, ...]) ``` ## Parameters **PARTITION (partition\$1col\$1name = partition\$1col\$1value [,...])** Specifica una partizione con le name/value combinazioni di colonne specificate. Racchiudere `partition_col_value` tra virgolette solo se il tipo di dati della colonna è una stringa. **REPLACE COLUMNS (col\$1name data\$1type [,col\$1name data\$1type,…])** Sostituisce le colonne esistenti con i nomi delle colonne e i tipi di dati specificati. ## Note + Per visualizzare la modifica nelle colonne della tabella nel pannello di navigazione dell'editor di query Athena dopo l'esecuzione di `ALTER TABLE REPLACE COLUMNS`, potrebbe essere necessario aggiornare manualmente l'elenco di tabelle nell'editor e quindi espandere nuovamente la tabella. + `ALTER TABLE REPLACE COLUMNS` non funziona per le colonne con il tipo di dati `date`. Per risolvere questo problema, utilizzare invece il tipo di dati `timestamp` nella tabella. + Anche se si sta sostituendo una sola colonna, la sintassi deve essere `ALTER TABLE table-name REPLACE COLUMNS`, con *colonne* al plurale. È necessario specificare non solo la colonna che si desidera sostituire, ma anche le colonne che si desidera conservare. In caso contrario, le colonne non specificate verranno eliminate. Questa sintassi e questo comportamento derivano da Apache Hive DDL. Come riferimento, consulta [Aggiungi/sostituisci colonne](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+DDL#LanguageManualDDL-Add/ReplaceColumns) nella documentazione di Apache. ## Esempio Nell'esempio seguente, la tabella`names_cities`, creata utilizzando [LazySimpleSerDe](lazy-simple-serde.md), ha tre colonne denominate `col1``col2`, e. `col3` Tutte le colonne sono di tipo `string`. Per visualizzare le colonne nella tabella, il comando seguente utilizza l'istruzione [SHOW COLUMNS](show-columns.md). ``` SHOW COLUMNS IN names_cities ``` Risultato della query: ``` col1 col2 col3 ``` Il comando `ALTER TABLE REPLACE COLUMNS` di seguito riportato sostituisce i nomi delle colonne con `first_name`, `last_name` e`city`. I dati di origine sottostanti non sono interessati. ``` ALTER TABLE names_cities REPLACE COLUMNS (first_name string, last_name string, city string) ``` Per testare il risultato, `SHOW COLUMNS` viene eseguito nuovamente. ``` SHOW COLUMNS IN names_cities ``` Risultato della query: ``` first_name last_name city ``` Un altro modo per mostrare i nuovi nomi di colonna è quello di [visualizzare in anteprima la tabella](creating-tables-showing-table-information.md) nell'editor di query di Athena o eseguire la propria query `SELECT`. # ALTER TABLE SET LOCATION Modifica il percorso per la tabella denominata `table_name` e, facoltativamente, una partizione con `partition_spec`. ## Riepilogo ``` ALTER TABLE table_name [ PARTITION (partition_spec) ] SET LOCATION 'new location' ``` ## Parameters **PARTITION (partition\$1spec)** Specifica la partizione con i parametri `partition_spec` di cui si desidera modificare il percorso. `partition_spec`specifica una name/value combinazione di colonne nel modulo`partition_col_name = partition_col_value`. **SET LOCATION "nuovo percorso"** Specifica il nuovo percorso, che deve essere interno ad Amazon S3. Per ulteriori informazioni sulla sintassi, consula [Posizione della tabella in Amazon S3](tables-location-format.md). ## Esempi ``` ALTER TABLE customers PARTITION (zip='98040', state='WA') SET LOCATION 's3://amzn-s3-demo-bucket/custdata/'; ``` # ALTER TABLE SET TBLPROPERTIES Aggiunge proprietà di metadati personalizzate o predefinite a una tabella e imposta i valori assegnati. Per visualizzare le proprietà in una tabella, utilizzare il comando [SHOW TBLPROPERTIES](show-tblproperties.md). Le [tabelle gestite](https://cwiki.apache.org/confluence/display/Hive/Managed+vs.+External+Tables) Apache Hive non sono supportate, quindi impostare `'EXTERNAL'='FALSE'` non determina alcun effetto. ## Riepilogo ``` ALTER TABLE table_name SET TBLPROPERTIES ('property_name' = 'property_value' [ , ... ]) ``` ## Parameters **SET TBLPROPERTIES ('property\$1name' = 'property\$1value' [ , ... ])** Specifica le proprietà dei metadati da aggiungere come `property_name` e il valore per ognuna di esse come `property value`. Se `property_name` esiste già, il suo valore è impostato sul nuovo `property_value`. Le seguenti proprietà predefinite della tabella hanno usi speciali. **** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/alter-table-set-tblproperties.html) ## Esempi Nell'esempio seguente viene aggiunto un commento alle proprietà della tabella. ``` ALTER TABLE orders SET TBLPROPERTIES ('notes'="Please don't drop this table."); ``` L'esempio seguente modifica la tabella `existing_table` per utilizzare il formato file Parquet con compressione ZSTD e livello di compressione ZSTD 4. ``` ALTER TABLE existing_table SET TBLPROPERTIES ('parquet.compression' = 'ZSTD', 'compression_level' = 4) ``` # ALTER VIEW DIALECT Aggiunge o elimina un dialetto del motore da una AWS Glue Data Catalog vista. Si applica solo alle AWS Glue Data Catalog viste. Richiede le autorizzazioni dell’amministratore `Lake Formation` o del definer. Per ulteriori informazioni sulle AWS Glue Data Catalog visualizzazioni, vedere[Utilizza le viste di Catalogo Dati in Athena](views-glue.md). ## Sintassi ``` ALTER VIEW name [ FORCE ] [ ADD|UPDATE ] DIALECT AS query ``` ``` ALTER VIEW name [ DROP ] DIALECT ``` **FORCE** La parola chiave `FORCE` causa la sovrascrittura delle informazioni in dialetto del motore di una vista in conflitto con la nuova definizione. La parola chiave `FORCE` è utile quando un aggiornamento di una vista di Catalogo Dati genera definizioni delle viste in conflitto tra i dialetti del motore esistenti. Supponiamo che una vista di Catalogo Dati contenga entrambi i dialetti Athena e Amazon Redshift e che l'aggiornamento generi un conflitto con Amazon Redshift nella definizione della vista. In questo caso, puoi utilizzare la parola chiave `FORCE` per consentire il completamento dell'aggiornamento e contrassegnare il dialetto di Amazon Redshift come obsoleto. Quando i motori contrassegnati come obsoleti interrogano la vista, la query ha esito negativo. I motori generano un'eccezione per non consentire risultati obsoleti. Per correggere questo problema, aggiorna i dialetti obsoleti nella vista. **ADD** Aggiunge un nuovo dialetto del motore alla vista di Catalogo Dati. Il motore specificato non può esistere già nella vista di Catalogo Dati. **UPDATE** Aggiorna un dialetto del motore esistente nella vista di Catalogo Dati. **DROP** Elimina un dialetto del motore esistente da una vista di Catalogo Dati. Dopo aver eliminato un motore da una vista di Catalogo Dati, tale vista non può essere interrogata dal motore che è stato disattivato. Gli altri dialetti del motore nella vista possono comunque interrogare la vista. **DIALECT AS** Introduce una query SQL specifica per il motore. ## Esempi ``` ALTER VIEW orders_by_date FORCE ADD DIALECT AS SELECT orderdate, sum(totalprice) AS price FROM orders GROUP BY orderdate ``` ``` ALTER VIEW orders_by_date FORCE UPDATE DIALECT AS SELECT orderdate, sum(totalprice) AS price FROM orders GROUP BY orderdate ``` ``` ALTER VIEW orders_by_date DROP DIALECT ``` # CREATE DATABASE Crea un database. L'uso di `DATABASE` e `SCHEMA` è intercambiabile. Significano la stessa cosa. **Nota** Per vedere un esempio di creazione di un database o di una tabella e di esecuzione di una query `SELECT` sulla tabella di Athena, consulta [Nozioni di base](getting-started.md). ## Riepilogo ``` CREATE {DATABASE|SCHEMA} [IF NOT EXISTS] database_name [COMMENT 'database_comment'] [LOCATION 'S3_loc'] [WITH DBPROPERTIES ('property_name' = 'property_value') [, ...]] ``` Per restrizioni sui nomi di database in Athena, vedere [Nomi di tabelle, database e colonne](tables-databases-columns-names.md). ## Parameters **[IF NOT EXISTS]** Determina la rimozione dell'errore se è già esistente un database denominato `database_name`. **[COMMENT database\$1comment]** Stabilisce il valore dei metadati per la proprietà metadati integrata denominata `comment` e il valore fornito per `database_comment`. In AWS Glue, i `COMMENT` contenuti vengono scritti nel `Description` campo delle proprietà del database. **[LOCATION S3\$1loc]** Specifica la posizione in cui i file e i metastore di database saranno presenti come `S3_loc`. È necessario che si tratti di una posizione Amazon S3. **[WITH DBPROPERTIES ('property\$1name' = 'property\$1value') [, ...] ]** Consente di specificare proprietà personalizzate per i metadati relativi alla definizione del database. ## Esempi ``` CREATE DATABASE clickstreams; ``` ``` CREATE DATABASE IF NOT EXISTS clickstreams COMMENT 'Site Foo clickstream data aggregates' LOCATION 's3://amzn-s3-demo-bucket/clickstreams/' WITH DBPROPERTIES ('creator'='Jane D.', 'Dept.'='Marketing analytics'); ``` ## Visualizzazione delle proprietà del database Per visualizzare le proprietà del database per un database creato in AWSData Catalog utilizzando`CREATE DATABASE`, è possibile utilizzare il AWS CLI comando [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/glue/get-database.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/glue/get-database.html), come nell'esempio seguente: ``` aws glue get-database --name ``` Nell'output JSON, il risultato è simile a quello nell'esempio seguente. ``` { "Database": { "Name": "", "Description": "", "LocationUri": "s3://amzn-s3-demo-bucket", "Parameters": { "": "" }, "CreateTime": 1603383451.0, "CreateTableDefaultPermissions": [ { "Principal": { "DataLakePrincipalIdentifier": "IAM_ALLOWED_PRINCIPALS" }, "Permissions": [ "ALL" ] } ] } } ``` Per ulteriori informazioni su AWS CLI, consulta la [Guida AWS Command Line Interface per l'utente](https://docs.aws.amazon.com/cli/latest/userguide/). # CREATE TABLE Crea una tabella con il nome e i parametri specificati dall'utente. **Nota** Questa pagina contiene informazioni di riferimento riepilogative. Per ulteriori informazioni sulla creazione delle tabelle in Athena e un esempio di istruzione `CREATE TABLE`, consulta la sezione [Crea tabelle in Athena](creating-tables.md). Per vedere esempio di creazione di un database o di una tabella e di esecuzione di una query `SELECT` sulla tabella di Athena, consulta [Nozioni di base](getting-started.md). ## Riepilogo ``` CREATE EXTERNAL TABLE [IF NOT EXISTS] [db_name.]table_name [(col_name data_type [COMMENT col_comment] [, ...] )] [COMMENT table_comment] [PARTITIONED BY (col_name data_type [COMMENT col_comment], ...)] [CLUSTERED BY (col_name, col_name, ...) INTO num_buckets BUCKETS] [ROW FORMAT row_format] [STORED AS file_format] [WITH SERDEPROPERTIES (...)] [LOCATION 's3://amzn-s3-demo-bucket/[folder]/'] [TBLPROPERTIES ( ['has_encrypted_data'='true | false',] ['encryption_option'='SSE_S3 | SSE_KMS | CSE_KMS',] ['kms_key'='aws_kms_key_arn',] ['classification'='aws_glue_classification',] property_name=property_value [, ...] ) ] ``` ## Parameters **EXTERNAL** Specifica che la tabella si basa su un file di dati sottostante esistente in Amazon S3 nella posizione specificata dall'utente in `LOCATION`. Tranne che durante la creazione di tabelle [Iceberg](querying-iceberg-creating-tables.md), utilizza sempre la parola chiave `EXTERNAL`. Se utilizzi `CREATE TABLE` senza la parola chiave `EXTERNAL` per le tabelle non Iceberg, Athena genera un errore. Quando crei una tabella esterna, i dati a cui fai riferimento devono rispettare il formato predefinito o il formato specificato con le clausole `ROW FORMAT`, `STORED AS` e `WITH SERDEPROPERTIES`. **[IF NOT EXISTS]** Questo parametro verifica se esiste già una tabella con lo stesso nome. In caso affermativo, il parametro restituisce `TRUE` e Amazon Athena annulla l'azione `CREATE TABLE`. Poiché l'annullamento avviene prima che Athena richiami il catalogo dati, non emette alcun evento. AWS CloudTrail **[db\$1name.]table\$1name** Specifica un nome per la tabella da creare. Il parametro facoltativo `db_name` specifica il database in cui è presente la tabella. Se omesso, sarà utilizzato il database corrente. Se il nome della tabella include numeri, racchiudi `table_name` tra virgolette, ad esempio `"table123"`. Se `table_name` inizia con un trattino basso, utilizza l'apice inverso, ad esempio ``_mytable``. I caratteri speciali (a eccezione del trattino basso) non sono supportati. I nomi di tabella di Athena fanno distinzione tra maiuscole e minuscole; se però utilizzi Apache Spark, dovrai specificare nomi di tabella in minuscolo. Per le restrizioni sui nomi delle tabelle in Athena, vedere. [Nomi di tabelle, database e colonne](tables-databases-columns-names.md) **[ ( col\$1name data\$1type [COMMENT col\$1comment] [, ...] ) ]** Specifica il nome di ogni colonna da creare, insieme al tipo di dati della colonna. Nei nomi di colonna non sono ammessi caratteri speciali diversi dal trattino basso `(_)`. Se `col_name` inizia con un trattino basso, racchiudi il nome della colonna tra apici inversi, ad esempio ``_mycolumn``. Per le restrizioni sui nomi delle colonne in Athena, vedere. [Nomi di tabelle, database e colonne](tables-databases-columns-names.md) Il valore `data_type` può essere qualunque tra i seguenti: + `boolean`: i valori validi sono `true` e `false`. + `tinyint`: un numero intero firmato a 8 bit in formato a due complementi, con un valore minimo pari a -2^7 e un valore massimo pari a 2^7-1. + `smallint`: un numero intero firmato a 16 bit in formato a due complementi, con un valore minimo pari a -2^15 e un valore massimo pari a 2^15-1. + `int`: nelle query DDL (Data Definition Language) come`CREATE TABLE`, utilizzare la parola chiave `int` per rappresentare un numero intero. In tutte le altre query, utilizzare la parola chiave `integer`, dove `integer` è rappresentato come valore firmato a 32 bit in formato a due complementi, con un valore minimo pari a -2^31 e un valore massimo pari a 2^31-1. Nel driver JDBC viene restituito `integer` per garantire la compatibilità con le applicazioni di analisi aziendale. + `bigint`: un numero intero firmato a 64 bit in formato a due complementi, con un valore minimo pari a -2^63 e un valore massimo pari a 2^63-1. + `double`: un numero a virgola mobile a precisione doppia firmato a 64 bit. L'intervallo va da 4.94065645841246544e-324d a 1.79769313486231570e\$1308d, positivo o negativo. `double` segue IEEE Standard for Floating-Point Arithmetic (IEEE 754). + `float`: un numero a virgola mobile a precisione singola a 32 bit. L'intervallo va da 1.40129846432481707e-45 a 3.40282346638528860e\$138, positivo o negativo. `float` segue IEEE Standard for Floating-Point Arithmetic (IEEE 754). Equivalente a `real` in Presto. In Athena, usa `float` nelle istruzioni DDL come `CREATE TABLE` e `real` nelle funzioni SQL come`SELECT CAST`. Il AWS Glue crawler restituisce i valori in `float` e Athena traduce `real` e `float` digita internamente (vedi le note di rilascio). [5 giugno 2018](release-notes.md#release-note-2018-06-05) + `decimal [ (precision, scale) ]`, dove `precision` è il numero totale di cifre e `scale` (facoltativo) è il numero di cifre nella parte frazionaria, il valore di default è 0. Ad esempio, è possibile usare il tipo di queste definizioni: `decimal(11,5)`, `decimal(15)`. Il valore massimo per *precision* è 38 e il valore massimo per è 38. *scale* Per specificare valori decimali come letterali, ad esempio durante la selezione delle righe con un determinato valore decimale nell'espressione di una query DDL, specifica la definizione di tipo `decimal` e indica il valore decimale come letterale (tra virgolette singole) nella query, come in questo esempio: `decimal_value = decimal '0.12'`. + `char`: lunghezza fissa dei dati dei caratteri specificata tra 1 e 255, ad esempio `char(10)`. Per ulteriori informazioni, consulta la sezione relativa a [tipo di dati Hive CHAR](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+Types#LanguageManualTypes-char). + `varchar`: lunghezza variabile dei dati dei caratteri specificata tra 1 e 65535, ad esempio `varchar(10)`. Per ulteriori informazioni, consulta la sezione relativa a [tipo di dati Hive VARCHAR](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+Types#LanguageManualTypes-varchar). + `string`: una stringa letterale racchiusa tra virgolette singole o doppie. **Nota** I tipi di dati non stringa non possono essere diffusi in `string` in Athena, ma possono essere diffusi in `varchar`. + `binary`: (per i dati in Parquet) + `date`: un dato in formato ISO, ad esempio `YYYY-MM-DD`. Ad esempio, `date '2008-09-15'`. Un'eccezione è l'Open CSVSer De, che utilizza il numero di giorni trascorsi dal 1° gennaio 1970. Per ulteriori informazioni, consulta [Apri CSV SerDe per l'elaborazione di CSV](csv-serde.md). + `timestamp`: data e ora istantanea in un formato compatibile con [https://docs.oracle.com/javase/8/docs/api/java/sql/Timestamp.html](https://docs.oracle.com/javase/8/docs/api/java/sql/Timestamp.html) fino a una risoluzione massima in millisecondi, come `yyyy-MM-dd HH:mm:ss[.f...]`. Ad esempio, `timestamp '2008-09-15 03:04:05.324'`. Un'eccezione è l'Open CSVSer De, che utilizza `TIMESTAMP` dati in formato numerico UNIX (ad esempio,). `1579059880000` Per ulteriori informazioni, consulta [Apri CSV SerDe per l'elaborazione di CSV](csv-serde.md). + `array` < data\$1type > + `map` < primitive\$1type, data\$1type > + `struct` < col\$1name : data\$1type [COMMENT col\$1comment] [, ...] > **[COMMENT table\$1comment]** Crea la proprietà della tabella `comment` e la popola con il parametro `table_comment` specificato. **[PARTITIONED BY (col\$1name data\$1type [ COMMENT col\$1comment ], ... ) ]** Crea una tabella partizionata con una o più colonne di partizione in cui sono specificati `col_name`, `data_type` e `col_comment`. Una tabella può avere una o più partizioni, che consistono in una combinazione distinta di nome e valore per la colonna. Viene creata una directory di dati separata per ciascuna combinazione specificata; in alcune circostanze ciò può migliorare le prestazioni delle query. Le colonne partizionate non esistono all'interno dei dati della tabella stessa. Se per `col_name` usi un valore uguale a una colonna della tabella, viene restituito un errore. Per ulteriori informazioni, consulta la pagina relativa al [partizionamento di dati](partitions.md). Dopo aver creato una tabella con partizioni, esegui una successiva query che comprenda la clausola [MSCK REPAIR TABLE](msck-repair-table.md) per aggiornare i metadati della partizione, ad esempio `MSCK REPAIR TABLE cloudfront_logs;`. Per le partizioni che non sono compatibili con Hive, utilizzare [ALTER TABLE ADD PARTITION](alter-table-add-partition.md) per caricare le partizioni in modo da poter eseguire una query sui dati. **[CLUSTERED BY (col\$1name, col\$1name, ...) INTO num\$1buckets BUCKETS]** Divide, con o senza partizionamento, i dati nelle colonne `col_name` specificate in sottoinsiemi di dati chiamati *bucket*. Il parametro `num_buckets` specifica il numero di bucket da creare. Il bucketing può migliorare le prestazioni di alcune query su set di dati di grandi dimensioni. **[ROW FORMAT row\$1format]** Specifica il formato di riga della tabella e i relativi dati di origine sottostanti, se applicabile. In `row_format`, è possibile specificare uno o più delimitatori con la clausola `DELIMITED` o, in alternativa, utilizzare la clausola `SERDE` come descritto di seguito. Se `ROW FORMAT` viene omesso o specificato, `ROW FORMAT DELIMITED` viene utilizzato un file nativo SerDe. + [DELIMITED FIELDS TERMINATED BY char [ESCAPED BY char]] + [DELIMITED COLLECTION ITEMS TERMINATED BY char] + [MAP KEYS TERMINATED BY char] + [LINES TERMINATED BY char] + [NULL DEFINED AS char] Disponibile solo con Hive 0.13 e quando il formato del file STORED AS è `TEXTFILE`. **--OPPURE--** + SERDE 'serde\$1name' [WITH SERDEPROPERTIES ("property\$1name" = "property\$1value", "property\$1name" = "property\$1value" [, ...] )] `serde_name`Indica la modalità SerDe di utilizzo. La `WITH SERDEPROPERTIES` clausola consente di fornire una o più proprietà personalizzate consentite da. SerDe **[STORED AS file\$1format]** Specifica il formato di file per i dati della tabella. Se omesso, il valore predefinito è `TEXTFILE`. Le opzioni per `file_format` sono: + SEQUENCEFILE + TEXTFILE + RCFILE + ORC + PARQUET + AVRO + ION + INPUTFORMAT input\$1format\$1classname OUTPUTFORMAT output\$1format\$1classname **[POSIZIONE 's3://amzn-s3-demo-bucket/[folder]/']** Specifica la posizione dei dati sottostanti in Amazon S3 da cui viene creata la tabella. Il percorso della posizione deve essere un nome bucket o un nome bucket e una o più cartelle. Se si utilizzano le partizioni, specificare la radice dei dati partizionati. Per ulteriori informazioni sulla posizione della tabella, consulta [Specificare la posizione di una tabella in Amazon S3](tables-location-format.md). Per informazioni sul formato dei dati e le autorizzazioni, consulta la sezione [Considerazioni su Amazon S3](creating-tables.md#s3-considerations). Utilizza una barra finale per la cartella o il bucket. Non utilizzare nomi di file o caratteri glob. **Utilizza**: `s3://amzn-s3-demo-bucket/` `s3://amzn-s3-demo-bucket/folder/` `s3://amzn-s3-demo-bucket/folder/anotherfolder/` **Non utilizzare:** `s3://amzn-s3-demo-bucket` `s3://amzn-s3-demo-bucket/*` `s3://amzn-s3-demo-bucket/mydatafile.dat` **[TBLPROPERTIES (['has\$1encrypted\$1data'='vero \$1 falso',] ['encryption\$1option'='SSE\$1S3 \$1 SSE\$1KMS \$1 CSE\$1KMS',] ['kms\$1key'='aws\$1kms\$1key\$1arn',] ['classification'='valore\$1classificazione',] property\$1name\$1arn =valore\$1proprietà [,...])]** Specifica coppie personalizzate di metadati chiave-valore per la definizione della tabella, oltre a proprietà predefinite per la tabella, ad esempio `"comment"`. **has\$1encrypted\$1data**: Athena ha una proprietà integrata, `has_encrypted_data`. Imposta questa proprietà su `true` per indicare che il set di dati sottostante specificato da `LOCATION` è crittografato con CSE-KMS. Se omesso e se le impostazioni del gruppo di lavoro non sostituiscono le impostazioni lato client, viene utilizzato `false`. Se omesso o impostato su `false` con dati sottostanti crittografati, la query restituisce un errore. Per ulteriori informazioni, consulta [Crittografia dei dati a riposo](encryption.md). **encryption\$1option** — Imposta questa proprietà su `SSE_S3``SSE_KMS`, o per indicare il livello massimo di crittografia `CSE_KMS` utilizzato nel set di dati sottostante specificato da. `LOCATION` Per ulteriori informazioni, consulta [Crittografia dei dati a riposo](encryption.md). **kms\$1key** — Imposta questa proprietà sull'ARN della chiave AWS KMS utilizzata per crittografare e decrittografare i file di dati delle tabelle. Athena utilizza questa chiave per crittografare i file di dati delle tabelle durante la scrittura `SSE_KMS` o la `CSE_KMS` crittografia e per decrittografare i file di dati delle tabelle crittografati CSE-KMS. Questa proprietà è richiesta solo quando è impostata su o. `encryption_option` `SSE_KMS` `CSE_KMS` Per ulteriori informazioni, consulta [Crittografia dei dati a riposo](encryption.md). **classificazione**: le tabelle create per Athena nella CloudTrail console vengono aggiunte `cloudtrail` come valore per la `classification` proprietà. Per eseguire processi ETL, è AWS Glue necessario creare una tabella con la `classification` proprietà per indicare il tipo di dati per AWS Glue as`csv`,, `parquet` `orc``avro`, o. `json` Ad esempio, `'classification'='csv'`. Se questa proprietà non viene specificata, i processi ETL non saranno completati con successo. È possibile specificarla in un secondo momento tramite la console AWS Glue , l'API o la CLI. Per ulteriori informazioni, consulta la sezione [Authoring Jobs in [Creare tabelle per processi ETL](schema-classifier.md)AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/author-job.html) nella *AWS Glue Developer Guide*. **compression\$1level**: la proprietà `compression_level` specifica il livello di compressione da utilizzare. Questa proprietà si applica solo alla compressione ZSTD. I valori possibili sono compresi tra 1 e 22. Il valore predefinito è 3. Per ulteriori informazioni, consulta [Usa i livelli di compressione ZSTD](compression-support-zstd-levels.md). Per ulteriori informazioni su altre proprietà della tabella, consulta [ALTER TABLE SET TBLPROPERTIES](alter-table-set-tblproperties.md). ## Esempi L’`CREATE TABLE`istruzione di esempio seguente crea una tabella basata su dati planetari separati da tabulazioni archiviati in Amazon S3. ``` CREATE EXTERNAL TABLE planet_data ( planet_name string, order_from_sun int, au_to_sun float, mass float, gravity_earth float, orbit_years float, day_length float ) ROW FORMAT DELIMITED FIELDS TERMINATED BY '\t' STORED AS TEXTFILE LOCATION 's3://amzn-s3-demo-bucket/tsv/' ``` Notare i seguenti punti: + La `ROW FORMAT DELIMITED` clausola indica che i dati sono delimitati da un carattere specifico. + La `FIELDS TERMINATED BY '\t'` clausola specifica che i campi nei dati TSV sono separati dal carattere di tabulazione ('\$1 t'). + La `STORED AS TEXTFILE` clausola indica che i dati vengono archiviati come file di testo semplice in Amazon S3. Per interrogare i dati, puoi usare una semplice `SELECT` dichiarazione come la seguente: ``` SELECT * FROM planet_data ``` Per utilizzare l’esempio per creare la tua tabella TSV in Athena, sostituisci i nomi di tabelle e colonne con i nomi e i tipi di dati della tua tabella e delle tue colonne e aggiorna `LOCATION` la clausola in modo che punti al percorso Amazon S3 in cui sono archiviati i tuoi file TSV. Per ulteriori informazioni sulla creazione delle tabelle, consulta [Crea tabelle in Athena](creating-tables.md). # CREATE TABLE AS Crea una nuova tabella popolata con i risultati di una query [SELECT](select.md). Per creare una tabella vuota, utilizza [CREATE TABLE](create-table.md). `CREATE TABLE AS` combina una dichiarazione DDL `CREATE TABLE` con una dichiarazione DML `SELECT`, quindi tecnicamente contiene sia DDL sia DML. Tieni presente che, sebbene `CREATE TABLE AS` siano raggruppate qui con altre dichiarazioni DDL, le query CTAS in Athena vengono trattate come DML ai fini delle Service Quotas. Per informazioni sulle Service Quotas in Athena, consulta [Service Quotas](service-limits.md). **Nota** Per le istruzioni CTAS, l'impostazione prevista per il proprietario del bucket non si applica alla posizione della tabella di destinazione in Amazon S3. L'impostazione prevista per il proprietario del bucket si applica solo al percorso di output di Amazon S3 specificato per i risultati delle query di Athena. Per ulteriori informazioni, consulta [Specificare una posizione dei risultati delle query utilizzando la console Athena](query-results-specify-location-console.md). Per ulteriori informazioni su `CREATE TABLE AS` oltre all'ambito di questo argomento di riferimento, consulta [Creare una tabella dai risultati delle query (CTAS)](ctas.md). **Topics** + [Riepilogo](#synopsis) + [Proprietà tabella CTAS](#ctas-table-properties) + [Esempi](#ctas-table-examples) ## Riepilogo ``` CREATE TABLE table_name [ WITH ( property_name = expression [, ...] ) ] AS query [ WITH [ NO ] DATA ] ``` Dove: **WITH ( property\$1name = expression[, ...] )** Un elenco di proprietà tabella CTAS facoltative, alcune delle quali sono specifiche per il formato di storage dei dati. Per informazioni, consulta [Proprietà tabella CTAS](#ctas-table-properties). **query** Query [SELECT](select.md) utilizzata per creare una nuova tabella. Se prevedi di creare una query con partizioni, specifica i nomi delle colonne partizionate nelle ultime voci dell'elenco delle colonne nella dichiarazione `SELECT`. **[ WITH [ NO ] DATA ]** Se si utilizza `WITH NO DATA`, viene creata una nuova tabella vuota con lo stesso schema della tabella originale. **Nota** Per includere le intestazioni di colonna nell'output dei risultati della query, è possibile utilizzare una semplice query `SELECT` anziché una query CTAS. È possibile recuperare i risultati dalla posizione dei risultati della query o scaricarli direttamente utilizzando la console Athena. Per ulteriori informazioni, consulta [Lavora con i risultati delle query e le query recenti](querying.md). ## Proprietà tabella CTAS Ogni tabella CTAS in Athena dispone di un elenco di proprietà tabella CTAS opzionali specificate dall'utente utilizzando `WITH (property_name = expression [, ...] )`. Per ulteriori informazioni sull'uso di questi parametri, consulta [Esempi di query CTAS](ctas-examples.md). ** `WITH (property_name = expression [, ...], )` ** `table_type = ['HIVE', 'ICEBERG']` Opzionale. Il valore predefinito è `HIVE`. Specifica il tipo di tabella della tabella risultante Esempio: ``` WITH (table_type ='ICEBERG') ``` `external_location = [location]` Poiché le tabelle Iceberg non sono esterne, questa proprietà non si applica ad esse. Per definire la posizione principale di una tabella Iceberg in un'istruzione CTAS, utilizza la proprietà `location` descritta più avanti in questa sezione. Opzionale. La posizione nella quale Athena salva la query CTAS in Amazon S3. Esempio: ``` WITH (external_location ='s3://amzn-s3-demo-bucket/tables/parquet_table/') ``` Athena non utilizza due volte lo stesso percorso per i risultati della query. Se si specifica il percorso manualmente, verificare che il percorso Amazon S3 non contenga dei dati. Athena non tenta mai di cancellare i tuoi dati. Se si desidera utilizzare di nuovo la stessa posizione, occorre eliminare manualmente i dati, altrimenti la query CTAS fallirà. Se si esegue una query CTAS che specifica una posizione `external_location` in un gruppo di lavoro che [applica una posizione dei risultati della query](workgroups-settings-override.md), la query non riesce e viene mostrato un messaggio di errore. Per visualizzare la posizione dei risultati della query specificata per il gruppo di lavoro, [vedere i dettagli del gruppo di lavoro](viewing-details-workgroups.md). Se il gruppo di lavoro sostituisce l'impostazione lato client per la posizione dei risultati della query, Athena crea la tabella nel percorso seguente: ``` s3://amzn-s3-demo-bucket/tables/query-id/ ``` Se non si utilizza la proprietà `external_location` per specificare una posizione e il gruppo di lavoro non sostituisce le impostazioni lato client, Athena utilizza l'[impostazione lato client](query-results-specify-location-console.md) per la posizione dei risultati della query per creare la tabella nel percorso seguente: ``` s3://amzn-s3-demo-bucket/Unsaved-or-query-name/year/month/date/tables/query-id/ ``` `is_external = [boolean]` Opzionale. Indica se la tabella è una tabella esterna. Il valore predefinito è true. Per le tabelle Iceberg, questo valore deve essere impostato su false. Esempio: ``` WITH (is_external = false) ``` `location = [location]` Obbligatorio per le tabelle Iceberg. Specifica la posizione principale della tabella Iceberg da creare partendo dai risultati della query. Esempio: ``` WITH (location ='s3://amzn-s3-demo-bucket/tables/iceberg_table/') ``` `field_delimiter = [delimiter]` Facoltativo e specifiche per formati di storage dei dati basati su testo. Il separatore di campo a carattere singolo per file in CSV, TSV e file di testo. Ad esempio, `WITH (field_delimiter = ',')`. Attualmente, i delimitatori di campo multicanale non sono supportati per le query CTAS. Se non si specifica un delimitatore, per impostazione predefinita viene utilizzato `\001`. `format = [storage_format]` Il formato di archiviazione per i risultati delle query CTAS, ad esempio `ORC`, `PARQUET`, `AVRO`, `JSON`, `ION` o `TEXTFILE`. Per le tabelle Iceberg, i formati consentiti sono `ORC`, `PARQUET` e `AVRO`. Se omesso, per impostazione predefinita viene utilizzato `PARQUET`. Il nome di questo parametro `format` deve essere elencato in lettere minuscole, altrimenti la query CTAS fallirà. Esempio: ``` WITH (format = 'PARQUET') ``` `bucketed_by = ARRAY[ column_name[,…], bucket_count = [int] ]` Questa proprietà non è valida per le tabelle Iceberg. Per le tabelle Iceberg, utilizza il partizionamento con trasformazione del bucket. Elenco matrice di bucket per periodizzare i dati. Se omesso, Athena non salva tuoi dati nel bucket in questa query. `bucket_count = [int]` Questa proprietà non è valida per le tabelle Iceberg. Per le tabelle Iceberg, utilizza il partizionamento con trasformazione del bucket. Il numero di bucket per la periodizzazione dei dati. Se omesso, Athena non conserva i dati nel bucket. Esempio: ``` CREATE TABLE bucketed_table WITH ( bucketed_by = ARRAY[column_name], bucket_count = 30, format = 'PARQUET', external_location ='s3://amzn-s3-demo-bucket/tables/parquet_table/' ) AS SELECT * FROM table_name ``` `partitioned_by = ARRAY[ col_name[,…] ]` Questa proprietà non è valida per le tabelle Iceberg. Per utilizzare le trasformazioni delle partizioni per le tabelle Iceberg, utilizza la proprietà `partitioning` descritta più avanti in questa sezione. Opzionale. Un elenco matrice di colonne in base al quale sarà partizionata la tabella CTAS. Verificare che i nomi delle colonne partizionate siano elencate per ultimi nell'elenco delle colonne della dichiarazione `SELECT`. `partitioning = ARRAY[partition_transform, ...]` Opzionale. Specifica il partizionamento della tabella Iceberg da creare. Iceberg supporta un'ampia varietà di trasformazioni ed evoluzione delle partizioni. La tabella seguente riepiloga le trasformazioni delle partizioni. **** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/create-table-as.html) Esempio: ``` WITH (partitioning = ARRAY['month(order_date)', 'bucket(account_number, 10)', 'country'])) ``` `optimize_rewrite_min_data_file_size_bytes = [long]` Opzionale. Configurazione specifica dell'ottimizzazione dei dati I file più piccoli del valore specificato sono inclusi per la compattazione. Il valore predefinito è 0,75 volte il valore di `write_target_data_file_size_bytes`. Questa proprietà si applica solo alle tabelle Iceberg. Per ulteriori informazioni, consulta [Ottimizzare le tabelle Iceberg](querying-iceberg-data-optimization.md). Esempio: ``` WITH (optimize_rewrite_min_data_file_size_bytes = 402653184) ``` `optimize_rewrite_max_data_file_size_bytes = [long]` Opzionale. Configurazione specifica dell'ottimizzazione dei dati I file più grandi del valore specificato sono inclusi per la compattazione. Il valore predefinito è 1,8 volte il valore di `write_target_data_file_size_bytes`. Questa proprietà si applica solo alle tabelle Iceberg. Per ulteriori informazioni, consulta [Ottimizzare le tabelle Iceberg](querying-iceberg-data-optimization.md). Esempio: ``` WITH (optimize_rewrite_max_data_file_size_bytes = 966367641) ``` `optimize_rewrite_data_file_threshold = [int]` Opzionale. Configurazione specifica dell'ottimizzazione dei dati Se ci sono meno file di dati che richiedono un'ottimizzazione rispetto alla soglia specificata, i file non vengono riscritti. Ciò consente l'accumulo di più file di dati per produrre file più vicini alle dimensioni di destinazione e saltare i calcoli non necessari per risparmiare sui costi. Il predefinito è 5. Questa proprietà si applica solo alle tabelle Iceberg. Per ulteriori informazioni, consulta [Ottimizzare le tabelle Iceberg](querying-iceberg-data-optimization.md). Esempio: ``` WITH (optimize_rewrite_data_file_threshold = 5) ``` `optimize_rewrite_delete_file_threshold = [int]` Opzionale. Configurazione specifica dell'ottimizzazione dei dati Se a un file di dati sono associati meno file di eliminazione rispetto alla soglia, il file di dati non viene riscritto. Ciò consente l'accumulo di più file di eliminazione per ogni file di dati per risparmiare sui costi. Il valore predefinito è 2. Questa proprietà si applica solo alle tabelle Iceberg. Per ulteriori informazioni, consulta [Ottimizzare le tabelle Iceberg](querying-iceberg-data-optimization.md). Esempio: ``` WITH (optimize_rewrite_delete_file_threshold = 2) ``` `vacuum_min_snapshots_to_keep = [int]` Opzionale. Configurazione specifica per il vacuum. Il numero minimo di snapshot più recenti da mantenere. Il valore di default è 1. Questa proprietà si applica solo alle tabelle Iceberg. Per ulteriori informazioni, consulta [VACUUM](vacuum-statement.md). La proprietà `vacuum_min_snapshots_to_keep` richiede la versione 3 del motore Athena. Esempio: ``` WITH (vacuum_min_snapshots_to_keep = 1) ``` `vacuum_max_snapshot_age_seconds = [long]` Opzionale. Configurazione specifica per il vacuum. Un periodo in secondi che rappresenta l'età degli snapshot da mantenere. Il valore predefinito è 432.000 (5 giorni). Questa proprietà si applica solo alle tabelle Iceberg. Per ulteriori informazioni, consulta [VACUUM](vacuum-statement.md). La proprietà `vacuum_max_snapshot_age_seconds` richiede la versione 3 del motore Athena. Esempio: ``` WITH (vacuum_max_snapshot_age_seconds = 432000) ``` `write_compression = [compression_format]` Il tipo di compressione da utilizzare per qualsiasi formato di archiviazione che consente di specificare la compressione. Il valore `compression_format` specifica la compressione da utilizzare quando i dati vengono scritti nella tabella. È possibile specificare la compressione per i formati file `TEXTFILE`, `JSON`, `PARQUET` e `ORC`. Ad esempio, se la proprietà `format` specifica `PARQUET` come formato di archiviazione, il valore per `write_compression` specifica il formato di compressione per Parquet. In questo caso, specificare un valore per `write_compression` equivale a specificare un valore per `parquet_compression`. Analogamente, se la proprietà `format` specifica `ORC` come formato di archiviazione, il valore per `write_compression` specifica il formato di compressione per ORC. In questo caso, specificare un valore per `write_compression` equivale a specificare un valore per `orc_compression`. Non è possibile specificare più proprietà della tabella dei formati di compressione nella stessa query CTAS. Ad esempio, non è possibile specificare sia `write_compression` che `parquet_compression` nella stessa query. Lo stesso vale per `write_compression` e `orc_compression`. Per informazioni sui tipi di compressione supportati per ciascun formato di file, consultare [Usa la compressione in Athena](compression-formats.md). `orc_compression = [compression_format]` Il tipo di compressione da utilizzare per il formato di file `ORC` quando i dati `ORC` vengono scritti nella tabella. Ad esempio, `WITH (orc_compression = 'ZLIB')`. I blocchi all'interno del file `ORC` (eccetto il Postscript `ORC`) vengono compressi utilizzando la compressione specificata. Se omesso, per impostazione predefinita per `ORC` viene utilizzata la compressione ZLIB. Si consiglia invece di utilizzare la proprietà `write_compression` al posto di `orc_compression`. Utilizzare la proprietà `format` per specificare il formato di archiviazione come `ORC`, quindi utilizzare la proprietà `write_compression` per specificare il formato di compressione che sarà utilizzato da `ORC`. `parquet_compression = [compression_format]` Il tipo di compressione da utilizzare per il formato di file Parquet quando i dati Parquet vengono scritti nella tabella. Ad esempio, `WITH (parquet_compression = 'SNAPPY')`. Questa compressione viene applicata ai blocchi di colonna all'interno dei file Parquet. Se omesso, per impostazione predefinita per Parquet viene utilizzata la compressione GZIP. Si consiglia invece di utilizzare la proprietà `write_compression` al posto di `parquet_compression`. Utilizzare la proprietà `format` per specificare il formato di archiviazione come `PARQUET`, quindi utilizzare la proprietà `write_compression` per specificare il formato di compressione che sarà utilizzato da `PARQUET`. `compression_level = [compression_level]` Il livello di compressione da utilizzare. Questa proprietà si applica solo alla compressione ZSTD. I valori possibili sono compresi tra 1 e 22. Il valore predefinito è 3. Per ulteriori informazioni, consulta [Usa i livelli di compressione ZSTD](compression-support-zstd-levels.md). ## Esempi Per esempi di query CTAS, consultare le risorse seguenti. + [Esempi di query CTAS](ctas-examples.md) + [Utilizzare CTAS e INSERT INTO per ETL e analisi dei dati](ctas-insert-into-etl.md) + [Uso di istruzioni CTAS con Amazon Athena per ridurre i costi e migliorare le prestazioni](https://aws.amazon.com/blogs/big-data/using-ctas-statements-with-amazon-athena-to-reduce-cost-and-improve-performance/) + [Utilizzare CTAS e INSERT INTO per aggirare il limite di 100 partizioni](ctas-insert-into.md) # CREATE VIEW e CREATE PROTECTED MULTI DIALECT VIEW Una vista è una tabella logica a cui possono fare riferimento le query future. Le visualizzazioni non contengono e non scrivono dati. Al contrario, la query specificata dalla visualizzazione viene eseguita ogni volta che si fa riferimento alla visualizzazione da un'altra query. + `CREATE VIEW` crea una nuova visualizzazione Athena da una query `SELECT` specificata. Le viste di Athena funzionano all’interno di Athena. Per ulteriori informazioni sulle viste di Athena, vedere. [Utilizzo delle viste](views.md) + `CREATE PROTECTED MULTI DIALECT VIEW`crea una AWS Glue Data Catalog vista in. AWS Glue Data Catalog AWS Glue Data Catalog le viste forniscono un'unica visualizzazione comune per applicazioni Servizi AWS come Amazon Athena e Amazon Redshift. Per ulteriori informazioni sulle AWS Glue Data Catalog visualizzazioni, consulta. [Utilizza le viste di Catalogo Dati in Athena](views-glue.md) ## CREATE VIEW Crea una vista da usare all’interno di Athena. ### Riepilogo ``` CREATE [ OR REPLACE ] VIEW view_name AS query ``` La clausola opzionale `OR REPLACE` consente di aggiornare la visualizzazione esistente sostituendola. Per ulteriori informazioni, consulta [Creazione delle viste](views-console.md#creating-views). ### Esempi Per creare una visualizzazione `test` dalla tabella `orders`, utilizza una query simile alla seguente: ``` CREATE VIEW test AS SELECT orderkey, orderstatus, totalprice / 2 AS half FROM orders; ``` Per creare una visualizzazione `orders_by_date` dalla tabella `orders`, utilizza la query seguente: ``` CREATE VIEW orders_by_date AS SELECT orderdate, sum(totalprice) AS price FROM orders GROUP BY orderdate; ``` Per aggiornare una visualizzazione esistente, utilizza un esempio simile al seguente: ``` CREATE OR REPLACE VIEW test AS SELECT orderkey, orderstatus, totalprice / 4 AS quarter FROM orders; ``` Per ulteriori informazioni sull’utilizzo di queste visualizzazioni, consultare [Utilizzo delle viste](views.md). ## CREATE PROTECTED MULTI DIALECT VIEW Crea una AWS Glue Data Catalog vista in AWS Glue Data Catalog. Una vista del catalogo dati è uno schema a visualizzazione singola che funziona su Athena e altri motori SQL come Amazon Redshift e Amazon EMR. ### Sintassi ``` CREATE [ OR REPLACE ] PROTECTED MULTI DIALECT VIEW view_name SECURITY DEFINER [ SHOW VIEW JSON ] AS query ``` **OR REPLACE** (Facoltativo) Aggiorna la vista esistente sostituendola. Una vista di Catalogo Dati non può essere sostituita se nella vista sono presenti dialetti SQL di altri motori. Se il motore chiamante ha l'unico dialetto SQL presente nella vista, la vista può essere sostituita. **PROTECTED** La parola chiave è obbligatoria. Specifica che la vista è protetta contro le fughe di dati. Le viste di Catalogo Dati possono essere create solo come vista `PROTECTED`. **MULTI DIALECT** Specifica che la vista supporta i dialetti SQL di diversi motori di query e può quindi essere letta da tali motori. **SECURITY DEFINER** Specifica che la semantica dei definitori è in vigore per questa vista. La semantica del definitore indica che i permessi di lettura effettivi per le tabelle sottostanti appartengono al principale o al ruolo che ha definito la vista anziché al principale che esegue la lettura effettiva. **SHOW VIEW JSON** (Facoltativo) Restituisce il codice JSON per la specifica della visualizzazione del catalogo dati senza creare effettivamente una vista. Questa opzione «dry-run» è utile quando si desidera convalidare l’SQL per la vista e restituire i metadati della tabella che verranno utilizzati. AWS Glue ### Esempio L'esempio seguente crea la vista di Catalogo Dati `orders_by_date` in base a una query sulla tabella `orders`. ``` CREATE PROTECTED MULTI DIALECT VIEW orders_by_date SECURITY DEFINER AS SELECT orderdate, sum(totalprice) AS price FROM orders WHERE order_city = 'SEATTLE' GROUP BY orderdate ``` Per ulteriori informazioni sull'utilizzo delle AWS Glue Data Catalog viste, consulta[Utilizza le viste di Catalogo Dati in Athena](views-glue.md). # DESCRIBE Visualizza una o più colonne, tra cui quelle di partizione, per la tabella specificata. Questo comando è utile per esaminare gli attributi di colonne complesse. ## Riepilogo ``` DESCRIBE [EXTENDED | FORMATTED] [db_name.]table_name [PARTITION partition_spec] [col_name ( [.field_name] | [.'$elem$'] | [.'$key$'] | [.'$value$'] )] ``` **Importante** La sintassi per questa istruzione è `DESCRIBE table_name`, non `DESCRIBE TABLE table_name`. L'utilizzo di quest'ultima sintassi genera il messaggio di errore FAILED: SemanticException [Error 10001]: Tabella non trovata tabella. ## Parameters **[EXTENDED \$1 FORMATTED]** Determina il formato dell'output. L'omissione di questi parametri mostra i nomi delle colonne e i relativi tipi di dati, incluse le colonne di partizione, in formato tabulare. La specificazione `FORMATTED` non solo mostra i nomi delle colonne e i tipi di dati in formato tabulare, ma anche informazioni dettagliate sulla tabella e sull'archiviazione. `EXTENDED` mostra le informazioni sulle colonne e sui tipi di dati in formato tabulare e metadati dettagliati per la tabella in formato serializzato Thrift. Questo formato è meno leggibile ed è utile principalmente per il debug. **[PARTITION partition\$1spec]** Se incluso, elenca i metadati per la partizione specificata da `partition_spec`, dove `partition_spec` è nel formato `(partition_column = partition_col_value, partition_column = partition_col_value, ...)`. **[col\$1name ( [.field\$1name] \$1 [.'\$1elem\$1'] \$1 [.'\$1key\$1'] \$1 [.'\$1value\$1'] )\$1 ]** Specifica la colonna e gli attributi da esaminare. Puoi specificare `.field_name` per un elemento di una struttura, `'$elem$'` per un elemento array, `'$key$'` per una chiave di mappatura e `'$value$'` per un valore di mappatura. È possibile specificare questi parametri in modo ricorsivo per esplorare ulteriormente la colonna complessa. ### Esempi ``` DESCRIBE orders ``` ``` DESCRIBE FORMATTED mydatabase.mytable PARTITION (part_col = 100) columnA; ``` La seguente query e il relativo output mostrano le informazioni relative alla colonna e al tipo di dati da una tabella `impressions` basata sui dati di esempio Amazon EMR. ``` DESCRIBE impressions ``` ``` requestbegintime string from deserializer adid string from deserializer impressionid string from deserializer referrer string from deserializer useragent string from deserializer usercookie string from deserializer ip string from deserializer number string from deserializer processid string from deserializer browsercokie string from deserializer requestendtime string from deserializer timers struct from deserializer threadid string from deserializer hostname string from deserializer sessionid string from deserializer dt string # Partition Information # col_name data_type comment dt string ``` La query e l'output di esempio riportati di seguito mostrano il risultato per la stessa tabella quando l'opzione `FORMATTED` viene utilizzata. ``` DESCRIBE FORMATTED impressions ``` ``` requestbegintime string from deserializer adid string from deserializer impressionid string from deserializer referrer string from deserializer useragent string from deserializer usercookie string from deserializer ip string from deserializer number string from deserializer processid string from deserializer browsercokie string from deserializer requestendtime string from deserializer timers struct from deserializer threadid string from deserializer hostname string from deserializer sessionid string from deserializer dt string # Partition Information # col_name data_type comment dt string # Detailed Table Information Database: sampledb Owner: hadoop CreateTime: Thu Apr 23 02:55:21 UTC 2020 LastAccessTime: UNKNOWN Protect Mode: None Retention: 0 Location: s3://us-east-1.elasticmapreduce/samples/hive-ads/tables/impressions Table Type: EXTERNAL_TABLE Table Parameters: EXTERNAL TRUE transient_lastDdlTime 1587610521 # Storage Information SerDe Library: org.openx.data.jsonserde.JsonSerDe InputFormat: org.apache.hadoop.mapred.TextInputFormat OutputFormat: org.apache.hadoop.hive.ql.io.IgnoreKeyTextOutputFormat Compressed: No Num Buckets: -1 Bucket Columns: [] Sort Columns: [] Storage Desc Params: paths requestbegintime, adid, impressionid, referrer, useragent, usercookie, ip serialization.format 1 ``` La query e l'output di esempio riportati di seguito mostrano il risultato per la stessa tabella quando l'opzione `EXTENDED` viene utilizzata. Le informazioni dettagliate della tabella vengono visualizzate su una singola riga, ma qui sono formattate per la leggibilità. ``` DESCRIBE EXTENDED impressions ``` ``` requestbegintime string from deserializer adid string from deserializer impressionid string from deserializer referrer string from deserializer useragent string from deserializer usercookie string from deserializer ip string from deserializer number string from deserializer processid string from deserializer browsercokie string from deserializer requestendtime string from deserializer timers struct from deserializer threadid string from deserializer hostname string from deserializer sessionid string from deserializer dt string # Partition Information # col_name data_type comment dt string Detailed Table Information Table(tableName:impressions, dbName:sampledb, owner:hadoop, createTime:1587610521, lastAccessTime:0, retention:0, sd:StorageDescriptor(cols:[FieldSchema(name:requestbegintime, type:string, comment:null), FieldSchema(name:adid, type:string, comment:null), FieldSchema(name:impressionid, type:string, comment:null), FieldSchema(name:referrer, type:string, comment:null), FieldSchema(name:useragent, type:string, comment:null), FieldSchema(name:usercookie, type:string, comment:null), FieldSchema(name:ip, type:string, comment:null), FieldSchema(name:number, type:string, comment:null), FieldSchema(name:processid, type:string, comment:null), FieldSchema(name:browsercokie, type:string, comment:null), FieldSchema(name:requestendtime, type:string, comment:null), FieldSchema(name:timers, type:struct, comment:null), FieldSchema(name:threadid, type:string, comment:null), FieldSchema(name:hostname, type:string, comment:null), FieldSchema(name:sessionid, type:string, comment:null)], location:s3://us-east-1.elasticmapreduce/samples/hive-ads/tables/impressions, inputFormat:org.apache.hadoop.mapred.TextInputFormat, outputFormat:org.apache.hadoop.hive.ql.io.IgnoreKeyTextOutputFormat, compressed:false, numBuckets:-1, serdeInfo:SerDeInfo(name:null, serializationLib:org.openx.data.jsonserde.JsonSerDe, parameters:{serialization.format=1, paths=requestbegintime, adid, impressionid, referrer, useragent, usercookie, ip}), bucketCols:[], sortCols:[], parameters:{}, skewedInfo:SkewedInfo(skewedColNames:[], skewedColValues:[], skewedColValueLocationMaps:{}), storedAsSubDirectories:false), partitionKeys:[FieldSchema(name:dt, type:string, comment:null)], parameters:{EXTERNAL=TRUE, transient_lastDdlTime=1587610521}, viewOriginalText:null, viewExpandedText:null, tableType:EXTERNAL_TABLE) ``` # DESCRIBE VIEW Mostra l'elenco di colonne per l'Athena o AWS Glue Data Catalog la vista specificata. Utile per esaminare gli attributi di una vista complessa. Per le viste di Catalogo dati, l’output dell’istruzione è controllato dal controllo degli accessi di Lake Formation e mostra soltanto le colonne a cui il chiamante ha accesso. ## Riepilogo ``` DESCRIBE [db_name.]view_name ``` ## Esempio ``` DESCRIBE orders ``` Consulta anche [SHOW COLUMNS](show-columns.md), [SHOW CREATE VIEW](show-create-view.md), [SHOW VIEWS](show-views.md) e [DROP VIEW](drop-view.md). # DROP DATABASE Rimuove il database denominato dal catalogo. Se il database contiene tabelle, è necessario eliminarle prima di eseguire `DROP DATABASE` o utilizzare la clausola `CASCADE`. L'uso di `DATABASE` e `SCHEMA` è intercambiabile. Significano la stessa cosa. ## Riepilogo ``` DROP {DATABASE | SCHEMA} [IF EXISTS] database_name [RESTRICT | CASCADE] ``` ## Parameters **[IF EXISTS]** Determina la rimozione dell'errore se `database_name` non esiste. **[RESTRICT\$1CASCADE]** Stabilisce come sono considerate le tabelle all'interno del `database_name` durante l'operazione `DROP`. Specificando `RESTRICT`, il database non viene eliminato se contiene tabelle. Questo è il comportamento che segue di default. Specificando `CASCADE`, verranno eliminati il database e tutte le relative tabelle. ## Esempi ``` DROP DATABASE clickstreams; ``` ``` DROP SCHEMA IF EXISTS clickstreams CASCADE; ``` **Nota** Quando tenti di eliminare un database il cui nome contiene caratteri speciali (ad esempio, `my-database`), potresti visualizzare un messaggio di errore. Per risolvere questo problema, prova a racchiudere il nome del database tra caratteri di apice retroverso (`). Per informazioni sulla denominazione dei database in Athena, consulta [Nomi di tabelle, database e colonne](tables-databases-columns-names.md). # DROP TABLE Rimuove la definizione della tabella dei metadati per la tabella denominata `table_name`. Quando elimini una tabella esterna, i dati sottostanti non vengono modificati. ## Riepilogo ``` DROP TABLE [IF EXISTS] table_name ``` ## Parameters **[ IF EXISTS ]** Determina la rimozione dell'errore se `table_name` non esiste. ## Esempi ``` DROP TABLE fulfilled_orders ``` ``` DROP TABLE IF EXISTS fulfilled_orders ``` Quando si utilizza l'editor di query della console Athena per eliminare una tabella con caratteri speciali diversi dal carattere di sottolineatura (\$1), utilizzare gli apici inversi, come nell'esempio seguente. ``` DROP TABLE `my-athena-database-01.my-athena-table` ``` Quando si utilizza il connettore JDBC per eliminare una tabella con caratteri speciali, i caratteri apice inverso non sono necessari. ``` DROP TABLE my-athena-database-01.my-athena-table ``` # DROP VIEW Elimina (elimina) un'Athena AWS Glue Data Catalog o una vista esistente. La clausola facoltativa `IF EXISTS` provoca l'errore da sopprimere se la vista non esiste. Per le viste di Catalogo dati, eliminare la vista solo se la sintassi di vista di Athena (dialetto) è presente nella vista di Catalogo Dati. Ad esempio, se un utente chiama `DROP VIEW` da Athena, la vista viene eliminata solo se al suo interno è presente il dialetto di Athena. In caso contrario, l'operazione non va a buon fine. L’eliminazione delle visualizzazioni del Catalogo dati richiede le autorizzazioni di amministratore di Lake Formation o View Definer. Per ulteriori informazioni, consultare [Utilizzo delle viste](views.md) e [Utilizza le viste di Catalogo Dati in Athena](views-glue.md). ## Riepilogo ``` DROP VIEW [ IF EXISTS ] view_name ``` ## Esempi ``` DROP VIEW orders_by_date ``` ``` DROP VIEW IF EXISTS orders_by_date ``` Consulta anche [CREATE VIEW e CREATE PROTECTED MULTI DIALECT VIEW](create-view.md), [SHOW COLUMNS](show-columns.md), [SHOW CREATE VIEW](show-create-view.md), [SHOW VIEWS](show-views.md) e [DESCRIBE VIEW](describe-view.md). # MSCK REPAIR TABLE Utilizzare il comando `MSCK REPAIR TABLE` per aggiornare i metadati nel catalogo dopo aver aggiunto le partizioni compatibili con Hive. Il comando `MSCK REPAIR TABLE` esegue la scansione di un file system, ad esempio Amazon S3 per la ricerca di partizioni compatibili con Hive aggiunte al file system dopo la creazione della tabella. `MSCK REPAIR TABLE` confronta le partizioni nei metadati della tabella e le partizioni in S3. Se sono presenti nuove partizioni nella posizione S3 specificata al momento della creazione della tabella, queste vengono aggiunte ai metadati e alla tabella Athena. Quando si aggiungono partizioni fisiche, i metadati nel catalogo diventano incoerenti con il layout dei dati nel file system e devono essere aggiunte al catalogo informazioni sulle nuove partizioni. Per aggiornare i metadati, esegui `MSCK REPAIR TABLE` in modo da poter interrogare i dati nelle nuove partizioni da Athena. **Nota** `MSCK REPAIR TABLE` aggiunge solo partizioni ai metadati; non le rimuove. Per rimuovere le partizioni dai metadati dopo che le partizioni sono state eliminate manualmente in Amazon S3, eseguire il comando `ALTER TABLE table-name DROP PARTITION`. Per ulteriori informazioni, consulta [ALTER TABLE DROP PARTITION](alter-table-drop-partition.md). ## Considerazioni e limitazioni Quando si utilizza `MSCK REPAIR TABLE`, tenere presenti le informazioni seguenti: + È possibile che l'aggiunta di tutte le partizioni richieda vari minuti. Se l'operazione scade, acquisirà lo stato "incompleta" laddove al catalogo siano state aggiunte solo alcune partizioni. In tal caso sarà necessario eseguire `MSCK REPAIR TABLE` sulla stessa tabella finché non vengono aggiunte tutte le partizioni. Per ulteriori informazioni, consulta [Come partizionare i dati](partitions.md). + Per le partizioni che non sono compatibili con Hive, utilizzare [ALTER TABLE ADD PARTITION](alter-table-add-partition.md) per caricare le partizioni in modo da poter eseguire una query sui dati. + Le posizioni delle partizioni da utilizzare con Athena devono utilizzare il protocollo `s3` (ad esempio, `s3://amzn-s3-demo-bucket/folder/`). In Athena, i percorsi che utilizzano altri protocolli (ad esempio, `s3a://bucket/folder/`) determineranno errori quando le query `MSCK REPAIR TABLE` vengono eseguite sulle tabelle contenenti. + Poiché `MSCK REPAIR TABLE` analizza sia una cartella che le relative sottocartelle per trovare uno schema di partizioni corrispondente, assicurarsi di conservare i dati per tabelle separate in gerarchie di cartelle separate. Supponiamo ad esempio che tu abbia dati per la tabella 1 in `s3://amzn-s3-demo-bucket1` e dati per la tabella 2 in `s3://amzn-s3-demo-bucket1/table-2-data`. Se entrambe le tabelle sono partizionate per stringa, `MSCK REPAIR TABLE` aggiungerà le partizioni per la tabella 2 alla tabella 1. Per evitare ciò, si consiglia di utilizzare invece strutture di cartelle separate come `s3://amzn-s3-demo-bucket1` e `s3://amzn-s3-demo-bucket2`. Questo comportamento è coerente con Amazon EMR e Apache Hive. + A causa di un problema noto, `MSCK REPAIR TABLE` avrà esito negativo e non verrà inviato alcun messaggio di errore quando i valori delle partizioni contengono i due punti (`:`) (ad esempio, quando il valore della partizione è un timestamp). Come soluzione alternativa, utilizza [ALTER TABLE ADD PARTITION](alter-table-add-partition.md). + `MSCK REPAIR TABLE` non aggiunge nomi di colonne di partizione che iniziano con un carattere di sottolineatura (\$1). Per ovviare al problema della limitazione, utilizza [ALTER TABLE ADD PARTITION](alter-table-add-partition.md). ## Riepilogo ``` MSCK REPAIR TABLE table_name ``` ## Esempi ``` MSCK REPAIR TABLE orders; ``` ## Risoluzione dei problemi Dopo l'esecuzione`MSCK REPAIR TABLE`, se Athena non aggiunge le partizioni alla tabella in AWS Glue Data Catalog, verifica quanto segue: + **AWS Glue accesso**: assicurati che il ruolo AWS Identity and Access Management (IAM) disponga di una politica che consenta l'azione`glue:BatchCreatePartition`. Per ulteriori informazioni, consultare [Allow glue: BatchCreatePartition nella policy IAM](#msck-repair-table-troubleshooting-allow-gluebatchcreatepartition-in-the-policy) riportata di seguito in questo documento. + **Accesso ad Amazon S3**: assicurati che il ruolo disponga di una policy con autorizzazioni sufficienti per accedere ad Amazon S3, inclusa l'operazione [https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_DescribeJob.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_DescribeJob.html). Per un esempio di quali operazioni Amazon S3 consentire, consulta la policy del bucket di esempio in [Accesso tra account in Athena a bucket Amazon S3](cross-account-permissions.md). + **Maiuscole e minuscole delle chiavi oggetto Amazon S3**: assicurati che il percorso Amazon S3 sia in minuscolo invece che in camel case (ad esempio `userid` invece di `userId`) o utilizza `ALTER TABLE ADD PARTITION` per specificare i nomi delle chiavi oggetto. Per ulteriori informazioni, consultare [Modificare o ridefinire il percorso Amazon S3](#msck-repair-table-troubleshooting-change-or-redefine-the-amazon-s3-path) riportata di seguito in questo documento. + **Timeout per query** – `MSCK REPAIR TABLE` viene utilizzato al meglio quando si crea una tabella per la prima volta o quando vi è incertezza sulla parità tra i metadati dei dati e delle partizioni. Se utilizzi `MSCK REPAIR TABLE` per aggiungere frequentemente nuove partizioni (ad esempio, su base giornaliera) e si verificano timeout di query, prendere in considerazione l'utilizzo di [ALTER TABLE ADD PARTITION](alter-table-add-partition.md). + **Partizioni mancanti dal file system**: se elimini manualmente una partizione in Amazon S3 e poi esegui `MSCK REPAIR TABLE`, è possibile che venga visualizzato il messaggio di errore Partizioni mancanti dal file system. Ciò si verifica perché `MSCK REPAIR TABLE` non rimuove le partizioni obsolete dai metadati della tabella. Per rimuovere le partizioni eliminate dai metadati della tabella, eseguire invece [ALTER TABLE DROP PARTITION](alter-table-drop-partition.md). Nota che[SHOW PARTITIONS](show-partitions.md) elenca in modo simile solo le partizioni nei metadati, non le partizioni nel file system. + **Errore «NullPointerException name is null»** Se si utilizza l'operazione AWS Glue [CreateTable](https://docs.aws.amazon.com/glue/latest/webapi/API_CreateTable.html)API o il CloudFormation [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-glue-table.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-glue-table.html)modello per creare una tabella da utilizzare in Athena senza specificare la `TableType` proprietà e quindi si esegue una query DDL come `SHOW CREATE TABLE` o`MSCK REPAIR TABLE`, è possibile ricevere il messaggio di errore FAILED: NullPointerException Name is null. [Per risolvere l'errore, specifica un valore per l'[TableInput](https://docs.aws.amazon.com/glue/latest/webapi/API_TableInput.html)`TableType`attributo come parte della chiamata o del modello AWS Glue`CreateTable` API.CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-table-tableinput.html) I valori possibili per `TableType` includono `EXTERNAL_TABLE` o `VIRTUAL_VIEW`. Questo requisito si applica solo quando si crea una tabella utilizzando l'operazione AWS Glue `CreateTable` API o il `AWS::Glue::Table` modello. Se si crea una tabella per Athena utilizzando un'istruzione DDL o un crawler AWS Glue , la proprietà `TableType` viene definita automaticamente. Nelle sezioni seguenti vengono fornite informazioni aggiuntive. ### Allow glue: BatchCreatePartition nella policy IAM Esamina le policy IAM collegate al ruolo che stai utilizzando per eseguire `MSCK REPAIR TABLE`. Quando si [utilizza AWS Glue Data Catalog con Athena](data-sources-glue.md), la policy IAM deve consentire l'azione`glue:BatchCreatePartition`. Per un esempio di policy IAM che consente l'operazione `glue:BatchCreatePartition`, vedere [AWS politica gestita: AmazonAthenaFullAccess](security-iam-awsmanpol.md#amazonathenafullaccess-managed-policy). ### Modificare o ridefinire il percorso Amazon S3 Se una o più chiavi oggetto nel percorso Amazon S3 sono in maiuscolo anziché in minuscolo, `MSCK REPAIR TABLE` potrebbe non essere in grado di aggiungere le partizioni a AWS Glue Data Catalog. Ad esempio, se il percorso Amazon S3 include il nome della chiave oggetto `userId`, le seguenti partizioni potrebbero non essere aggiunte a AWS Glue Data Catalog: ``` s3://amzn-s3-demo-bucket/path/userId=1/ s3://amzn-s3-demo-bucket/path/userId=2/ s3://amzn-s3-demo-bucket/path/userId=3/ ``` Per risolvere il problema, procedi in uno dei seguenti modi: + Usa le lettere minuscole anziché le maiuscole camel quando crei le tue chiavi oggetto Amazon S3: ``` s3://amzn-s3-demo-bucket/path/userid=1/ s3://amzn-s3-demo-bucket/path/userid=2/ s3://amzn-s3-demo-bucket/path/userid=3/ ``` + Utilizza [ALTER TABLE ADD PARTITION](alter-table-add-partition.md) per ridefinire il percorso, come nell'esempio seguente: ``` ALTER TABLE table_name ADD [IF NOT EXISTS] PARTITION (userId=1) LOCATION 's3://amzn-s3-demo-bucket/path/userId=1/' PARTITION (userId=2) LOCATION 's3://amzn-s3-demo-bucket/path/userId=2/' PARTITION (userId=3) LOCATION 's3://amzn-s3-demo-bucket/path/userId=3/' ``` Tieni presente che, sebbene i nomi delle chiavi degli oggetti di Amazon S3 possano utilizzare lettere maiuscole, i nomi dei bucket di Amazon S3 devono essere sempre in minuscolo. Per ulteriori informazioni, consulta le [Linee guida per la denominazione delle chiavi oggetto](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html#object-key-guidelines) e le [Regole di denominazione dei bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucketnamingrules.html) nella *Guida per l'utente di Amazon S3*. # SHOW COLUMNS Mostra solo i nomi delle colonne per una singola tabella, vista Athena o Catalogo dati specificati. Per ottenere informazioni più dettagliate sulle viste di Athena, interrogate invece il AWS Glue Data Catalog . Per informazioni ed esempi, consulta le sezioni seguenti nell'argomento [Interroga il AWS Glue Data Catalog](querying-glue-catalog.md): + Per visualizzare i metadati delle colonne, ad esempio il tipo di dati, consulta [Elencare o ricercare colonne per una tabella o una vista specificata](querying-glue-catalog-listing-columns.md). + Per visualizzare tutte le colonne di ogni tabella in un database specifico in `AwsDataCatalog`, consulta [Elencare o ricercare colonne per una tabella o una vista specificata](querying-glue-catalog-listing-columns.md). + Per visualizzare tutte le colonne per tutte le tabelle in tutti i database in `AwsDataCatalog`, consulta [Elencare tutte le colonne di ogni tabella](querying-glue-catalog-listing-all-columns-for-all-tables.md). + Per visualizzare le colonne che hanno in comune tabelle specifiche di un database, consulta [Elenca le colonne che hanno in comune tabelle specifiche](querying-glue-catalog-listing-columns-in-common.md). Per le viste del Catalogo dati, l’output dell’istruzione è controllato dal controllo degli accessi di Lake Formation e mostra solo le colonne a cui il chiamante ha accesso. ## Riepilogo ``` SHOW COLUMNS {FROM|IN} database_name.table_or_view_name ``` ``` SHOW COLUMNS {FROM|IN} table_or_view_name [{FROM|IN} database_name] ``` Le parole chiave `FROM` e `IN` possono essere utilizzate in modo intercambiabile. Se *table\$1or\$1view\$1name* o *database\$1name* contiene caratteri speciali come trattini, racchiudi il nome tra virgolette (ad esempio,). ``my-database`.`my-table`` Non racchiudete o tra virgolette singole *table\$1or\$1view\$1name* o *database\$1name* doppie. Attualmente, l'uso di `LIKE` e le espressioni di corrispondenza dei modelli non sono supportati. ## Esempi Gli esempi equivalenti seguenti mostrano le colonne della tabella `orders` nel database `customers`. I primi due esempi presuppongono che `customers` sia il database corrente. ``` SHOW COLUMNS FROM orders ``` ``` SHOW COLUMNS IN orders ``` ``` SHOW COLUMNS FROM customers.orders ``` ``` SHOW COLUMNS IN customers.orders ``` ``` SHOW COLUMNS FROM orders FROM customers ``` ``` SHOW COLUMNS IN orders IN customers ``` # SHOW CREATE TABLE Analizza una tabella esistente denominata `table_name` per generare la query che l'ha creata. ## Riepilogo ``` SHOW CREATE TABLE [db_name.]table_name ``` ## Parameters **TABLE [db\$1name.]table\$1name** Il parametro `db_name` è facoltativo. Se omesso, il contesto rimanda automaticamente al database corrente. Il nome della tabella è obbligatorio. ## Esempi ``` SHOW CREATE TABLE orderclickstoday; ``` ``` SHOW CREATE TABLE `salesdata.orderclickstoday`; ``` ## Risoluzione dei problemi Se si utilizza l'operazione AWS Glue [CreateTable](https://docs.aws.amazon.com/glue/latest/webapi/API_CreateTable.html)API o il CloudFormation [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-glue-table.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-glue-table.html)modello per creare una tabella da utilizzare in Athena senza specificare la `TableType` proprietà e quindi si esegue una query DDL come `SHOW CREATE TABLE` o`MSCK REPAIR TABLE`, è possibile ricevere il messaggio di errore FAILED: NullPointerException Name is null. [Per risolvere l'errore, specifica un valore per l'[TableInput](https://docs.aws.amazon.com/glue/latest/webapi/API_TableInput.html)`TableType`attributo come parte della chiamata o del modello AWS Glue`CreateTable` API.CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-table-tableinput.html) I valori possibili per `TableType` includono `EXTERNAL_TABLE` o `VIRTUAL_VIEW`. Questo requisito si applica solo quando si crea una tabella utilizzando l'operazione AWS Glue `CreateTable` API o il `AWS::Glue::Table` modello. Se si crea una tabella per Athena utilizzando un'istruzione DDL o un crawler AWS Glue , la proprietà `TableType` viene definita automaticamente. # SHOW CREATE VIEW Mostra l’istruzione SQL che ha creato la vista specificata Athena o la vista specificata Catalogo dati. L'istruzione SQL restituita mostra la sintassi di creazione della vista utilizzata in Athena. Chiamare `SHOW CREATE VIEW` alle viste del Catalogo dati richiede le autorizzazioni di amministratore o view definer di Lake Formation. ## Riepilogo ``` SHOW CREATE VIEW view_name ``` ## Esempi ``` SHOW CREATE VIEW orders_by_date ``` Consulta anche [CREATE VIEW e CREATE PROTECTED MULTI DIALECT VIEW](create-view.md) e [DROP VIEW](drop-view.md). # SHOW DATABASES Elenca tutti i database definiti nel metastore. È possibile utilizzare `DATABASES` o `SCHEMAS`. Significano la stessa cosa. L'equivalente programmatico di `SHOW DATABASES` è l'azione API [ListDatabases](https://docs.aws.amazon.com/athena/latest/APIReference/API_ListDatabases.html)Athena. [Il metodo equivalente in AWS SDK per Python (Boto3) è list\$1databases.](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/athena/client/list_databases.html) ## Riepilogo ``` SHOW {DATABASES | SCHEMAS} [LIKE 'regular_expression'] ``` ## Parameters **[COME ''] *regular\$1expression*** Filtra l'elenco di database mostrando solo quelli che soddisfano la `regular_expression` specificata. Per la corrispondenza dei caratteri jolly, è possibile utilizzare la combinazione `.*`, che corrisponde a qualsiasi carattere zero a tempi illimitati. ## Esempi ``` SHOW SCHEMAS; ``` ``` SHOW DATABASES LIKE '.*analytics'; ``` # SHOW PARTITIONS Elenca tutte le partizioni in una tabella Athena in ordine non ordinato. ## Riepilogo ``` SHOW PARTITIONS table_name ``` + Per visualizzare le partizioni in una tabella ed elencarle in un ordine specifico, vedere la sezione [Elencare partizioni per una tabella specifica](querying-glue-catalog-listing-partitions.md) nella pagina [Interroga il AWS Glue Data Catalog](querying-glue-catalog.md). + Per visualizzare il contenuto di una partizione, vedere la sezione [Esecuzione di query sui dati](partitions.md#query-the-data) della pagina [Come partizionare i dati](partitions.md). + `SHOW PARTITIONS`non elenca le partizioni proiettate da Athena ma non registrate nel catalogo. AWS Glue Per informazioni sulla proiezione delle partizioni, consulta [Proiezione delle partizioni con Amazon Athena](partition-projection.md). + `SHOW PARTITIONS` elenca le partizioni nei metadati, non le partizioni nel file system effettivo. Per aggiornare i metadati dopo aver eliminato manualmente le partizioni in Amazon S3, eseguire [ALTER TABLE DROP PARTITION](alter-table-drop-partition.md). ## Esempi La query di esempio seguente mostra le partizioni per l'oggetto `flight_delays_csv`, che mostra i dati della tabella di volo del Dipartimento dei Trasporti degli Stati Uniti. Per ulteriori informazioni sulle tabelle `flight_delays_csv` in questo esempio, consulta [Lazy SerDe Simple per file CSV, TSV e delimitati in modo personalizzato](lazy-simple-serde.md). La tabella è suddivisa per anno. ``` SHOW PARTITIONS flight_delays_csv ``` **Risultati** ``` year=2007 year=2015 year=1999 year=1993 year=1991 year=2003 year=1996 year=2014 year=2004 year=2011 ... ``` La query di esempio seguente mostra le partizioni per l'oggetto `impressions`, che contiene dati di esplorazione Web di esempio. Per ulteriori informazioni sulle tabelle `impressions` in questo esempio, consulta [Come partizionare i dati](partitions.md). La tabella è partizionata dal comando `dt` (datetime). ``` SHOW PARTITIONS impressions ``` **Risultati** ``` dt=2009-04-12-16-00 dt=2009-04-13-18-15 dt=2009-04-14-00-20 dt=2009-04-12-13-00 dt=2009-04-13-02-15 dt=2009-04-14-12-05 dt=2009-04-14-06-15 dt=2009-04-12-21-15 dt=2009-04-13-22-15 ... ``` ### Elenco delle partizioni in ordine ordinato Per ordinare le partizioni nell'elenco dei risultati, utilizza la seguente sintassi `SELECT` invece di `SHOW PARTITIONS`. ``` SELECT * FROM database_name."table_name$partitions" ORDER BY column_name ``` La query seguente mostra l'elenco delle partizioni per l'esempio `flight_delays_csv`, ma in ordine. ``` SELECT * FROM "flight_delays_csv$partitions" ORDER BY year ``` **Risultati** ``` year 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 ... ``` Per ulteriori informazioni, consulta la sezione [Elencare partizioni per una tabella specifica](querying-glue-catalog-listing-partitions.md) nella pagina [Interroga il AWS Glue Data Catalog](querying-glue-catalog.md). # SHOW TABLES Elenca tutte le tabelle di base e le viste in un database. **Nota** Il [StatementType](https://docs.aws.amazon.com/athena/latest/APIReference/API_QueryExecution.html#athena-Type-QueryExecution-StatementType)parametro per `SHOW TABLES` il funzionamento dell'[GetQueryExecution](https://docs.aws.amazon.com/athena/latest/APIReference/API_GetQueryExecution.html)API è classificato come`UTILITY`, non`DDL`. ## Riepilogo ``` SHOW TABLES [IN database_name] ['regular_expression'] ``` ## Parameters **[IN database\$1name]** Specifica il `database_name` da cui saranno elencate le tabelle. Se omesso, sarà utilizzato automaticamente il database dal contesto corrente. `SHOW TABLES` potrebbe fallire se `database_name` utilizza un [carattere non supportato](tables-databases-columns-names.md) come un trattino. Come soluzione alternativa, prova a racchiudere il nome del database tra i backtick. **['regular\$1expression']** Filtra l'elenco di tabelle mostrando solo quelle che soddisfano la `regular_expression` specificata. Per indicare qualsiasi carattere nelle tabelle `AWSDataCatalog` è possibile utilizzare le espressioni jolly `*` o `.*`. Per i database Apache Hive, utilizzare l'espressione jolly `.*`. Per indicare una scelta tra i caratteri, utilizzare il carattere `|`. ## Esempi **Example mostra tutte le tabelle nel database `sampledb`** ``` SHOW TABLES IN sampledb ``` `Results` ``` alb_logs cloudfront_logs elb_logs flights_2016 flights_parquet view_2016_flights_dfw ``` **Example mostra i nomi di tutte le tabelle `sampledb` che includono la parola "flights"** ``` SHOW TABLES IN sampledb '*flights*' ``` `Results` ``` flights_2016 flights_parquet view_2016_flights_dfw ``` **Example mostra i nomi di tutte le tabelle in `sampledb` che terminano nella parola "logs"** ``` SHOW TABLES IN sampledb '*logs' ``` `Results` ``` alb_logs cloudfront_logs elb_logs ``` # SHOW TBLPROPERTIES Elenca le proprietà della tabella con nome. ## Riepilogo ``` SHOW TBLPROPERTIES table_name [('property_name')] ``` ## Parameters **[('property\$1name')]** Se incluso, viene elencato solo il valore della proprietà denominata `property_name`. ## Esempi ``` SHOW TBLPROPERTIES orders; ``` ``` SHOW TBLPROPERTIES orders('comment'); ``` # SHOW VIEWS Elencare le viste Athena o Catalogo dati in un elenco di valori di tipo `STRING`. Ciascun valore nell’elenco è il nome di una vista nel database specificato o, se si omette il nome del database, di quelle nel database corrente. Utilizza la clausola `LIKE` facoltativa con un'espressione regolare per limitare l'elenco dei nomi di vista. Per le viste del catalogo dati, elencare solo le viste che utilizzano la sintassi SQL Athena. Le altre visualizzazioni del catalogo dati vengono filtrate. ## Riepilogo ``` SHOW VIEWS [IN database_name] [LIKE 'regular_expression'] ``` ### Parameters **[IN database\$1name]** Specifica il `database_name` da cui saranno elencate le viste. Se omesso, sarà utilizzato automaticamente il database dal contesto corrente. **[LIKE 'regular\$1expression']** Filtra l'elenco delle viste mostrando solo quelle che soddisfano la `regular_expression` specificata. È possibile utilizzare solo il carattere jolly `*`, il quale indica qualsiasi carattere, o `|`, il quale indica una scelta tra caratteri. ## Esempi ``` SHOW VIEWS ``` ``` SHOW VIEWS IN marketing_analytics LIKE 'orders*' ``` Consulta anche [SHOW COLUMNS](show-columns.md), [SHOW CREATE VIEW](show-create-view.md), [DESCRIBE VIEW](describe-view.md) e [DROP VIEW](drop-view.md). # Considerazioni e restrizioni per le query SQL in Amazon Athena Quando si eseguono query sulle tabelle Athena, tenere presente le seguenti considerazioni e limitazioni: + **Procedure archiviate**: le procedure archiviate non sono supportate. + **Numero massimo di partizioni**: il numero massimo di partizioni che è possibile creare con le istruzioni `CREATE TABLE AS SELECT` (CTAS) è 100. Per ulteriori informazioni, consulta [CREATE TABLE AS](create-table-as.md). Per una soluzione alternativa, vedere [Utilizzare CTAS e INSERT INTO per aggirare il limite di 100 partizioni](ctas-insert-into.md). + **Istruzioni non supportate**: le istruzioni non supportate includono le seguenti. Per un elenco delle istruzioni DDL non supportate in Athena, consultare [DDL non supportato](unsupported-ddl.md). + `CREATE TABLE LIKE` non è supportato. + `DESCRIBE INPUT` e `DESCRIBE OUTPUT` non sono supportate. + L'istruzione `MERGE` è supportata solo per i formati di tabelle transazionali. Per ulteriori informazioni, consulta [MERGE INTO](merge-into-statement.md). + Le istruzioni `UPDATE` non sono supportate. + `DELETE FROM` non è supportato. + **Connettori Trino e Presto**: i connettori [Trino](https://trino.io/docs/current/connector.html) e [Presto](https://prestodb.io/docs/current/connector.html) non sono supportati. Utilizzare Amazon Athena Federated Query per collegare le origini dati. Per ulteriori informazioni, consulta [Utilizza Amazon Athena Federated Query](federated-queries.md). + **Timeout su tabelle con molte partizioni** – Athena potrebbe verificarsi un timeout quando si esegue una query su una tabella con molte migliaia di partizioni. Questo può accadere quando la tabella ha molte partizioni che non sono di tipo `string`. Quando si utilizza il tipo `string`, Athena elimina le partizioni a livello di metastore. Tuttavia, quando si utilizzano altri tipi di dati, Athena elimina le partizioni a livello di server. Più partizioni hai, più questo processo richiede tempo e più è probabile che le tue query vadano in timeout. Per risolvere questo problema, impostare il tipo di partizione su `string` in modo che Athena elimini le partizioni a livello di metastore. Ciò riduce il sovraccarico e impedisce il timeout delle query. + Supporto per **Amazon Glacier**: per informazioni sull’esecuzione di query su oggetti Amazon Glacier ripristinati, consultare [Eseguire query su oggetti Amazon Glacier ripristinati](querying-glacier.md). + **File trattati come nascosti** – Athena tratta i file sorgenti che iniziano con un trattino basso (`_`) o un punto (`.`) come nascosti. Per aggirare questa limitazione, rinominare i file. + **Limitazione della dimensione di righe o colonne** — Le dimensioni di una singola riga o delle relative colonne non può superare i 32 MB. Questo limite può essere superato quando, ad esempio, una riga contiene una singola colonna di 35 MB. Questo è un limite fissato per il servizio che non può essere modificato. + **Lunghezza massima della riga in un file di testo**: la dimensione di una singola riga in un file di testo ha un limite massimo di 200 MB. Il superamento di questo limite può produrre il messaggio di errore TextLineLengthLimitExceededException: Troppi byte prima della nuova riga. Per aggirare questa limitazione, assicurarsi di non avere alcuna riga in un file di testo che supera i 200 MB. + **Massimo clausola LIMIT**: il numero massimo di righe che è possibile specificare per la clausola `LIMIT` è 9223372036854775807. Quando si utilizza `ORDER BY`, il numero massimo di righe supportate per la clausola LIMIT è 2147483647. Il superamento di questo limite causa il messaggio di errore NOT\$1SUPPORTED: ORDER BY LIMIT > 2147483647 is not supported (NOT\$1SUPPORTED: ORDER BY LIMIT > 2147483647 non è supportato). + **information\$1schema**: l'interrogazione `information_schema` è più performante se si dispone di una quantità di metadati da piccola a moderata. AWS Glue Se disponi di una quantità di metadati elevata, possono verificarsi degli errori. Per informazioni sull'interrogazione dei metadati nel database, consulta. `information_schema` AWS Glue [Interroga il AWS Glue Data Catalog](querying-glue-catalog.md) + **Inizializzazioni dell'array**: a causa di una limitazione in Java, non è possibile inizializzare un array in Athena con più di 254 argomenti. + **Colonne di metadati nascoste**: le colonne di metadati nascoste Hive o Iceberg, `$bucket`, `$file_modified_time`, `$file_size` e `$partition` non sono supportate per le visualizzazioni. Per informazioni sull'utilizzo della colonna dei metadati `$path` in Athena, consulta [Ottenere le posizioni dei file per i dati di origine in Amazon S3](select.md#select-path). Per informazioni sulla lunghezza massima della stringa di query, sulle quote per i timeout delle query e sulle quote per il numero attivo di query DML, consulta la sezione [Service Quotas](service-limits.md).