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à. # Comando SELECT **Importante** Amazon S3 Select non è più disponibile per i nuovi clienti. I clienti esistenti di Amazon S3 Select possono continuare a utilizzare la funzionalità come di consueto. [Ulteriori informazioni](https://aws.amazon.com/blogs/storage/how-to-optimize-querying-your-data-in-amazon-s3/) Amazon S3 Select supporta soltanto il comando SQL `SELECT`. Le seguenti clausole standard ANSI sono supportate per `SELECT`: + `SELECT` Elenco + `FROM`Clausola + `WHERE`Clausola + `LIMIT`Clausola **Nota** Al momento, le query di Amazon S3 Select non supportano query secondarie o join. ## SELECT Elenco L'elenco `SELECT` assegna un nome a colonne, funzioni ed espressioni che la query deve restituire. L'elenco rappresenta l'output della query. ``` SELECT * SELECT projection1 AS column_alias_1, projection2 AS column_alias_2 ``` La prima forma di `SELECT` con `*` (asterisco) restituisce ogni riga che ha passato la clausola , così com'è. Il secondo formato di `SELECT` crea una riga con espressioni scalari di output definite dall’utente **`projection1`** e **`projection2`** per ogni colonna. ## FROMClausola Amazon S3 Select supporta i seguenti formati della clausola `FROM`: ``` FROM table_name FROM table_name alias FROM table_name AS alias ``` In ogni forma della clausola `FROM`, `table_name` è il `S3Object` che viene interrogato. Gli utenti abituati a database relazionali tradizionali possono considerare questo come uno schema di database che contiene più viste di una tabella. Nel linguaggio SQL standard, la clausola `FROM` crea righe che vengono filtrate nella clausola `WHERE` e proiettate nell'elenco `SELECT`. Per tutti gli oggetti JSON archiviati in Amazon S3 Select, puoi anche utilizzare i seguenti moduli della clausola `FROM`: ``` FROM S3Object[*].path FROM S3Object[*].path alias FROM S3Object[*].path AS alias ``` Utilizzando questo modulo della clausola `FROM`, puoi selezionare da array o oggetti inclusi in un oggetto JSON. Puoi specificare `path` mediante uno dei seguenti moduli: + Per nome (in un oggetto): `.name` o `['name']` + Per indice (in un array): `[index]` + Per carattere jolly (in un oggetto): `.*` + Per carattere jolly (in un array): `[*]` **Nota** Questo modulo della clausola `FROM` è utilizzabile solo con oggetti JSON. I caratteri jolly emettono sempre almeno un record. Se nessun record corrisponde, Amazon S3 Select emette il valore `MISSING`. Durante la serializzazione dell'output (dopo che la query è stata completata), Amazon S3 Select sostituisce i valori `MISSING` con record vuoti. Le funzioni di aggregazione (`AVG`, `COUNT`, `MAX`, `MIN` e `SUM`) ignorano i valori `MISSING`. Se non fornisci un alias quando utilizzi un carattere jolly, puoi fare riferimento alla riga utilizzando l'ultimo elemento nel percorso. Ad esempio, puoi selezionare tutti i prezzi da un elenco di libri utilizzando la query `SELECT price FROM S3Object[*].books[*].price`. Se il percorso termina con un carattere jolly anziché con un nome, puoi utilizzare il valore `_1` per fare riferimento alla riga. Ad esempio, anziché `SELECT price FROM S3Object[*].books[*].price`, puoi usare la query `SELECT _1.price FROM S3Object[*].books[*]`. Amazon S3 Select considera sempre un documento JSON come un array di valori a livello di radice. Pertanto, anche se l'oggetto JSON che stai interrogando ha solo un elemento radice, la clausola `FROM` deve iniziare con `S3Object[*]`. Tuttavia, per motivi di compatibilità, Amazon S3 Select consente di omettere il carattere jolly se non si include un percorso. Pertanto, la clausola completa `FROM S3Object` è equivalente a `FROM S3Object[*] as S3Object`. Se includi un percorso, devi utilizzare anche il carattere jolly. Pertanto `FROM S3Object` e `FROM S3Object[*].path` sono entrambe clausole valide, ma `FROM S3Object.path` non è valida. **Example** **Esempi:** *Esempio 1* Questo esempio mostra i risultati utilizzando i seguenti set di dati e query: ``` { "Rules": [ {"id": "1"}, {"expr": "y > x"}, {"id": "2", "expr": "z = DEBUG"} ]} { "created": "June 27", "modified": "July 6" } ``` ``` SELECT id FROM S3Object[*].Rules[*].id ``` ``` {"id":"1"} {} {"id":"2"} {} ``` Amazon S3 Select produce ciascun risultato per i seguenti motivi: + `{"id":"id-1"}`— `S3Object[0].Rules[0].id` ha prodotto una corrispondenza. + `{}` - `S3Object[0].Rules[1].id` non ha prodotto una corrispondenza con un record, quindi Amazon S3 Select ha emesso un valore `MISSING`, che è stato quindi modificato in un record vuoto durante la serializzazione dell'output e restituito. + `{"id":"id-2"}`— `S3Object[0].Rules[2].id` ha prodotto una corrispondenza. + `{}`-`S3Object[1]` non ha prodotto una corrispondenza in `Rules`, quindi Amazon S3 Select ha emesso un valore `MISSING`, che è stato quindi modificato in un record vuoto durante la serializzazione dell'output e restituito. Se non desideri che Amazon S3 Select restituisca record vuoti quando non trova una corrispondenza, puoi testare il valore `MISSING`. La seguente query restituisce gli stessi risultati della query precedente, ma con i valori vuoti omessi: ``` SELECT id FROM S3Object[*].Rules[*].id WHERE id IS NOT MISSING ``` ``` {"id":"1"} {"id":"2"} ``` *Esempio 2* Questo esempio mostra i risultati utilizzando i seguenti set di dati e query: ``` { "created": "936864000", "dir_name": "important_docs", "files": [ { "name": "." }, { "name": ".." }, { "name": ".aws" }, { "name": "downloads" } ], "owner": "Amazon S3" } { "created": "936864000", "dir_name": "other_docs", "files": [ { "name": "." }, { "name": ".." }, { "name": "my stuff" }, { "name": "backup" } ], "owner": "User" } ``` ``` SELECT d.dir_name, d.files FROM S3Object[*] d ``` ``` {"dir_name":"important_docs","files":[{"name":"."},{"name":".."},{"name":".aws"},{"name":"downloads"}]} {"dir_name":"other_docs","files":[{"name":"."},{"name":".."},{"name":"my stuff"},{"name":"backup"}]} ``` ``` SELECT _1.dir_name, _1.owner FROM S3Object[*] ``` ``` {"dir_name":"important_docs","owner":"Amazon S3"} {"dir_name":"other_docs","owner":"User"} ``` ## WHEREClausola La sintassi della clausola `WHERE` è la seguente: ``` WHERE condition ``` La clausola `WHERE` filtra le righe in base alla `condition`. Una condizione è un'espressione che genera un risultato booleano. Solo le righe per le quali la condizione è `TRUE` sono restituite nel risultato. ## LIMITClausola La sintassi della clausola `LIMIT` è la seguente: ``` LIMIT number ``` La clausola `LIMIT` limita il numero di record che desideri vengano restituiti dalla query in base al `number` specificato. ## Accesso agli attributi Le clausole `SELECT` e `WHERE` possono fare riferimento a record di dati utilizzando uno dei metodi descritti nelle seguenti sezioni, a seconda che il file su cui viene eseguita la query sia in formato CSV o JSON. ### CSV + **Numeri di colonna**: puoi fare riferimento alla *N-esima* colonna di una riga con il nome di colonna `_N`, dove *`N`* è la posizione della colonna. La numerazione delle posizioni inizia da 1. Ad esempio, la prima colonna è denominata `_1` e la seconda è denominata `_2`. Puoi fare riferimento a una colonna con `_N` o `alias._N`. Ad esempio, `_2` e `myAlias._2` sono entrambi modi validi di fare riferimento a una colonna nell'elenco `SELECT` e nella clausola `WHERE`. + **Intestazioni di colonna**: per gli oggetti in formato CSV che hanno una riga di intestazione, le intestazioni sono disponibili per l'elenco `SELECT` e la clausola `WHERE`. In particolare, come nel linguaggio SQL classico, all'interno di espressioni con le clausole `SELECT` e `WHERE` è possibile fare riferimento alle colonne in base a `alias.column_name` o `column_name`. ### JSON + **Documento**: puoi accedere ai campi di documento JSON con `alias.name`. È inoltre possibile accedere ai campi nidificati, ad esempio `alias.name1.name2.name3`. + **Elenco**: puoi accedere agli elementi in un elenco JSON utilizzando indici a base zero con l'operatore `[]`. Ad esempio, puoi accedere al secondo elemento di un elenco con `alias[1]`. È possibile abbinare l'accesso agli elementi dell'elenco con i campi, `alias.name1.name2[1].name3`, ad esempio. + **Esempi:** considera questo oggetto JSON come un set di dati di esempio: ``` {"name": "Susan Smith", "org": "engineering", "projects": [ {"project_name":"project1", "completed":false}, {"project_name":"project2", "completed":true} ] } ``` *Esempio 1* La seguente query restituisce questi risultati: ``` Select s.name from S3Object s ``` ``` {"name":"Susan Smith"} ``` *Esempio 2* La seguente query restituisce questi risultati: ``` Select s.projects[0].project_name from S3Object s ``` ``` {"project_name":"project1"} ``` ## Distinzione tra maiuscole e minuscole nei nomi di intestazioni/attributi Con Amazon S3 Select puoi utilizzare le virgolette doppie per indicare che nelle intestazioni di colonna (per gli oggetti CSV) e negli attributi (per gli oggetti JSON) si applica la distinzione tra maiuscole e minuscole. In assenza delle virgolette doppie, le intestazioni e gli attributi degli oggetti non prevedono distinzione tra maiuscole e minuscole. In caso di ambiguità viene generato un errore. I seguenti esempi sono 1) oggetti Amazon S3 in formato CSV con le intestazioni di colonna specificate e con impostato su `"Use"` per la richiesta di query oppure 2) oggetti Amazon S3 in formato JSON con gli attributi specificati. *Esempio \$11:* l'oggetto su cui viene eseguita la query ha intestazione o attributo `NAME`. + La seguente espressione restituisce correttamente i valori dall'oggetto. Poiché non sono presenti virgolette, la query non fa distinzione tra maiuscole e minuscole. ``` SELECT s.name from S3Object s ``` + La seguente espressione genera un errore 400 `MissingHeaderName`. Poiché sono presenti le virgolette, la query fa distinzione tra maiuscole e minuscole. ``` SELECT s."name" from S3Object s ``` *Esempio 2:* l'oggetto Amazon S3 su cui viene eseguita la query ha un'intestazione o attributo con `NAME` e un'altra intestazione o attributo con `name`. + La seguente espressione genera un errore 400 `AmbiguousFieldName`. Poiché senza virgolette, senza distinzione tra maiuscole e minuscole, ma ci sono due corrispondenze, quindi viene generato un errore. ``` SELECT s.name from S3Object s ``` + La seguente espressione restituisce correttamente i valori dall'oggetto. Poiché sono presenti le virgolette, la query fa distinzione tra maiuscole e minuscole, quindi non vi è alcuna ambiguità. ``` SELECT s."NAME" from S3Object s ``` ## Utilizzo di parole chiave riservate come termini definiti dall'utente Amazon S3 Select dispone di un set di parole chiave riservate, necessarie per eseguire le espressioni SQL utilizzate per le query sul contenuto degli oggetti. Tali parole chiave riservate includono nomi di funzioni, tipi di dati, operatori e così via. In alcuni casi, i termini definiti dall'utente, ad esempio le intestazioni di colonna (per i file CSV) o gli attributi (per gli oggetti JSON) possono essere in conflitto con una parola chiave riservata. Quando ciò si verifica, devi utilizzare le virgolette doppie per indicare che stai intenzionalmente utilizzando un termine definito dall'utente in conflitto con una parola chiave riservata. In caso contrario, verrà generato un errore di analisi 400. Per l'elenco completo delle parole chiave riservate, consulta [Parole chiave riservate](s3-select-sql-reference-keyword-list.md). Il seguente esempio è 1) un oggetto Amazon S3 in formato CSV con le intestazioni di colonna specificate e con `FileHeaderInfo` impostato su `"Use"` per la richiesta di query oppure 2) un oggetto Amazon S3 in formato JSON con gli attributi specificati. *Esempio:* l'oggetto su cui viene eseguita la query ha un'intestazione o attributo denominato `CAST`, che è una parola chiave riservata. + La seguente espressione restituisce correttamente i valori dall'oggetto. Poiché nella query vengono utilizzate le virgolette, S3 Select utilizza l'intestazione o l'attributo definiti dall'utente. ``` SELECT s."CAST" from S3Object s ``` + La seguente espressione genera un errore 400 di analisi. Poiché nella query non vengono utilizzate virgolette, `CAST` entra in conflitto con una parola chiave riservata. ``` SELECT s.CAST from S3Object s ``` ## Espressioni scalari Nella clausola `WHERE` e nell'elenco `SELECT`, puoi avere *espressioni scalari* di SQL, ovvero espressioni che restituiscono valori scalari. Queste espressioni hanno la seguente forma: + ***`literal`*** Un valore letterale SQL. + ***`column_reference`*** Un riferimento a una colonna nel modulo `column_name` o`alias.column_name`. + **`unary_op`** **`expression`** In questo caso, ****`unary_op`**** è un operatore SQL unario. + **`expression`** **`binary_op`** ***`expression`*** In questo caso, ****`binary_op`**** è un operatore binario SQL. + **`func_name`** In questo caso, **`func_name`** è il nome della funzione scalare da richiamare. + ***`expression`*** `[ NOT ] BETWEEN` ****`expression`**** `AND` ****`expression`**** + ***`expression`*** `LIKE` ****`expression`**** [ `ESCAPE` ***`expression`*** ]