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.

Astuce

Vous pouvez utiliser le service d’optimisation de recherche pour améliorer les performances des requêtes qui appellent cette fonction. Pour plus de détails, voir Service d’optimisation de la recherche.

Syntaxe

Pour comparer les valeurs individuelles :

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

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> ... ] )  ...  ]  )
Copy

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

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

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. Voir Utilisation de NULL.

  • Syntaxiquement, IN est traité comme un opérateur plutôt que comme une fonction. Cet exemple montre la différence entre l’utilisation de IN en tant qu’opérateur et l’appel de f() en tant que fonction :

    SELECT
    f(a, b),
    x IN (y, z) ...
    Copy

    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)) ...
    Copy

  • IN est également considéré comme un opérateur de sous-requête.

  • Dans une requête qui utilise IN, vous pouvez développer un tableau tableau en une liste de valeurs individuelles en utilisant l’opérateur d’étalement (**). Pour plus d’informations et d’exemples, voir Opérateurs d’expansion.

Détails du classement

Arguments with collation specifications currently aren’t supported.

Exemples

Les exemples suivants utilisent la fonction IN.

Utilisation de IN avec des littéraux simples

Les exemples suivants montrent comment utiliser IN et NOTIN avec des littéraux simples :

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

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

Utilisation de IN avec une sous-requête

Cet exemple montre comment utiliser IN dans une sous-requête.

SELECT 'a' IN (
  SELECT column1 FROM VALUES ('b'), ('c'), ('d')
  ) AS RESULT;
Copy
+--------+
| 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 OR REPLACE TABLE in_function_demo (
  col_1 INTEGER,
  col_2 INTEGER,
  col_3 INTEGER);

INSERT INTO in_function_demo (col_1, col_2, col_3) VALUES
  (1, 1, 1),
  (1, 2, 3),
  (4, 5, NULL);
Copy

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

SELECT col_1, col_2, col_3
  FROM in_function_demo
  WHERE (col_1) IN (1, 10, 100, 1000)
  ORDER BY col_1, col_2, col_3;
Copy
+-------+-------+-------+
| 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 in_function_demo
  WHERE (col_1, col_2, col_3) IN (
    (1,2,3),
    (4,5,6));
Copy
+-------+-------+-------+
| 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 in_function_demo
  ) AS RESULT;
Copy
+--------+
| RESULT |
|--------|
| True   |
+--------+

Utilisation de NULL

Rappelez-vous que NULL != NULL. Les listes IN et NOT IN contenant des comparaisons avec NULL (y compris les conditions d’égalité) peuvent produire des résultats inattendus car NULL représente une valeur inconnue. Les comparaisons avec NULL ne renvoient pas TRUE ou FALSE ; elles renvoient NULL. Voir aussi Logique ternaire.

Par exemple, la requête suivante renvoie NULL, et non TRUE, car SQL ne peut pas déterminer si NULL est égal à toute valeur, y compris un autre NULL.

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

Notez que si vous modifiez la requête pour sélectionner 1, et non NULL, elle renvoie TRUE :

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

Dans ce cas, le résultat est TRUE car 1 a une correspondance dans la liste IN. Le fait que NULL existe également dans la liste IN n’affecte pas le résultat.

De même, les comparaisons NOT IN avec NULL renvoient aussi NULL si une valeur de la liste est NULL.

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

Le même comportement est « true » pour la requête suivante, où l’ensemble des valeurs 4, 5, NULL ne correspond pas à 4, 5, NULL ni à 7, 8, 9 :

SELECT (4, 5, NULL) IN ( (4, 5, NULL), (7, 8, 9) ) AS RESULT;
Copy

L’exemple suivant montre le même comportement avec les comparaisons NULL, mais utilise une sous-requête pour définir les valeurs de liste IN qui sont comparées :

CREATE OR REPLACE TABLE in_list_table (
  val1 INTEGER,
  val2 INTEGER,
  val3 INTEGER
);

INSERT INTO in_list_table VALUES (1, 10, NULL), (2, 20, NULL), (NULL, NULL, NULL);

SELECT 1 IN (SELECT val1 FROM in_list_table) AS RESULT;
Copy
+--------+
| RESULT |
|--------|
| True   |
+--------+

SELECT NULL IN (SELECT val1 FROM in_list_table) AS RESULT;
Copy
+--------+
| RESULT |
|--------|
| NULL   |
+--------+

SELECT 3 IN (SELECT val1 FROM in_list_table) AS RESULT;
Copy
+--------+
| RESULT |
|--------|
| NULL   |
+--------+
Langage: Français