Catégories :

Fonctions d’expressions conditionnelles

CASE

Fonctionne comme une instruction en cascade « if-then-else ». Dans sa forme la plus générale, une série de conditions est évaluée en séquence. Lorsqu’une condition est évaluée à TRUE, l’évaluation est arrêtée et le résultat associé (après THEN) est renvoyé. Si aucune des conditions n’est évaluée à TRUE, le résultat après le ELSE facultatif est renvoyé, s’il est présent ; sinon, NULL est renvoyé.

Dans la seconde forme « abrégée », l’expression après CASE est comparée à chacune des expressions WHEN dans l’ordre, jusqu’à ce que l’une corresponde ; alors le résultat associé (après THEN) est renvoyé. Si aucune des expressions ne correspond, le résultat après le ELSE facultatif est renvoyé, s’il est présent ; sinon, NULL est renvoyé.

Notez que dans le second formulaire, une expression NULL CASE ne correspond à aucune des expressions WHEN, même si l’une des expressions WHEN correspond également à NULL.

Voir aussi

IFF

Syntaxe

CASE
    WHEN <condition1> THEN <result1>
  [ WHEN <condition2> THEN <result2> ]
  [ ... ]
  [ ELSE <result3> ]
END

CASE <expr>
    WHEN <value1> THEN <result1>
  [ WHEN <value2> THEN <result2> ]
  [ ... ]
  [ ELSE <result3> ]
END

Arguments

condition#

Dans la première forme de CASE, chaque condition est une expression qui doit correspondre à une valeur BOOLEAN (True, False ou NULL).

expr

Une expression générale.

valeur

Dans la seconde forme de CASE, chaque valeur est une correspondance potentielle pour expr. La valeur peut être un littéral ou une expression. La valeur doit correspondre au même type de données que expr ou être un type de données pouvant être converti en type de données expr.

résultat#

Dans la première forme de la clause CASE, si condition# est vraie, alors la fonction renvoie le résultat# correspondant. Si plusieurs conditions sont vraies, le résultat associé à la première condition vraie est renvoyé.

Dans la seconde forme de l’instruction CASE, si valeur# correspond à expr, le résultat correspondant est renvoyé. Si plus d’une valeur correspond à expr, le résultat de la première valeur correspondante est renvoyé.

Le résultat doit être une expression qui donne une valeur unique.

Dans les deux formes de CASE, si la clause facultative ELSE est présente et si aucune correspondance n’est trouvée, la fonction renvoie le résultat dans la clause ELSE. Si aucune clause ELSE n’est présente et qu’aucune correspondance n’est trouvée, le résultat est NULL.

Notes sur l’utilisation

  • Notez que, contrairement à DECODE, une valeur NULL dans la condition ne correspond pas à une valeur NULL ailleurs dans la condition. Par exemple, WHEN <expr_null> = NULL THEN 'Return me!' ne renvoie pas « Rends-moi ! ». Si vous souhaitez comparer avec des valeurs NULL, utilisez IS NULL plutôt que = NULL.

  • Les condition#, expr, valeur et résultat peuvent tous être des expressions générales et peuvent donc inclure des sous-requêtes incluant des opérateurs Set, tels que UNION, INTERSECT, EXCEPT et MINUS. Lorsque vous utilisez des opérateurs Set, assurez-vous que les types de données sont compatibles. Pour plus d’informations, voir Notes générales sur l’utilisation dans la rubrique Opérateurs Set.

Détails du classement

Dans la première forme de CASE, chaque expression est indépendante et les spécifications de classement dans différentes branches sont indépendantes. Par exemple, dans ce qui suit, les spécifications de classement dans condition1 sont indépendantes de la ou des spécifications de classement dans condition2. Ces spécifications de classement ne doivent pas nécessairement être identiques ni même compatibles.

CASE
    WHEN <condition1> THEN <result1>
  [ WHEN <condition2> THEN <result2> ]

Dans la seconde forme de CASE, bien que toutes les opérations liées au classement doivent utiliser des spécifications de classement compatibles, il n’est pas nécessaire que les spécifications de classement soient identiques. Par exemple, dans l’instruction suivante, les spécifications de classement de valeur1 et de valeur2 doivent être compatibles avec la spécification de classement de expr, mais les spécifications de classement de valeur1 et valeur2 n’ont pas besoin d’être identiques à la spécification de classement de expr.

CASE <expr>
    WHEN <value1> THEN <result1>
  [ WHEN <value2> THEN <result2> ]
  ...

La valeur renvoyée par la fonction a le classement le plus élevé -préséance des arguments THEN/ELSE.

Exemples

Cela montre une utilisation typique de CASE :

SELECT
    column1,
    CASE
        WHEN column1=1 THEN 'one'
        WHEN column1=2 THEN 'two'
        ELSE 'other'
    END AS result
FROM (values(1),(2),(3)) v;

Sortie :

+---------+--------+
| COLUMN1 | RESULT |
|---------+--------|
|       1 | one    |
|       2 | two    |
|       3 | other  |
+---------+--------+

Cela montre que si aucune des valeurs ne correspond et qu’il n’y a pas de clause ELSE, la valeur renvoyée est NULL :

SELECT
    column1,
    CASE
        WHEN column1=1 THEN 'one'
        WHEN column1=2 THEN 'two'
    END AS result
FROM (values(1),(2),(3)) v;

Sortie :

+---------+--------+
| COLUMN1 | RESULT |
|---------+--------|
|       1 | one    |
|       2 | two    |
|       3 | NULL   |
+---------+--------+

Cet exemple traite explicitement NULL.

SELECT
    column1,
    CASE 
        WHEN column1 = 1 THEN 'one'
        WHEN column1 = 2 THEN 'two'
        WHEN column1 IS NULL THEN 'NULL'
        ELSE 'other'
    END AS result
FROM VALUES (1), (2), (NULL);

Sortie :

+---------+--------+
| COLUMN1 | RESULT |
|---------+--------|
|       1 | one    |
|       2 | two    |
|    NULL | NULL   |
+---------+--------+

L’exemple suivant combine CASE avec un classement :

SELECT CASE COLLATE('m', 'upper')
    WHEN 'M' THEN TRUE
    ELSE FALSE
END;
+----------------------------+
| CASE COLLATE('M', 'UPPER') |
|     WHEN 'M' THEN TRUE     |
|     ELSE FALSE             |
| END                        |
|----------------------------|
| True                       |
+----------------------------+
SELECT CASE 'm'
    WHEN COLLATE('M', 'lower') THEN TRUE
    ELSE FALSE
END;
+------------------------------------------+
| CASE 'M'                                 |
|     WHEN COLLATE('M', 'LOWER') THEN TRUE |
|     ELSE FALSE                           |
| END                                      |
|------------------------------------------|
| True                                     |
+------------------------------------------+