Documentation PostgreSQL 15.15 » Langage SQL » Syntaxe SQL » Fonctions appelantes

Précédent | Niveau supérieur | Suivant
4.2. Expressions de valeurs | Sommaire | Chapitre 5. Définition des données

## 4.3. Fonctions appelantes

PostgreSQL permet aux fonctions qui ont des paramètres nommés d'être appelées en utilisant soit la notation par position soit la notation par nom. La notation par nom est particulièrement utile pour les fonctions qui ont un grand nombre de paramètres, car elle rend l'association entre paramètre et argument plus explicite et fiable. Dans la notation par position, un appel de fonction précise les valeurs en argument dans le même ordre que ce qui a été défini à la création de la fonction. Dans la notation nommée, les arguments sont précisés par leur nom et peuvent du coup être intégrés dans n'importe quel ordre. Pour chaque notation, considérez aussi l'effet des types d'argument de la fonction, documenté dans Section 10.3.

Quel que soit la notation, les paramètres qui ont des valeurs par défaut dans leur déclaration n'ont pas besoin d'être précisés dans l'appel. Ceci est particulièrement utile dans la notation nommée, car toute combinaison de paramètre peut être omise, alors que dans la notation par position, les paramètres peuvent seulement être omis de la droite vers la gauche.

PostgreSQL supporte aussi la notation mixée. Elle combine la notation par position avec la notation par nom. Dans ce cas, les paramètres de position sont écrits en premier, les paramètres nommés apparaissent après.

Les exemples suivants illustrent l'utilisation des trois notations, en utilisant la définition de fonction suivante :

    CREATE FUNCTION assemble_min_ou_maj(a text, b text, majuscule boolean DEFAULT false)
    RETURNS text
    AS
    $$
     SELECT CASE
            WHEN $3 THEN UPPER($1 || ' ' || $2)
            ELSE LOWER($1 || ' ' || $2)
            END;
    $$
    LANGUAGE SQL IMMUTABLE STRICT;

La fonction `assemble_min_ou_maj` a deux paramètres obligatoires, `a` et `b`. Il existe en plus un paramètre optionnel, `majuscule`, qui vaut par défaut `false`. Les arguments `a` et `b` seront concaténés et forcés soit en majuscule soit en minuscule suivant la valeur du paramètre `majuscule`. Les détails restants ne sont pas importants ici (voir le Chapitre 38 pour plus d'informations).

### 4.3.1. En utilisant la notation par position

La notation par position est le mécanisme traditionnel pour passer des arguments aux fonctions avec PostgreSQL. En voici un exemple :

    SELECT assemble_min_ou_maj('Hello', 'World', true);
     assemble_min_ou_maj
    ---------------------
     HELLO WORLD
    (1 row)

Tous les arguments sont indiqués dans l'ordre. Le résultat est en majuscule, car l'argument `majuscule` est indiqué à `true`. Voici un autre exemple :

    SELECT assemble_min_ou_maj('Hello', 'World');
     assemble_min_ou_maj
    -----------------------
     hello world
    (1 row)

Ici, le paramètre `majuscule` est omis, donc il récupère la valeur par défaut, soit `false`, ce qui a pour résultat une sortie en minuscule. Dans la notation par position, les arguments peuvent être omis de la droite à la gauche à partir du moment où ils ont des valeurs par défaut.

### 4.3.2. En utilisant la notation par nom

Dans la notation par nom, chaque nom d'argument est précisé en utilisant `=>` pour le séparer de l'expression de la valeur de l'argument. Par exemple :

    SELECT assemble_min_ou_maj(a => 'Hello', b => 'World');
     assemble_min_ou_maj
    ---------------------
     hello world
    (1 row)

Encore une fois, l'argument `majuscule` a été omis, donc il dispose de sa valeur par défaut, `false`, implicitement. Un avantage à utiliser la notation par nom est que les arguments peuvent être saisis dans n'importe quel ordre. Par exemple :

    SELECT assemble_min_ou_maj(a => 'Hello', b => 'World', uppercase => true);
     assemble_min_ou_maj
    ---------------------
     HELLO WORLD
    (1 row)

    SELECT assemble_min_ou_maj(a => 'Hello', uppercase => true, b => 'World');
     assemble_min_ou_maj
    ---------------------
     HELLO WORLD
    (1 row)

Une syntaxe plus ancienne basée sur « := » est supportée pour des raisons de compatibilité ascendante :

    SELECT assemble_min_ou_maj(a := 'Hello', uppercase := true, b := 'World');
     assemble_min_ou_maj
    ---------------------
     HELLO WORLD
    (1 row)

### 4.3.3. En utilisant la notation mixée

La notation mixée combine les notations par position et par nom. Néanmoins, comme cela a déjà été expliqué, les arguments par nom ne peuvent pas précéder les arguments par position. Par exemple :

    SELECT assemble_min_ou_maj('Hello', 'World', majuscule => true);
     assemble_min_ou_maj
    -----------------------
     HELLO WORLD
    (1 row)

Dans la requête ci-dessus, les arguments `a` et `b` sont précisés par leur position alors que `majuscule` est indiqué par son nom. Dans cet exemple, cela n'apporte pas grand-chose, sauf pour une documentation de la fonction. Avec une fonction plus complexe, comprenant de nombreux paramètres avec des valeurs par défaut, les notations par nom et mixées améliorent l'écriture des appels de fonction et permettent de réduire les risques d'erreurs.

### Note

Les notations par appel nommé ou mixe ne peuvent pas être utilisées lors de l'appel d'une fonction d'agrégat (mais elles fonctionnent quand une fonction d'agrégat est utilisée en tant que fonction de fenêtrage).