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'`IN`opérateur avec l'`SELECT`instruction 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'une table 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 les lignes qui 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 contenant 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 trouver les clients des départements et des régions de vente qui vous intéressent avec le `IN` mot clé dans 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 chaque dixième sous-requête traitée. + 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 sous la forme de 24 sous-requêtes, car la cardinalité du produit cartésien de tous les `IN` termes contenus dans cette requête est de 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 contenant 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 clé de partition et de 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 les valeurs 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 d'ordre de la requête, le cas échéant, ou de l'ordre de regroupement 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 ```