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à. # 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\_query [, ....] ]** È 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 \| DISTINCT ] select\_expr** `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\_item [, ...]** 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 \| DISTINCT] grouping\_expressions [,...]]** 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. **[ { UNION \| INTERSECT \| EXCEPT } [ ALL \| DISTINCT ] union\_query] ]** `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 \| DESC ] [ NULLS FIRST \| 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 \| 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 \| 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 \| 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\_or\_map) [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) |