SQLite : l'expression CASE WHEN, THEN, ELSE et IIF

CASE, c'est le If/Else du SQL

L'expression CASE en SQLite, c'est ce qui permet de glisser de la logique conditionnelle directement dans une requête. SQLite parcourt les branches WHEN dans l'ordre, retient la première qui correspond et renvoie la valeur indiquée après THEN. Si aucune branche ne matche, c'est la valeur du ELSE qui est renvoyée — ou NULL si vous n'en avez pas mis.

Le mot-clé à retenir ici, c'est expression. Un CASE produit une valeur, donc vous pouvez le placer partout où une valeur est acceptée : une colonne du SELECT, une clé de tri dans ORDER BY, le membre droit d'une comparaison, ou même un argument passé à une fonction.

SELECT
    'pomme' AS item,
    CASE
        WHEN 5 > 3 THEN 'oui'
        ELSE 'non'
    END AS bigger;

Voilà la structure complète : CASE, un ou plusieurs WHEN ... THEN ..., un ELSE optionnel, puis END. Le END est obligatoire — l'oublier est l'erreur de frappe la plus fréquente.

Un exemple concret avec CASE WHEN

Imaginons une table de commandes et on veut étiqueter chaque ligne selon son montant. On va en créer une petite directement pour pouvoir lancer la requête :

WITH orders(id, total) AS (
    VALUES
        (1, 12.00),
        (2, 89.50),
        (3, 250.00),
        (4, 5.25),
        (5, 1200.00)
)
SELECT
    id,
    total,
    CASE
        WHEN total < 10 THEN 'minuscule'
        WHEN total < 100 THEN 'petite'
        WHEN total < 500 THEN 'moyenne'
        ELSE 'grande'
    END AS size_bucket
FROM orders;

Les branches sont évaluées de haut en bas. La première qui matche l'emporte, donc range-les de la plus spécifique à la plus générale. Le ELSE rattrape tout ce qui n'a pas été pris en compte — sans lui, 1200.00 ressortirait à NULL au lieu de 'grande'.

CASE recherché ou CASE simple

Ce que vous venez de voir, c'est la forme recherchée : chaque WHEN embarque sa propre condition booléenne. Il existe une forme plus courte quand vous comparez une seule expression à plusieurs constantes — la forme simple :

WITH users(id, status) AS (
    VALUES
        (1, 'A'),
        (2, 'B'),
        (3, 'C'),
        (4, 'A')
)
SELECT
    id,
    status,
    CASE status
        WHEN 'A' THEN 'actif'
        WHEN 'B' THEN 'banni'
        WHEN 'C' THEN 'fermé'
        ELSE 'inconnu'
    END AS status_label
FROM users;

L'expression placée après CASE est évaluée une seule fois, puis comparée avec = à chaque valeur des WHEN. C'est plus lisible quand on fait des comparaisons d'égalité sur une seule colonne.

Petit piège à connaître : la forme simple de CASE utilise =, or en SQL, NULL = NULL n'est pas vrai. Si status peut valoir NULL, les branches 'A'/'B'/'C' ne correspondront jamais — on tombera systématiquement dans le ELSE. Pour gérer le NULL explicitement, il faut basculer sur la forme « searched » avec WHEN status IS NULL THEN ....

SQLite CASE dans ORDER BY

ORDER BY accepte n'importe quelle expression, donc CASE y fonctionne sans souci. C'est pratique quand on veut un ordre de tri personnalisé qui ne suit ni l'ordre alphabétique ni l'ordre numérique :

WITH tickets(id, priority) AS (
    VALUES
        (1, 'low'),
        (2, 'high'),
        (3, 'medium'),
        (4, 'high'),
        (5, 'low')
)
SELECT id, priority
FROM tickets
ORDER BY
    CASE priority
        WHEN 'high' THEN 1
        WHEN 'medium' THEN 2
        WHEN 'low' THEN 3
    END,
    id;

'high' < 'low' < 'medium' dans l'ordre alphabétique, ce qui ne vaut rien pour du tri par priorité. En associant chaque priorité à un nombre via CASE, vous obtenez enfin l'ordre qui a du sens. Le , id à la fin sert à départager les ex æquo de façon stable.

CASE dans une clause WHERE

Vous pouvez glisser un CASE à l'intérieur d'un WHERE, mais la plupart du temps ça ne sert à rien — un enchaînement de AND/OR reste bien plus lisible. Là où CASE devient vraiment utile, c'est quand la condition elle-même dépend d'une autre valeur :

WITH products(id, name, price, on_sale) AS (
    VALUES
        (1, 'tasse', 12.00, 1),
        (2, 'chemise', 25.00, 0),
        (3, 'casquette', 18.00, 1),
        (4, 'sac', 45.00, 0)
)
SELECT id, name, price
FROM products
WHERE price < CASE WHEN on_sale = 1 THEN 20 ELSE 30 END;

Les articles en solde passent sous 20, les articles classiques sous 30. Le seuil lui-même dépend d'une condition. Sans CASE, il faudrait écrire (on_sale = 1 AND price < 20) OR (on_sale = 0 AND price < 30) — même résultat, mais beaucoup plus verbeux.

CASE à l'intérieur des fonctions d'agrégation

C'est là que CASE prend toute sa valeur. Couplé à SUM ou COUNT, il permet de calculer des totaux sur un sous-ensemble de lignes en un seul passage — l'équivalent SQL de « compte-moi celles qui correspondent » :

WITH orders(id, total, status) AS (
    VALUES
        (1, 50.00, 'paid'),
        (2, 30.00, 'pending'),
        (3, 75.00, 'paid'),
        (4, 20.00, 'cancelled'),
        (5, 100.00, 'paid')
)
SELECT
    COUNT(*) AS all_orders,
    SUM(CASE WHEN status = 'paid' THEN 1 ELSE 0 END) AS paid_count,
    SUM(CASE WHEN status = 'paid' THEN total ELSE 0 END) AS paid_revenue
FROM orders;

Le CASE renvoie 1 pour les lignes qui correspondent et 0 pour les autres : SUM se transforme alors en comptage conditionnel. La même astuce marche pour le chiffre d'affaires — on renvoie total sur les lignes qui matchent et 0 partout ailleurs. Un seul parcours de la table, plusieurs agrégats conditionnels d'un coup.

IIF : le raccourci à deux branches

Quand on n'a qu'une condition avec deux issues possibles, SQLite propose IIF(cond, when_true, when_false). C'est juste un raccourci pour CASE WHEN cond THEN when_true ELSE when_false END :

WITH accounts(id, balance) AS (
    VALUES
        (1, 100.00),
        (2, -25.00),
        (3, 0.00),
        (4, 1500.00)
)
SELECT
    id,
    balance,
    IIF(balance < 0, 'à découvert', 'ok') AS state
FROM accounts;

Utilisez IIF quand la logique est binaire et tient mieux sur une seule ligne. Passez à CASE dès que vous avez trois branches ou plus, qu'il faut gérer NULL à part, ou que vous voulez profiter de l'ordre d'évaluation successif des clauses WHEN.

Les pièges classiques à connaître

Voici quelques points qui font souvent trébucher :

• Oublier END. CASE ouvre un bloc ; END le referme. SQLite vous remontera une erreur de parsing, mais bien après l'endroit où se trouve réellement la coquille.
• Sans ELSE, on obtient NULL. Si aucune branche WHEN ne correspond et que vous n'avez pas mis de ELSE, le résultat vaut NULL. Parfois c'est voulu ; le plus souvent, non.
• L'ordre des branches compte. Dans la forme cherchée, c'est le premier WHEN qui correspond qui l'emporte. Placer WHEN total < 500 avant WHEN total < 100 rend la seconde branche inatteignable.
• Mélange de types. Chaque branche peut renvoyer un type différent, et SQLite ne dira rien — mais le code en aval, lui, risque de râler. Essayez de garder des types compatibles dans toutes les branches (tout en texte, ou tout en numérique).
• CASE simple et NULL. Comme évoqué : la forme simple utilise =, qui ne matche jamais NULL. Dès que des valeurs nulles entrent en jeu, utilisez la forme cherchée.

La suite : les fonctions de chaînes

CASE permet de brancher selon une valeur ; le chapitre suivant attaque la transformation des valeurs. Les fonctions de chaînes — UPPER, LOWER, SUBSTR, REPLACE, motifs LIKE — couvrent le quotidien : nettoyer et reformater les colonnes texte. C'est ce qui nous attend.