Documentation PostgreSQL 15.15 » Langage SQL » Fonctions et opérateurs » Expressions conditionnelles

Précédent | Niveau supérieur | Suivant
9.17. Fonctions de manipulation de séquence | Sommaire | 9.19. Fonctions et opérateurs tableau

## 9.18. Expressions conditionnelles

Cette section décrit les expressions conditionnelles compatibles SQL disponibles dans PostgreSQL.

### Astuce

Si vos besoins dépassent les possibilités de ces expressions conditionnelles, il faudrait considérer l'écriture d'une fonction serveur dans un langage de programmation plus expressif.

### Note

Bien que `COALESCE`, `GREATEST` et `LEAST` sont syntaxiquement similaires aux fonctions, ce ne sont pas des fonctions ordinaires et, de ce fait, ne peuvent pas être utilisées avec des arguments de tableau `VARIADIC`.

### 9.18.1. `CASE`

L'expression SQL `CASE` est une expression conditionnelle générique, similaire à des instructions if/else dans les autres langages de programmation :

    CASE WHEN condition THEN result
         [WHEN ...]
         [ELSE result]
    END

Les clauses `CASE` peuvent être utilisées partout où une expression est valide. Chaque `condition` est une expression qui renvoie un résultat `boolean`. Si le résultat de la condition est true, la valeur de l'expression `CASE` est le résultat `result` qui suit la condition, et le reste de l'expression `CASE` n'est pas traité. Si le résultat de la condition ne vaut pas true, toutes les clauses `WHEN` suivants sont examinées de la même manière. Si aucun `WHEN` `condition` ne renvoie true, la valeur de l'expression `CASE` est le `result` de la clause `ELSE`. S'il n'y a pas de clause `ELSE` et qu'aucune condition ne vaut true, le résultat est NULL.

An example:

    SELECT * FROM test;

     a
    ---
     1
     2
     3

    SELECT a,
           CASE WHEN a=1 THEN 'one'
                WHEN a=2 THEN 'two'
                ELSE 'other'
           END
        FROM test;

     a | case
    ---+-------
     1 | one
     2 | two
     3 | other

Les types de données de toutes les expressions `result` doivent être convertibles en un seul type de sortie. Voir Section 10.5 pour plus de détails.

Il existe une forme « simple » d'expression `CASE` qui est une variante de la forme générale ci-dessus :

    CASE expression
        WHEN value THEN result
        [WHEN ...]
        [ELSE result]
    END

La première `expression` est calculée, puis comparée à chacune des expressions `value` dans les clauses `WHEN` jusqu'à ce qu'une valeur égale soit trouvée. Si aucune égalité n'est trouvée, l'expression `result` de la clause `ELSE` (ou une valeur NULL) est renvoyée. Ceci est similaire à l'instruction `switch` en C.

L'exemple ci-dessus peut être écrit en utilisant la syntaxe simple `CASE` :

    SELECT a,
           CASE a WHEN 1 THEN 'one'
                  WHEN 2 THEN 'two'
                  ELSE 'other'
           END
        FROM test;

     a | case
    ---+-------
     1 | one
     2 | two
     3 | other

Une expression `CASE` n'évalue pas les sous-expressions qui ne sont pas nécessaires pour déterminer le résultat. Par exemple, voici une façon possible d'éviter une erreur de division par zéro :

    SELECT ... WHERE CASE WHEN x <> 0 THEN y/x > 1.5 ELSE false END;

### Note

Comme décrit dans Section 4.2.14, il existe différentes situations pour lesquelles les sous-expressions d'une expression sont évaluées à différents moments, donc le principe pour lequel « `CASE` évalue seulement les sous-expressions nécessaires » n'est pas sûr. Par exemple, une sous-expression constante `1/0` pourrait donner une erreur de division par zéro lors de l'optimisation de la requête, même si elle est dans une partie du `CASE` qui n'aurait pas été exécutée au moment de l'exécution.

### 9.18.2. `COALESCE`

    COALESCE(value [, ...])

La fonction `COALESCE` renvoie le premier de ses arguments non NULL. NULL est renvoyé seulement si tous les arguments sont NULL. Elle est souvent utilisée pour substituer une valeur par défaut pour les valeurs NULL quand les données sont récupérées pour affichage. Par exemple :

    SELECT COALESCE(description, short_description, '(none)') ...

Ceci renvoie `description` si ce champ n'est pas NULL, sinon `short_description` si ce champ n'est pas NULL, et sinon `(none)`.

Les arguments doivent tous être convertibles vers un type de données commun, qui* sera le type du résultat (voir Section 10.5 pour les détails).

Comme une expression `CASE`, `COALESCE` évalue seulement les arguments qui sont nécessaires pour déterminer le résultat ; c'est-à-dire les arguments à droite du premier argument non NULL ne sont pas évalués. Cette fonction du standard SQL fournit des possibilités similaires à `NVL` et `IFNULL`, qui sont utilisées dans d'autres systèmes de bases de données.

### 9.18.3. `NULLIF`

    NULLIF(value1, value2)

La fonction `NULLIF` renvoie une valeur NULL si `value1` est égal à `value2` ; sinon, elle renvoie `value1`. Elle peut être utilisée pour réaliser l'opération inverse de l'exemple `COALESCE` donné ci-dessus :

    SELECT NULLIF(value, '(none)') ...

Dans cet exemple, si `value` vaut `(none)`, NULL est renvoyé, sinon la valeur de `value` est renvoyée.

Les deux arguments doit être de types comparables. Pour être spécifique, ils sont comparés exactement comme si vous aviez écrit ``value1` = `value2``, donc il doit y avoir un opérateur `=` convenable de disponible.

Le résultat a le même type que le premier argument -- mais il existe une subtilité. Ce qui est réellement renvoyé est le premier argument de l'opérateur `=` impliqué et, dans certains cas, aura été promu pour correspondre au type du deuxième argument. Par exemple, `NULLIF(1, 2.2)` renvoie `numeric` parce qu'il n'y a pas d'opérateur `integer` `=` `numeric`, seulement un `numeric` `=` `numeric`.

### 9.18.4. `GREATEST` et `LEAST`

    GREATEST(value [, ...])

    LEAST(value [, ...])

Les fonctions `GREATEST` et `LEAST` sélectionnent la valeur la plus grande ou la plus petite d'une liste d'expressions. Les expressions doivent toutes être convertibles en un type de donnée commun, qui sera le type du résultat (voir Section 10.5 pour les détails). Les valeurs NULL de la liste sont ignorées. Le résultat sera NULL seulement si toutes les expressions sont évaluées à NULL.

Notez que `GREATEST` and `LEAST` ne font pas partie du standard SQL mais sont une extension courante. Certaines autres bases de données les font renvoyer NULL si un argument est NULL, plutôt que quand toutes sont NULL.