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à. # Usa l'`IN`operatore con l'`SELECT`istruzione in una query in Amazon Keyspaces **SELEZIONA IN** È possibile interrogare i dati dalle tabelle utilizzando l'`SELECT`istruzione, che legge una o più colonne per una o più righe in una tabella e restituisce un set di risultati contenente le righe corrispondenti alla richiesta. Un'`SELECT`istruzione contiene un'istruzione `select_clause` che determina quali colonne leggere e restituire nel set di risultati. La clausola può contenere istruzioni per trasformare i dati prima di restituirli. La `WHERE` clausola facoltativa specifica quali righe devono essere interrogate ed è composta da relazioni sulle colonne che fanno parte della chiave primaria. Amazon Keyspaces supporta la `IN` parola chiave nella clausola. `WHERE` Questa sezione utilizza esempi per mostrare come Amazon Keyspaces elabora `SELECT` le istruzioni con la `IN` parola chiave. *Questo esempio dimostra come Amazon Keyspaces suddivide `SELECT` l'istruzione con `IN` la parola chiave in sottoquery.* In questo esempio utilizziamo una tabella con il nome. `my_keyspace.customers` La tabella ha una colonna chiave primaria`department_id`, due colonne `sales_region_id` di clustering e e una colonna che contiene il nome del cliente nella `customer_name` colonna. `sales_representative_id` ``` SELECT * FROM my_keyspace.customers; department_id | sales_region_id | sales_representative_id | customer_name ---------------+-----------------+-------------------------+-------------- 0 | 0 | 0 | a 0 | 0 | 1 | b 0 | 1 | 0 | c 0 | 1 | 1 | d 1 | 0 | 0 | e 1 | 0 | 1 | f 1 | 1 | 0 | g 1 | 1 | 1 | h ``` Utilizzando questa tabella, è possibile eseguire la seguente `SELECT` istruzione per trovare i clienti nei reparti e nelle aree di vendita a cui si è interessati con la `IN` parola chiave contenuta nella `WHERE` clausola. La seguente dichiarazione ne è un esempio. ``` SELECT * FROM my_keyspace.customers WHERE department_id IN (0, 1) AND sales_region_id IN (0, 1); ``` Amazon Keyspaces divide questa dichiarazione in quattro sottoquery, come illustrato nell'output seguente. ``` SELECT * FROM my_keyspace.customers WHERE department_id = 0 AND sales_region_id = 0; department_id | sales_region_id | sales_representative_id | customer_name ---------------+-----------------+-------------------------+-------------- 0 | 0 | 0 | a 0 | 0 | 1 | b SELECT * FROM my_keyspace.customers WHERE department_id = 0 AND sales_region_id = 1; department_id | sales_region_id | sales_representative_id | customer_name ---------------+-----------------+-------------------------+-------------- 0 | 1 | 0 | c 0 | 1 | 1 | d SELECT * FROM my_keyspace.customers WHERE department_id = 1 AND sales_region_id = 0; department_id | sales_region_id | sales_representative_id | customer_name ---------------+-----------------+-------------------------+-------------- 1 | 0 | 0 | e 1 | 0 | 1 | f SELECT * FROM my_keyspace.customers WHERE department_id = 1 AND sales_region_id = 1; department_id | sales_region_id | sales_representative_id | customer_name ---------------+-----------------+-------------------------+-------------- 1 | 1 | 0 | g 1 | 1 | 1 | h ``` Quando viene utilizzata la `IN` parola chiave, Amazon Keyspaces impagina automaticamente i risultati in uno dei seguenti casi: + Dopo l'elaborazione di ogni decima sottoquery. + Dopo aver elaborato 1 MB di IO logico. + Se hai configurato a`PAGE SIZE`, Amazon Keyspaces impagina dopo aver letto il numero di query da elaborare in base al set. `PAGE SIZE` + Quando usi la `LIMIT` parola chiave per ridurre il numero di righe restituite, Amazon Keyspaces impagina dopo aver letto il numero di query da elaborare in base al set. `LIMIT` La tabella seguente viene utilizzata per illustrare questo aspetto con un esempio. Per ulteriori informazioni sull'impaginazione, vedere. [Impaginare i risultati in Amazon Keyspaces](paginating-results.md) ``` SELECT * FROM my_keyspace.customers; department_id | sales_region_id | sales_representative_id | customer_name ---------------+-----------------+-------------------------+-------------- 2 | 0 | 0 | g 2 | 1 | 1 | h 2 | 2 | 2 | i 0 | 0 | 0 | a 0 | 1 | 1 | b 0 | 2 | 2 | c 1 | 0 | 0 | d 1 | 1 | 1 | e 1 | 2 | 2 | f 3 | 0 | 0 | j 3 | 1 | 1 | k 3 | 2 | 2 | l ``` È possibile eseguire la seguente istruzione in questa tabella per vedere come funziona l'impaginazione. ``` SELECT * FROM my_keyspace.customers WHERE department_id IN (0, 1, 2, 3) AND sales_region_id IN (0, 1, 2) AND sales_representative_id IN (0, 1); ``` Amazon Keyspaces elabora questa dichiarazione come 24 sottoquery, poiché la cardinalità del prodotto cartesiano di tutti i `IN` termini contenuti in questa query è 24. ``` department_id | sales_region_id | sales_representative_id | customer_name ---------------+-----------------+-------------------------+-------------- 0 | 0 | 0 | a 0 | 1 | 1 | b 1 | 0 | 0 | d 1 | 1 | 1 | e ---MORE--- department_id | sales_region_id | sales_representative_id | customer_name ---------------+-----------------+-------------------------+-------------- 2 | 0 | 0 | g 2 | 1 | 1 | h 3 | 0 | 0 | j ---MORE--- department_id | sales_region_id | sales_representative_id | customer_name ---------------+-----------------+-------------------------+-------------- 3 | 1 | 1 | k ``` Questo esempio mostra come utilizzare la `ORDER BY` clausola in un'istruzione con la parola chiave. `SELECT` `IN` ``` SELECT * FROM my_keyspace.customers WHERE department_id IN (3, 2, 1) ORDER BY sales_region_id DESC; department_id | sales_region_id | sales_representative_id | customer_name ---------------+-----------------+-------------------------+-------------- 3 | 2 | 2 | l 3 | 1 | 1 | k 3 | 0 | 0 | j 2 | 2 | 2 | i 2 | 1 | 1 | h 2 | 0 | 0 | g 1 | 2 | 2 | f 1 | 1 | 1 | e 1 | 0 | 0 | d ``` Le sottoquery vengono elaborate nell'ordine in cui le colonne della chiave di partizione e della chiave di clustering vengono presentate nella query. Nell'esempio seguente, le sottoquery per il valore della chiave di partizione» 2 «vengono elaborate per prime, seguite dalle sottoquery per il valore della chiave di partizione» 3 «e» 1». I risultati di una determinata sottoquery vengono ordinati in base alla clausola di ordinamento della query, se presente, o all'ordine di clustering della tabella definito durante la creazione della tabella. ``` SELECT * FROM my_keyspace.customers WHERE department_id IN (2, 3, 1) ORDER BY sales_region_id DESC; department_id | sales_region_id | sales_representative_id | customer_name ---------------+-----------------+-------------------------+-------------- 2 | 2 | 2 | i 2 | 1 | 1 | h 2 | 0 | 0 | g 3 | 2 | 2 | l 3 | 1 | 1 | k 3 | 0 | 0 | j 1 | 2 | 2 | f 1 | 1 | 1 | e 1 | 0 | 0 | d ```