WHERE en profondeur ② — BETWEEN et LIKE pour le filtrage par plage et par motif

Les données qu'on va utiliser — la table staff

Le 2e des 4 articles approfondis sur WHERE couvre le filtrage par plage (BETWEEN) et le pattern matching (LIKE). Quand tu combines les conditions composées construites avec AND / OR / NOT vues précédemment et le BETWEEN / LIKE de cet article, tu peux exprimer dans un seul WHERE à peu près n'importe quelle exigence de filtrage du quotidien.

Avant les exercices, confirme les définitions de colonnes et un échantillon des données de la table staff.

① Lance PRAGMA table_info(staff); pour vérifier les noms de colonnes, types et clés primaires.

② Lance SELECT * FROM staff LIMIT 5; pour prévisualiser les 5 premières lignes.

BETWEEN — filtrer par plage de valeurs

Quand tu veux tester si une valeur tombe dans une plage — « salaire entre 5 000 000 et 6 000 000 », « anniversaire entre avril 2020 et mars 2025 » — BETWEEN est l'opérateur.

Écrire colonne BETWEEN valeur1 AND valeur2 renvoie les lignes où la colonne vaut au moins valeur1 et au plus valeur2. Note que les deux bornes sont incluses. Ça veut dire la même chose que colonne >= valeur1 AND colonne <= valeur2 ; on choisit souvent BETWEEN juste pour la lisibilité.

Ajouter NOT BETWEEN renvoie les lignes hors de la plage (inférieures à valeur1 ou supérieures à valeur2).

-- Staff dont le salary est entre 5 000 000 et 6 000 000 (bornes incluses)
SELECT name, salary FROM staff
WHERE salary BETWEEN 5000000 AND 6000000;

-- Même sens, écrit avec >= et <= reliés par AND
SELECT name, salary FROM staff
WHERE salary >= 5000000 AND salary <= 6000000;

-- Hors de la plage (sous 5 000 000 OU au-dessus de 6 000 000)
SELECT name, salary FROM staff
WHERE salary NOT BETWEEN 5000000 AND 6000000;

BETWEEN inclut les deux bornes

BETWEEN 5000000 AND 6000000 inclut exactement 5 000 000 et exactement 6 000 000. Si tu veux exclure les bornes, écris > 5000000 AND < 6000000.

Avec les dates, tu peux écrire BETWEEN '2020-04-01' AND '2025-03-31' — les littéraux sont comparés comme des chaînes. Pour inclure « tout mars 2025 », définir les deux bornes avec la vraie date de fin de mois est l'approche sûre. BETWEEN '2020-04-01' AND '2025-04-01' inclurait aussi `2025-04-01` lui-même, ce qui n'est généralement pas ce que tu veux.

Imagine qu'une réunion de direction a besoin du compte des « salariés intermédiaires (salary 5 000 000 – 6 000 000) ». (Une fois exécuté correctement, l'explication apparaîtra.)

① Depuis staff, extrais les colonnes name et salary.

② Filtre les lignes où `salary` est au moins 5 000 000 et au plus 6 000 000 (bornes incluses).

③ Confirme que le résultat fait 3 lignes (Bob 5 200 000 / Grace 5 500 000 / Jack 5 900 000).

Imagine une demande de « voir le staff hors de la tranche intermédiaire (4 500 000 – 6 000 000), trié par salary le plus haut en premier ».

① Depuis staff, extrais les colonnes name et salary.

② Filtre les lignes où `salary` est hors de la plage 4 500 000 – 6 000 000 (c'est-à-dire sous 4 500 000 ou au-dessus de 6 000 000).

③ Trie par `salary` descendant.

④ Confirme que le résultat fait 6 lignes, commençant par Frank 7 200 000 et finissant par Emi 3 800 000.

LIKE — filtrer par pattern matching

Quand tu veux filtrer par un motif de chaîne — « noms se terminant par Tanaka », « emails contenant @example.com » — LIKE est l'opérateur. Écris colonne LIKE 'motif'. Dans le motif tu peux utiliser les deux wildcards suivants.

'A%' veut dire commence par A, '%a' veut dire se termine par a, '%a%' veut dire contient a, 'A___%' veut dire commence par A et a au moins trois caractères de plus — combine-les selon les besoins. Ajouter NOT LIKE renvoie les lignes qui ne correspondent pas au motif.

-- 1) Correspondance préfixe : name commence par A
SELECT name FROM staff WHERE name LIKE 'A%';

-- 2) Correspondance suffixe : nom de famille Tanaka
SELECT name FROM staff WHERE name LIKE '%Tanaka';

-- 3) Contient : name contient 'a' n'importe où
SELECT name FROM staff WHERE name LIKE '%a%';

-- 4) Caractère unique : 2e caractère est 'a', le reste est n'importe quoi
SELECT name FROM staff WHERE name LIKE '_a%';

-- 5) Négation : ne se termine pas par Tanaka
SELECT name FROM staff WHERE name NOT LIKE '%Tanaka';

LIKE et `=` suivent des règles de sensibilité à la casse différentes

Dans la console de ce cours (SQLite), au sein de l'ASCII, LIKE est insensible à la casse. name LIKE '%a%' et name LIKE '%A%' renvoient les mêmes lignes. Pour le rendre sensible à la casse, lance PRAGMA case_sensitive_like = 1; ou normalise les deux côtés avec LOWER(...).

En parallèle, la comparaison de chaînes avec `=` (couverte dans l'article SELECT) est sensible à la casse — fais attention à la différence de comportement entre = et LIKE.

Chercher un `%` ou `_` littéral — la clause `ESCAPE`

Si la chaîne que tu cherches contient réellement un littéral % ou _ (disons un code produit comme 'A_001'), alors par défaut le _ sera interprété comme un wildcard. La clause ESCAPE te permet de spécifier un caractère d'échappement, après lequel % / _ sont traités comme des caractères littéraux.

Exemple : WHERE code LIKE 'A\_001' ESCAPE '\'; (déclare \ comme caractère d'échappement, donc \_ est traité comme un underscore littéral). Le caractère d'échappement n'a pas à être \ — ESCAPE '#' fait de # l'échappement, ESCAPE '!' en fait !, etc. Tu sortiras ça quand tu cherches dans des colonnes de codes qui contiennent _ ou %.

Lance les trois motifs — préfixe, suffixe, contient via _ — dans une seule console et compare les résultats.

① Pour chaque requête, extrais name, city et salary de staff.

② Extrais les lignes où `name` commence par `A` (correspondance préfixe 'A%').

③ Puis extrais les lignes où `name` se termine par `Tanaka` (correspondance suffixe '%Tanaka').

④ Puis extrais les lignes où le 2e caractère de `name` est `a` ('_a%', où _ est n'importe quel caractère unique).

⑤ Confirme que les comptes de lignes sont 1 / 4 / 3.

Combiner WHERE, ORDER BY et LIMIT

Les requêtes du monde réel combinent généralement filtrage (WHERE) → tri (ORDER BY) → limite de lignes (LIMIT) dans cet ordre exact. L'ordre des clauses est fixe, et les permuter est une erreur de syntaxe.

L'ordre d'exécution de la base est en gros FROM → WHERE → SELECT → ORDER BY → LIMIT — d'abord restreindre les lignes, choisir les colonnes nécessaires, les trier, puis découper le compte voulu.

Imagine un dashboard montrant un classement des salaires pour « le staff avec a dans son name ».

① Depuis staff, extrais les colonnes name et salary.

② Filtre les lignes où `name` contient `a` (correspondance contient).

③ Trie par `salary` descendant, et prends seulement les 3 premières lignes.

④ Confirme que le résultat fait 3 lignes : Frank Tanaka 7 200 000 / David Sato 6 800 000 / Henry Sato 6 100 000.