Filtrage des données avec IN et NOT IN

Imagine que tu bosses sur la base de données d’une université et que tu dois trouver les étudiants inscrits à certains cours précis. Par exemple, "Programmation", "Mathématiques" et "Physique". Bien sûr, tu pourrais écrire une requête longue avec plein de conditions du genre :

SELECT *
FROM students 
WHERE course = 'Programmation'
   OR course = 'Mathématiques'
   OR course = 'Physique';

Mais soyons honnêtes. Écrire ce genre de trucs, c’est relou et franchement pas très élégant. Heureusement, l’opérateur IN est là pour te simplifier la vie et rendre la requête bien plus compacte :

SELECT *
FROM students 
WHERE course IN ('Programmation', 'Mathématiques', 'Physique');

Ça fait un peu magie, non ? Au lieu de plein de OR, on dit juste à SQL de chercher les valeurs dans cette liste. Et si tu veux vérifier qu’une valeur n’est pas dans la liste, tu utilises NOT IN — trouve tout ce qui n’est pas dans cette liste.

Syntaxe de l’opérateur IN

Voilà la syntaxe générale de IN :

SELECT colonnes
FROM table
WHERE colonne IN (valeur1, valeur2, valeur3, ...);

Maintenant, voyons quelques exemples.

Exemple 1 : Étudiants qui suivent plusieurs cours

Disons qu’on a une table students :

On veut trouver tous les étudiants qui suivent "Programmation", "Mathématiques" ou "Physique". On utilise IN :

SELECT name, course
FROM students
WHERE course IN ('Programmation', 'Mathématiques', 'Physique');

Résultat :

Comme tu vois, l’opérateur IN a bien simplifié la tâche. Pas besoin d’écrire une longue liste de OR, tu mets juste les valeurs qui t’intéressent dans la liste.

Exemple 2 : Étudiants qui ne suivent pas certains cours

Maintenant, imaginons que tu veux trouver les étudiants qui ne suivent pas "Programmation", "Mathématiques" et "Physique". Là, NOT IN est parfait :

SELECT name, course
FROM students
WHERE course NOT IN ('Programmation', 'Mathématiques', 'Physique');

Résultat :

Donc, NOT IN te renvoie toutes les lignes où la colonne course n’est pas dans la liste donnée.

Utiliser IN et NOT IN avec des sous-requêtes

Les opérateurs IN et NOT IN sont super utiles quand tu veux comparer des données entre deux tables. Par exemple, imaginons qu’on a deux tables :

Table students :

Table courses :

Imaginons qu’on veut trouver les étudiants inscrits à des cours qui existent dans la table courses. Là, une sous-requête avec IN est nickel :

SELECT name
FROM students
WHERE course_id IN (
    SELECT id
    FROM courses
);

Cette requête marche comme ça : la sous-requête SELECT id FROM courses renvoie la liste de tous les ids de cours. Ensuite, IN vérifie si course_id est dans cette liste.

Résultat :

Pourquoi Dan n’apparaît pas ? Parce que son course_id (104) n’existe pas dans la table courses.

Particularités avec NULL

L’opérateur IN a une particularité importante : si la liste de valeurs contient NULL, ça peut influencer le résultat de la requête. Voyons un exemple.

Table grades :

Une requête qui cherche les étudiants avec une note dans ('A', 'B', 'C') pourrait ressembler à ça :

SELECT student_id
FROM grades
WHERE grade IN ('A', 'B', 'C');

Résultat :

La ligne avec NULL dans la colonne grade est ignorée, parce que NULL n’est jamais considéré comme faisant partie d’une liste.

Maintenant, imagine que tu utilises NOT IN. Par exemple :

SELECT student_id
FROM grades
WHERE grade NOT IN ('A', 'B', 'C');

Tu t’attends à voir la ligne avec student_id = 2, mais le résultat sera vide ! Pourquoi ? Parce que NULL comparé à chaque valeur de la liste donne toujours un résultat indéfini (UNKNOWN). Ce comportement peut surprendre, donc quand tu utilises NOT IN, fais gaffe aux colonnes qui peuvent contenir NULL. Le mieux, c’est de vérifier explicitement NULL :

SELECT student_id
FROM grades
WHERE grade NOT IN ('A', 'B', 'C')
   OR grade IS NULL;

Résultat :

Conseils pour utiliser IN et NOT IN

Utilise IN pour rendre ton code SQL plus lisible
Si tu dois vérifier si une colonne est dans une liste de valeurs, préfère toujours IN à une ribambelle de OR.

Fais attention à NOT IN et NULL
Si tes données peuvent contenir des NULL, ça peut donner des résultats bizarres. Pense à gérer NULL explicitement avec NOT IN.

Utilise des index pour accélérer les sous-requêtes
Si tu utilises IN avec une sous-requête, assure-toi que la colonne dans la sous-requête est indexée, sinon tu risques d’avoir des soucis de perf.

Exemple d’un cas réel

Imagine que tu bosses sur un site e-commerce. Tu as les tables orders et users. Tu veux trouver tous les utilisateurs qui n’ont jamais passé de commande.

Table users :

Table orders :

On utilise NOT IN pour résoudre ce problème :

SELECT name
FROM users
WHERE id NOT IN (
    SELECT user_id
    FROM orders
);

Résultat :

Cette requête fonctionne comme ça : d’abord la sous-requête SELECT user_id FROM orders renvoie les ids de tous les utilisateurs qui ont passé une commande (1 et 3). Ensuite, NOT IN les exclut, et il ne reste que ceux qui n’ont jamais commandé (Mello et Dan).