WHEN en SQL : syntaxe et conditions avancées expliquées

La clause WHEN en SQL permet de définir des conditions logiques pour créer des expressions conditionnelles sophistiquées. Cette syntaxe constitue le cœur des structures CASE et représente l'un des éléments les plus puissants pour manipuler et transformer vos données selon des critères précis.

Que vous prépariez un entretien technique ou cherchiez à optimiser vos requêtes, maîtriser WHEN vous permettra de résoudre des problèmes complexes de logique métier. Cette clause s'avère indispensable pour segmenter des données, créer des catégories dynamiques ou appliquer des transformations conditionnelles.

Dans cet article, nous explorerons la syntaxe complète de WHEN, ses différentes applications et les techniques avancées qui vous distingueront lors de vos évaluations techniques.

Syntaxe fondamentale de WHEN en SQL

La clause WHEN fonctionne exclusivement au sein d'une expression CASE. Elle permet de spécifier les conditions qui déclenchent l'exécution d'une action particulière. SQL propose deux syntaxes distinctes pour utiliser WHEN selon vos besoins.

La syntaxe simple compare une expression à différentes valeurs :

CASE expression
    WHEN valeur1 THEN resultat1
    WHEN valeur2 THEN resultat2
    ELSE resultat_defaut
END

La syntaxe recherchée évalue des conditions booléennes complexes :

CASE
    WHEN condition1 THEN resultat1
    WHEN condition2 THEN resultat2
    ELSE resultat_defaut
END

Cette seconde approche offre une flexibilité maximale pour construire des logiques métier sophistiquées avec des opérateurs de comparaison, des fonctions et des sous-requêtes.

WHEN simple vs WHEN conditionnel

Le choix entre syntaxe simple et conditionnelle dépend de la complexité de vos critères d'évaluation. La syntaxe simple convient parfaitement pour des correspondances exactes sur une seule colonne.

Voici un exemple de WHEN simple pour catégoriser des produits :

SELECT 
    nom_produit,
    CASE type_produit
        WHEN 'A' THEN 'Premium'
        WHEN 'B' THEN 'Standard'
        WHEN 'C' THEN 'Économique'
        ELSE 'Non classifié'
    END AS categorie
FROM produits;

La syntaxe conditionnelle permet des évaluations plus complexes :

SELECT 
    nom_produit,
    prix,
    CASE
        WHEN prix > 1000 AND stock > 50 THEN 'Premium disponible'
        WHEN prix > 1000 AND stock <= 50 THEN 'Premium limité'
        WHEN prix BETWEEN 100 AND 1000 THEN 'Standard'
        ELSE 'Économique'
    END AS statut_produit
FROM produits;

Cette flexibilité rend la syntaxe conditionnelle indispensable pour les analyses métier complexes.

Conditions multiples avec WHEN

Les expressions WHEN supportent tous les opérateurs logiques SQL pour créer des conditions sophistiquées. Vous pouvez combiner plusieurs critères avec AND, OR et utiliser la négation avec NOT.

SELECT 
    client_id,
    age,
    salaire,
    CASE
        WHEN age BETWEEN 25 AND 35 AND salaire > 50000 THEN 'Cible premium'
        WHEN age < 25 OR salaire < 30000 THEN 'Segment jeune/économique'
        WHEN age > 60 AND salaire > 40000 THEN 'Senior aisé'
        ELSE 'Segment général'
    END AS segment_client
FROM clients;

L'ordre d'évaluation des conditions WHEN suit une logique séquentielle. SQL évalue chaque condition dans l'ordre d'apparition et s'arrête à la première condition vraie rencontrée.

Opérateurs avancés dans les conditions WHEN

Les conditions WHEN acceptent tous les opérateurs SQL standards, y compris les plus avancés. Cette richesse syntaxique permet de résoudre des problèmes métier complexes avec élégance.

Ces opérateurs s'avèrent particulièrement utiles pour créer des segments clients sophistiqués :

SELECT 
    client_id,
    CASE
        WHEN email LIKE '%@entreprise.com' THEN 'Client B2B'
        WHEN commandes.total_annuel > 5000 THEN 'VIP'
        WHEN derniere_commande IS NULL THEN 'Prospect'
        WHEN ville IN ('Paris', 'Lyon', 'Marseille') THEN 'Grande ville'
        ELSE 'Standard'
    END AS type_client
FROM clients
LEFT JOIN (
    SELECT client_id, SUM(montant) as total_annuel
    FROM commandes 
    WHERE date_commande >= '2026-01-01'
    GROUP BY client_id
) commandes ON clients.id = commandes.client_id;

WHEN avec sous-requêtes et fonctions

Les conditions WHEN supportent l'intégration de sous-requêtes et fonctions SQL, offrant des possibilités d'analyse avancées. Cette approche permet de contextualiser chaque ligne par rapport à l'ensemble du dataset.

SELECT 
    employe_id,
    salaire,
    CASE
        WHEN salaire > (SELECT AVG(salaire) FROM employes) 
             THEN 'Au-dessus de la moyenne'
        WHEN salaire < (SELECT AVG(salaire) * 0.8 FROM employes) 
             THEN 'Sous-payé'
        ELSE 'Dans la moyenne'
    END AS niveau_salaire
FROM employes;

Les fonctions analytiques enrichissent également les possibilités :

SELECT 
    produit_id,
    ventes_mensuelles,
    CASE
        WHEN ventes_mensuelles > LAG(ventes_mensuelles) OVER (ORDER BY mois) 
             THEN 'En croissance'
        WHEN ventes_mensuelles < LAG(ventes_mensuelles) OVER (ORDER BY mois) 
             THEN 'En baisse'
        ELSE 'Stable'
    END AS tendance
FROM ventes_produits;

Cette intégration de fonctions fenêtre SQL dans les conditions WHEN permet des analyses de tendances sophistiquées.

Gestion des valeurs NULL avec WHEN

Les valeurs NULL nécessitent une attention particulière dans les conditions WHEN. SQL suit une logique ternaire (vrai, faux, inconnu) qui peut surprendre les développeurs habitués à la logique booléenne classique.

SELECT 
    client_id,
    telephone,
    email,
    CASE
        WHEN telephone IS NOT NULL AND email IS NOT NULL 
             THEN 'Contact complet'
        WHEN telephone IS NOT NULL AND email IS NULL 
             THEN 'Téléphone uniquement'
        WHEN telephone IS NULL AND email IS NOT NULL 
             THEN 'Email uniquement'
        WHEN telephone IS NULL AND email IS NULL 
             THEN 'Aucun contact'
        ELSE 'Cas non prévu'
    END AS statut_contact
FROM clients;

La fonction COALESCE s'avère utile pour gérer les valeurs par défaut :

SELECT 
    commande_id,
    CASE
        WHEN COALESCE(remise, 0) > 0.15 THEN 'Forte remise'
        WHEN COALESCE(remise, 0) > 0.05 THEN 'Remise modérée'
        ELSE 'Aucune remise'
    END AS niveau_remise
FROM commandes;

Optimisation des performances avec WHEN

L'ordre des conditions WHEN impacte directement les performances de vos requêtes. Placez les conditions les plus fréquemment vraies en premier pour minimiser le nombre d'évaluations.

-- Optimisé : condition la plus fréquente en premier
SELECT 
    transaction_id,
    CASE
        WHEN statut = 'VALIDEE' THEN 'Transaction normale'  -- 80% des cas
        WHEN statut = 'EN_ATTENTE' THEN 'À traiter'         -- 15% des cas
        WHEN statut = 'ANNULEE' THEN 'Transaction annulée'  -- 5% des cas
        ELSE 'Statut inconnu'
    END AS description_statut
FROM transactions;

Pour les conditions complexes impliquant des calculs coûteux, considérez l'utilisation de CTE SQL pour pré-calculer les valeurs :

WITH stats_clients AS (
    SELECT 
        client_id,
        COUNT(*) as nb_commandes,
        SUM(montant) as total_depense,
        AVG(montant) as panier_moyen
    FROM commandes
    GROUP BY client_id
)
SELECT 
    c.client_id,
    CASE
        WHEN s.nb_commandes > 50 AND s.total_depense > 10000 THEN 'VIP'
        WHEN s.nb_commandes > 20 AND s.panier_moyen > 200 THEN 'Premium'
        WHEN s.nb_commandes > 5 THEN 'Régulier'
        ELSE 'Occasionnel'
    END AS segment
FROM clients c
LEFT JOIN stats_clients s ON c.id = s.client_id;

Cas d'usage avancés en entreprise

Les conditions WHEN permettent de résoudre des problématiques métier complexes. Voici quelques patterns fréquemment utilisés en analyse de données.

Scoring de leads avec pondération multiple :

SELECT 
    lead_id,
    CASE
        WHEN secteur = 'IT' AND taille_entreprise > 500 
             AND budget_estime > 100000 THEN 100
        WHEN secteur IN ('Finance', 'Santé') 
             AND budget_estime > 50000 THEN 80
        WHEN source_lead = 'Recommandation' 
             AND derniere_interaction < 7 THEN 70
        WHEN email LIKE '%@%' 
             AND telephone IS NOT NULL THEN 50
        ELSE 20
    END AS score_lead
FROM leads;

Calcul de commissions avec paliers dégressifs :

SELECT 
    vendeur_id,
    ventes_totales,
    CASE
        WHEN ventes_totales > 100000 THEN ventes_totales * 0.08
        WHEN ventes_totales > 50000 THEN ventes_totales * 0.06
        WHEN ventes_totales > 20000 THEN ventes_totales * 0.04
        ELSE ventes_totales * 0.02
    END AS commission
FROM ventes_vendeur;

Ces exemples illustrent la polyvalence des conditions WHEN pour implémenter des règles métier sophistiquées directement en SQL.

Questions fréquentes

Peut-on imbriquer des expressions CASE WHEN ?

Oui, SQL permet d'imbriquer des expressions CASE WHEN pour créer des logiques conditionnelles complexes. Chaque expression CASE constitue une valeur qui peut être utilisée dans une condition WHEN de niveau supérieur. Cette approche reste lisible pour 2-3 niveaux maximum.

WHEN fonctionne-t-il avec tous les types de données ?

WHEN supporte tous les types de données SQL : numériques, chaînes, dates, booléens et même les types complexes selon votre SGBD. Les comparaisons respectent les règles de conversion implicite de SQL, mais il est recommandé d'être explicite sur les types pour éviter les erreurs.

Comment gérer plusieurs conditions vraies simultanément ?

SQL évalue les conditions WHEN de manière séquentielle et s'arrête à la première condition vraie. Si vous devez traiter plusieurs conditions vraies, utilisez des expressions CASE distinctes ou restructurez votre logique avec des opérateurs AND/OR dans une même condition.

Les conditions WHEN impactent-elles les performances ?

L'impact dépend de la complexité des conditions et de l'ordre d'évaluation. Les conditions simples sur des colonnes indexées restent performantes. Les sous-requêtes ou calculs complexes dans WHEN peuvent ralentir l'exécution. Optimisez en plaçant les conditions les plus fréquentes en premier.

Peut-on utiliser WHEN dans les clauses WHERE ou HAVING ?

WHEN ne s'utilise que dans les expressions CASE. Pour des conditions dans WHERE ou HAVING, utilisez directement les opérateurs de comparaison et logiques. Les expressions CASE WHEN complètes peuvent cependant être utilisées dans ces clauses si nécessaire.

Conclusion

La maîtrise de la syntaxe WHEN en SQL vous permet de créer des logiques conditionnelles sophistiquées essentielles pour l'analyse de données moderne. Des conditions simples aux expressions complexes avec sous-requêtes, cette clause constitue un outil indispensable pour transformer et segmenter vos données selon des critères métier précis.

L'ordre d'évaluation, la gestion des valeurs NULL et l'optimisation des performances représentent les aspects techniques cruciaux à retenir. Ces compétences vous distingueront lors de vos entretiens techniques et dans vos missions d'analyse.

Poursuivez votre apprentissage avec nos exercices pratiques sur SQL Pratique pour consolider ces concepts et découvrir d'autres techniques avancées.