La plupart des rapports nécessitent une certaine logique : étiquetez les commandes comme étant grandes ou petites, comptez côte à côte les commandes payées et en attente, ou affichez en premier les articles urgents. SQL CASE WHEN gère tout cela directement dans une requête et fonctionne sur toutes les principales bases de données.

Nous avons exécuté chaque requête ici dans SQLite 3.50, et les résultats affichés proviennent de cette exécution. CASE fait partie du SQL standard, il se comporte donc de la même manière dans PostgreSQL, MySQL, SQL Server et Oracle pour ces exemples.

Qu’est-ce que CAS QUAND ?

CASE est une expression, pas une commande distincte. Il évalue les conditions dans l’ordre et renvoie une valeur, de sorte qu’il peut aller partout où une valeur est autorisée : dans SELECT, WHERE, GROUP BY, ORDER BY ou à l’intérieur des fonctions. Il se termine toujours par END.

CASE
  WHEN condition1 THEN result1
  WHEN condition2 THEN result2
  ELSE fallback
END

Le tableau exemple

CREATE TABLE orders (id INT, customer TEXT, total INT, status TEXT);

INSERT INTO orders VALUES
 (1,'Asha',1200,'paid'), (2,'Ben',300,'pending'),
 (3,'Asha',800,'paid'), (4,'Chitra',2500,'shipped'),
 (5,'Dev',150,'cancelled'), (6,'Ben',NULL,'pending');

Notez que l’ordre 6 n’a pas de total. Cette ligne compte plus tard.

CAS recherché

Il s’agit de la forme la plus flexible, puisque chaque WHEN a sa propre condition :

SELECT id, total,
       CASE
         WHEN total >= 1000 THEN 'large'
         WHEN total >= 500 THEN 'medium'
         ELSE 'small'
       END AS size
FROM orders;

-- 1 | 1200 | large
-- 2 |  300 | small
-- 3 |  800 | medium
-- 4 | 2500 | large
-- 5 |  150 | small
-- 6 | NULL | small

Regardez la dernière ligne. L’ordre 6 n’a pas de total, mais il est étiqueté « petit ». Les deux comparaisons avec NULL n’étaient pas vraies, donc elles sont tombées sur ELSE. Nous montrons comment résoudre ce problème dans la section NULL. Donnez toujours un nom au résultat en utilisant AS, sinon vous risquez d’obtenir un nom de colonne maladroit.

CAS SIMPLE

Lorsque vous comparez une colonne avec des valeurs fixes, la forme la plus courte se lit mieux :

SELECT id,
       CASE status
         WHEN 'paid' THEN 'Complete'
         WHEN 'shipped' THEN 'Complete'
         WHEN 'pending' THEN 'Waiting'
       END AS label
FROM orders;

-- 1 | Complete
-- 2 | Waiting
-- 3 | Complete
-- 4 | Complete
-- 5 | NULL
-- 6 | Waiting

L’ordre compte

CASE s’arrête à la première condition vraie, et c’est le bug logique le plus courant. Échangez les deux conditions de notre requête précédente :

SELECT id, total,
       CASE
         WHEN total >= 500 THEN 'medium'
         WHEN total >= 1000 THEN 'large'
         ELSE 'small'
       END AS size
FROM orders WHERE id IN (1, 4);

-- 1 | 1200 | medium
-- 4 | 2500 | medium

Désormais, rien ne peut jamais être « grand ». Un total de 2 500 fait également au moins 500, donc la première branche gagne et la seconde n’est jamais atteinte. Aucune erreur n’apparaît, seulement des étiquettes erronées. Pour les plages, placez la condition la plus restrictive en premier ou écrivez des plages complètes, telles que total >= 500 AND total < 1000.

Que se passe-t-il sans ELSE ?

Dans notre exemple CASE simple ci-dessus, la commande 5 a été annulée et aucune branche ne l’a géré, le résultat était donc NULL. Parfois, c’est exactement ce que vous souhaitez, comme le montre la section suivante. Mais lors de la création d’étiquettes, un ELSE 'other' clair est généralement préférable, car il rend visibles les valeurs inattendues plutôt que de laisser des blancs dans un rapport.

Rapports de style pivot avec SUM

C’est l’un des modèles les plus utiles du SQL quotidien. Englober CASE dans un agrégat transforme les lignes en colonnes, avec une ligne par client :

SELECT customer,
       SUM(CASE WHEN status = 'paid' THEN total ELSE 0 END) AS paid,
       SUM(CASE WHEN status = 'pending' THEN 1 ELSE 0 END) AS pending_orders
FROM orders
GROUP BY customer
ORDER BY customer;

-- Asha   | 2000 | 0
-- Ben    |    0 | 2
-- Chitra |    0 | 0
-- Dev    |    0 | 0

Une seule requête donne désormais à la fois les revenus payés et le nombre de commandes en attente, sans avoir besoin de requêtes ou de jointures distinctes. Le modèle fonctionne dans presque toutes les bases de données, contrairement à la syntaxe dédiée PIVOT que seules certaines proposent. Si GROUP BY est nouveau pour vous, lisez SQL GROUP BY et HAVING.

Comptes conditionnels

COUNT ignore les valeurs NULL, donc un CASE sans ELSE ne compte que les lignes qui correspondent :

SELECT COUNT(*) AS all_orders,
       COUNT(CASE WHEN status = 'paid' THEN 1 END) AS paid_orders,
       COUNT(CASE WHEN total >= 1000 THEN 1 END) AS large_orders
FROM orders;

-- 6 | 2 | 2

Attention : si vous ajoutez ELSE 0 à l’intérieur d’un COUNT, chaque ligne est comptée, car 0 n’est pas NULL. Utilisez ELSE 0 avec SUM et laissez-le de côté avec COUNT. PostgreSQL et SQLite prennent également en charge COUNT(*) FILTER (WHERE ...), qui se lit bien, mais il n’est pas disponible partout.

Regroupement par un CASE

Vous pouvez créer vos propres buckets, puis les résumer :

SELECT CASE WHEN total >= 1000 THEN 'large' ELSE 'other' END AS bucket,
       COUNT(*)
FROM orders
GROUP BY bucket
ORDER BY bucket;

-- large | 2
-- other | 4

Le regroupement par alias fonctionne dans SQLite, PostgreSQL et MySQL. SQL Server ne le permet pas, vous devrez donc d’abord répéter l’expression entière ou placer la requête dans un CTE ou une sous-requête.

Tri personnalisé avec ORDER BY

L’ordre alphabétique est rarement ce qu’une entreprise souhaite. CASE vous permet de définir votre propre commande :

SELECT id, status FROM orders
ORDER BY CASE status
           WHEN 'pending' THEN 1
           WHEN 'paid' THEN 2
           ELSE 3
         END, id;

-- 2 | pending
-- 6 | pending
-- 1 | paid
-- 3 | paid
-- 4 | shipped
-- 5 | cancelled

Les commandes en attente viennent en premier, ce qui est pratique pour une file d’attente de travail. La deuxième colonne de tri, id, conserve les lignes dans un ordre prévisible au sein de chaque groupe.

CAS en MISE À JOUR

CASE permet à une instruction d’appliquer différentes modifications à différentes lignes. Ici, les petites commandes en attente sont signalées pour examen :

UPDATE orders
SET status = CASE
               WHEN status = 'pending' AND total < 500 THEN 'review'
               ELSE status
             END;

SELECT id, status FROM orders WHERE customer = 'Ben';

-- 2 | review
-- 6 | pending

Le ELSE status conserve les autres lignes inchangées. Le laisser de côté est dangereux, car les lignes sans correspondance seraient définies sur NULL. Sans clause WHERE, cette instruction touche également chaque ligne, donc sur les grandes tables, ajoutez un filtre et envisagez d’encapsuler la modification dans une transaction afin de pouvoir vérifier le résultat avant de valider. Notez également que l’ordre 6 n’a pas changé, car son total NULL ne satisfaisait pas total < 500.

Pièges NULL

NULL provoque deux problèmes distincts avec CASE. Premièrement, la forme simple compare en utilisant l’égalité, et rien n’est égal à NULL, pas même NULL lui-même :

SELECT CASE NULL WHEN NULL THEN 'matched' ELSE 'not matched' END;

-- not matched

Donc CASE col WHEN NULL ne correspond jamais. Utilisez plutôt le formulaire recherché avec IS NULL. Deuxièmement, comme nous l’avons vu avec l’ordre 6, une valeur NULL échappe aux comparaisons et atterrit dans ELSE. La solution consiste à le vérifier d’abord :

SELECT id,
       CASE
         WHEN total IS NULL THEN 'unknown'
         WHEN total >= 1000 THEN 'large'
         ELSE 'other'
       END AS size
FROM orders WHERE id IN (1, 2, 6);

-- 1 | large
-- 2 | other
-- 6 | unknown

La commande 6 reçoit désormais une étiquette honnête. Notre guide sur les Valeurs SQL NULL couvre ce comportement dans son intégralité.

CAS vs autres options

Cette dernière option mérite réflexion. Si un CASE atteint trente branches et apparaît dans cinq requêtes, déplacez le mappage dans une table et rejoignez-y. Un changement consiste alors en une mise à jour d’une seule ligne, plutôt qu’en un changement de code à cinq endroits.

Erreurs courantes

• Mauvais ordre des conditions. Une condition générale masque d’abord les conditions plus étroites.
• Oublier END. C’est l’erreur de syntaxe la plus fréquente.
• Utilisation de WHEN NULL. Cela ne correspond jamais, alors utilisez WHEN col IS NULL.
• Ajout de ELSE 0 à l’intérieur de COUNT. Il compte toutes les lignes.
• Omettre ELSE dans une MISE À JOUR. Il peut effacer les valeurs avec NULL.
• Filtrage par CASE dans WHERE. Il peut empêcher l’utilisation d’un index. Consultez notre guide sur l’optimisation des requêtes SQL.

Pour conclure

CASE WHEN est une petite fonctionnalité qui fait beaucoup de travail. N’oubliez pas trois règles : la première vraie branche gagne, les lignes sans correspondance deviennent NULL sans ELSE et NULL a besoin de sa propre vérification. Pour vous entraîner, prenez un rapport que vous construisez actuellement avec plusieurs requêtes et essayez de le produire comme une seule requête en utilisant SUM(CASE ...).

Questions fréquentes

Continuez à apprendre