Catégories :: Fonctions d’expressions conditionnelles

[ NOT ] IN¶

Teste si son argument est ou n’est pas l’un des membres d’une liste explicite ou le résultat d’une sous-requête.

Note

Sous la forme de sous-requête, IN est équivalent à = ANY et NOT IN est équivalent à <> ALL.

Syntaxe¶

Pour comparer les valeurs individuelles :

<value> [ NOT ] IN ( <value_1> [ , <value_2> ...  ] )

Pour comparer les constructeurs de lignes (listes de valeurs entre parenthèses) :

( <value_A> [, <value_B> ... ] ) [ NOT ] IN (  ( <value_1> [ , <value_2> ... ] )  [ , ( <value_3> [ , <value_4> ... ] )  ...  ]  )

Pour comparer une valeur aux valeurs renvoyées par une sous-requête :

<value> [ NOT ] IN ( <subquery> )

Paramètres¶

value

La valeur à rechercher.

value_A, value_B

Les éléments d’un constructeur de ligne à rechercher.

Assurez-vous que chaque valeur à droite de IN (par exemple, (value3, value4)) a le même nombre d’éléments que la valeur à gauche de IN (par exemple, (value_A, value_B)).

value_#

Une valeur à laquelle value doit être comparée.

Si les valeurs à comparer sont des constructeurs de ligne, alors chaque value_# est un élément individuel d’un constructeur de ligne.

subquery

Une sous-requête qui renvoie une liste de valeurs auxquelles value peut être comparée.

Notes sur l’utilisation¶

Comme dans la plupart des contextes, NULL n’est pas égal à NULL. Si value est NULL, la valeur renvoyée par la fonction est NULL, que la liste ou la sous-requête contienne ou non NULL.

Par exemple, ceci renvoie NULL, et non TRUE :
SELECT NULL IN (1, 2, NULL) AS RESULT;
Syntaxiquement, IN est traité comme un opérateur plutôt que comme une fonction. L’exemple ci-dessous montre la différence entre l’utilisation de IN comme opérateur et l’appel de f() comme fonction :
```
SELECT
    f(a, b),
    x IN (y, z) ...
```
Vous ne pouvez pas utiliser la syntaxe de fonction avec IN. Par exemple, vous ne pouvez pas réécrire l’exemple précédent comme ceci :
```
SELECT
    f(a, b),
    IN(x, (y, z)) ...
```
IN est également considéré comme un opérateur de sous-requête.

Détails du classement¶

Arguments with collation specifications are currently not supported.

Exemples¶

Utilisation de `IN` avec des littéraux simples¶

Ces exemples montrent comment utiliser IN et NOT IN avec des littéraux simples :

SELECT 1 IN (1, 2, 3) AS RESULT;
+--------+
| RESULT |
|--------|
| True   |
+--------+

SELECT 4 NOT IN (1, 2, 3) AS RESULT;
+--------+
| RESULT |
|--------|
| True   |
+--------+

Utilisation de `IN` avec une sous-requête¶

SELECT 'a' IN (
    SELECT column1 FROM VALUES ('b'), ('c'), ('d')
    ) AS RESULT;
+--------+
| RESULT |
|--------|
| False  |
+--------+

Utilisation de `IN` avec une table¶

Ces exemples montrent comment utiliser IN avec une table : L’instruction ci-dessous crée la table utilisée dans les exemples.

CREATE TABLE my_table (col_1 INTEGER, col_2 INTEGER, col_3 INTEGER);
INSERT INTO my_table (col_1, col_2, col_3) VALUES
    (1, 1, 1),
    (1, 2, 3),
    (4, 5, NULL);

Cet exemple montre comment utiliser IN avec une colonne d’une table :

SELECT col_1, col_2, col_3
    FROM my_table
    WHERE (col_1) IN (1, 10, 100, 1000)
    ORDER BY col_1, col_2, col_3;
+-------+-------+-------+
| COL_1 | COL_2 | COL_3 |
|-------+-------+-------|
|     1 |     1 |     1 |
|     1 |     2 |     3 |
+-------+-------+-------+

Cet exemple montre comment utiliser IN avec plusieurs colonnes d’une table :

SELECT col_1, col_2, col_3
    FROM my_table
    WHERE (col_1, col_2, col_3) IN ( 
                                   (1,2,3), 
                                   (4,5,6)
                                   );
+-------+-------+-------+
| COL_1 | COL_2 | COL_3 |
|-------+-------+-------|
|     1 |     2 |     3 |
+-------+-------+-------+

Cet exemple montre comment utiliser IN avec une sous-requête qui lit plusieurs colonnes d’une table :

SELECT (1, 2, 3) IN (
    SELECT col_1, col_2, col_3 FROM my_table
    ) AS RESULT;
+--------+
| RESULT |
|--------|
| True   |
+--------+

Utilisation de NULL¶

Rappelez-vous que NULL! = NULL. Aucune des requêtes suivantes ne renvoie de correspondance lorsque la valeur à gauche ou à droite de IN contient un NULL :

SELECT NULL IN (1, 2, NULL) AS RESULT;
+--------+
| RESULT |
|--------|
| NULL   |
+--------+

SELECT (4, 5, NULL) IN ( (4, 5, NULL), (7, 8, 9) ) AS RESULT;
+--------+
| RESULT |
|--------|
| NULL   |
+--------+