Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra. # Utiliser l'`opérateur` IN avec l'`instruction` SELECT dans une requête dans Amazon Keyspaces **SÉLECTIONNEZ DANS ** Vous pouvez interroger les données des tables à l'aide de l'`SELECT`instruction, qui lit une ou plusieurs colonnes pour une ou plusieurs lignes d'un tableau et renvoie un jeu de résultats contenant les lignes correspondant à la demande. Une `SELECT` instruction contient un `select_clause` qui détermine les colonnes à lire et à renvoyer dans le jeu de résultats. La clause peut contenir des instructions pour transformer les données avant de les renvoyer. La `WHERE` clause facultative spécifie quelles lignes doivent être interrogées et est composée de relations sur les colonnes qui font partie de la clé primaire. Amazon Keyspaces prend en charge le `IN` mot clé dans la `WHERE` clause. Cette section utilise des exemples pour montrer comment Amazon Keyspaces traite les `SELECT` instructions utilisant le `IN` mot clé. Cet exemple montre comment Amazon Keyspaces décompose l'`SELECT`instruction contenant le `IN` mot clé en * * sous-requêtes. Dans cet exemple, nous utilisons une table portant le nom`my_keyspace.customers`. La table comporte une colonne de clé primaire`department_id`, deux colonnes `sales_region_id` de clustering et une colonne contenant le nom du client dans la `customer_name` colonne. `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 ``` À l'aide de ce tableau, vous pouvez exécuter l'`SELECT`instruction suivante pour rechercher les clients des départements et des régions de vente qui vous intéressent en utilisant le `IN` mot clé de la `WHERE` clause. La déclaration suivante en est un exemple. ``` SELECT * FROM my_keyspace.customers WHERE department_id IN (0, 1) AND sales_region_id IN (0, 1); ``` Amazon Keyspaces divise cette instruction en quatre sous-requêtes, comme indiqué dans le résultat suivant. ``` 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 ``` Lorsque le `IN` mot clé est utilisé, Amazon Keyspaces pagine automatiquement les résultats dans les cas suivants : + Après le traitement d'une sous-requête sur 10. + Après avoir traité 1 Mo d'E/S logiques. + Si vous avez configuré un`PAGE SIZE`, Amazon Keyspaces pagine après avoir lu le nombre de requêtes à traiter en fonction de l'ensemble. `PAGE SIZE` + Lorsque vous utilisez le `LIMIT` mot clé pour réduire le nombre de lignes renvoyées, Amazon Keyspaces pagine après avoir lu le nombre de requêtes à traiter en fonction de l'ensemble. `LIMIT` Le tableau suivant est utilisé pour illustrer cela à l'aide d'un exemple. Pour plus d'informations sur la pagination, consultez[Paginer les résultats dans 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 ``` Vous pouvez exécuter l'instruction suivante sur ce tableau pour voir comment fonctionne la pagination. ``` 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 traite cette instruction comme 24 sous-requêtes, car la cardinalité du produit cartésien de tous les `IN` termes contenus dans cette requête est 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 ``` Cet exemple montre comment utiliser la `ORDER BY` clause dans une `SELECT` instruction avec le `IN` mot clé. ``` 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 ``` Les sous-requêtes sont traitées dans l'ordre dans lequel les colonnes de la clé de partition et de la clé de clustering sont présentées dans la requête. Dans l'exemple ci-dessous, les sous-requêtes pour la valeur de clé de partition « 2 » sont traitées en premier, suivies des sous-requêtes pour la valeur de clé de partition « 3 » et « 1 ». Les résultats d'une sous-requête donnée sont classés en fonction de la clause de classement de la requête, si elle est présente, ou de l'ordre de classification de la table défini lors de la création de la table. ``` 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 ```