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
Copy

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.

value

Dans la seconde forme de CASE, chaque value est une correspondance potentielle pour expr. La value peut être un littéral ou une expression. La value 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.

result#

Dans la première forme de la clause CASE, si condition# est vraie, alors la fonction renvoie le result# 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 value# correspond à expr, le result correspondant est renvoyé. Si plus d’une value correspond à expr, le result 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, value et result 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> ]
Copy

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 value1 et de value2 doivent être compatibles avec la spécification de classement de expr, mais les spécifications de classement de value1 et value2 n’ont pas besoin d’être identiques à la spécification de classement de expr.

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

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;
Copy

Sortie :

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

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;
Copy

Sortie :

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

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);
Copy

Sortie :

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

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                                     |
+------------------------------------------+
Copy