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'`operatore` IN con l'`istruzione` SELECT in una query in Amazon Keyspaces **SELEZIONA IN ** È possibile interrogare i dati delle tabelle utilizzando l'`SELECT`istruzione, che legge una o più colonne per una o più righe di una tabella e restituisce un set di risultati contenente le righe corrispondenti alla richiesta. Un'`SELECT`istruzione contiene una `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 opzionale 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 parola chiave. `IN` Questi esempi dimostrano come Amazon Keyspaces suddivide l'`SELECT`istruzione con la `IN` 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 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, puoi eseguire la seguente `SELECT` dichiarazione per trovare i clienti nei reparti e nelle aree di vendita che ti interessano con la `IN` parola chiave 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 mostrato 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 un`PAGE SIZE`, Amazon Keyspaces si impagina dopo aver letto il numero di query da elaborare in base al set. `PAGE SIZE` + Quando utilizzi la `LIMIT` parola chiave per ridurre il numero di righe restituite, Amazon Keyspaces si impagina dopo aver letto il numero di query da elaborare in base al set. `LIMIT` La tabella seguente viene utilizzata per illustrare ciò con un esempio. Per ulteriori informazioni sull'impaginazione, vedere. [Impagina 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 su 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 ```