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
SELECTDANS
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 nommy_keyspace.customers
. La table comporte une colonne de clé primairedepartment_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, consultezPaginer les résultats dans Amazon Keyspaces.
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, si elle est présente, 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