35.7. Structures de Contrôle

35.7.1.1. RETURN

RETURN expression;

RETURN accompagné d'une expression termine la fonction et renvoie le valeur d'expression à l'appelant. Cette forme est à utiliser avec des fonctions PL/pgSQL qui ne renvoient pas d'ensemble de valeurs.

Lorsqu'elle renvoie un type scalaire, n'importe quelle expression peut être utilisée. Le résultat de l'expression sera automatiquement transtypé vers le type de retour de la fonction, comme décrit pour les assignations. Pour renvoyer une valeur composite (ligne), vous devez écrire une variable record ou ligne comme expression.

La valeur de retour d'une fonction ne peut pas être laissée indéfinie. Si le contrôle atteint la fin du bloc de premier niveau sans avoir rencontré d'instruction RETURN une erreur d'éxécution sera lancée.

Notez que si vous avez déclaré la fonction comme renvoyant void, une instruction RETURN doit être quand même fournie ; l'expression suivant la commande RETURN est cependant optionnelle et sera ignorée dans tous les cas.

35.7.1.2. RETURN NEXT

RETURN NEXT expression;

Lorsqu'une fonction PL/pgSQL est déclarée renvoyer SETOF type quelconque, la procédure à suivre est légèrement différente. Dans ce cas, les items individuels à renvoyer sont spécifiés dans les commandes RETURN NEXT, et ensuite une commande RETURN finale, sans arguments est utilisée pour indiquer que la fonction a terminé son exécution. RETURN NEXT peut être utilisé avec des types scalaires et des types composites de données; dans ce dernier cas, une << table >> entière de résultats sera renvoyée.

Les fonctions qui utilisent RETURN NEXT devraient être appelées d'après le modèle suivant :

SELECT * FROM some_func();

En fait, la fonction doit être utilisée comme table source dans une clause FROM

RETURN NEXT n'effectue pas vraiment de renvoi; il sauvegarde simplement les valeurs des expressions. L'exécution continue alors avec la prochaîne instruction dans la fonction PL/pgSQL. Lorsque des commandes RETURN NEXT successives sont renvoyées, l'ensemble des résultats est élaboré. Un RETURN final, qui ne devrait pas avoir d'argument, provoque la sortie du contrôle de la fonction.

35.7.2.1. IF-THEN

IF expression-booleenne THEN
    instructions
END IF;

Les instructions IF-THEN sont la forme la plus simple de IF. Les instructions entre THEN et END IF seront exécutées si la condition est true. Autrement, ils seront négligés.

Exemple :

IF v_user_id <> 0 THEN
    UPDATE users SET email = v_email WHERE user_id = v_user_id;
END IF;

35.7.2.2. IF-THEN-ELSE

IF expression-booleenne THEN
    instructions
ELSE
    instructions
END IF;

Les instructions IF-THEN-ELSE s'ajoutent au IF-THEN en vous permettant de spécifier un ensemble d'instructions alternatif à exécuter si la condition est evaluée à false.

Exemples :

IF parentid IS NULL OR parentid = ''
THEN
    RETURN fullname;
ELSE
    RETURN hp_true_filename(parentid) || '/' || fullname;
END IF;

IF v_count > 0 THEN 
    INSERT INTO users_count (count) VALUES (v_count);
    RETURN 't';
ELSE
    RETURN 'f';
END IF;

35.7.2.3. IF-THEN-ELSE IF

Les instructions IF peuvent être imbriquées, comme dans l'exemple suivant :

IF demo_row.sex = 'm' THEN
    pretty_sex := ''man'';
ELSE
    IF demo_row.sex = 'f' THEN
        pretty_sex := 'woman';
    END IF;
END IF;

Lorsque vous utilisez cette forme, vous imbriquez une instruction IF dans la partie ELSE d'une instruction IF extérieure. Ansi vous avez besoin d'une instruction END IF pour chaque IF imbriqué et une pour le IF-ELSE parent. Ceci fonctionne mais devient fastidieux quand il y a de nombreuses alternatives à traiter. Considérez alors la forme suivante.

35.7.2.4. IF-THEN-ELSIF-ELSE

IF expression-booleenne THEN
    instructions
[ ELSIF expression-booleenne THEN
    instructions
[ ELSIF expression-booleenne THEN
    instructions
    ...]]
[ ELSE
    instructions ]
END IF;

IF-THEN-ELSIF-ELSE fournit une méthode plus pratique pour vérifier de nombreuses alternatives en une instruction. Elle est équivalente formellement aux commandes IF-THEN-ELSE-IF-THEN imbriquées, mais un seul END IF est nécessaire.

Voici un exemple :

IF number = 0 THEN
    result := 'zero';
ELSIF number > 0 THEN 
    result := 'positif';
ELSIF number < 0 THEN
    result := 'negatif';
ELSE
    -- hmm, la seule possibilité est que le nombre soit null
    result := 'NULL';
END IF;

35.7.2.5. IF-THEN-ELSEIF-ELSE

ELSEIF est un alias pour ELSIF.

35.7.3.1. LOOP

[<<label>>]
LOOP
    instructions
END LOOP;

LOOP définit une boucle inconditionnelle répétée indéfiniement jusqu'a ce qu'elle soit terminée par une instruction EXIT ou RETURN. Le label optionnel peut être utilisé par les instructions EXIT dans le cas de boucles imbriquées pour définir quel niveau d'imbrication doit s'achever.

35.7.3.2. EXIT

EXIT [ label ] [ WHEN expression ];

Si aucun label n'est donné la boucle la plus imbriquée se termine et l'instruction suivant END LOOP est exécutée ensuite. Si un label est donné, ce doit être le label de la boucle ou du bloc courant ou d'un niveau moins imbriqué. La boucle ou le bloc nommé se termine alors et le contrôle continue avec l'instruction située après le END de la boucle ou du bloc correspondant.

Si WHEN est présent, la sortie de boucle ne s'effectue que si les conditions spécifiées sont true, autrement le contrôle passe à l'instruction suivant le EXIT.

EXIT peut être utilisé pour causer un départ rapide de tout type de boucles ; il n'est pas limité en utilisation aux boucles sans condition.

Exemples :

LOOP
    -- quelques traitements
    IF count > 0 THEN
        EXIT;  -- sortie de boucle
    END IF;
END LOOP;

LOOP
    -- quelques traitements
    EXIT WHEN count > 0;
END LOOP;

BEGIN
    -- quelques traitements
    IF stocks > 100000 THEN
        EXIT;  -- cause la sortie (EXIT) du bloc BEGIN
    END IF;
END;

35.7.3.3. WHILE

[<<label>>]
WHILE expression LOOP
    instructions
END LOOP;

L'instruction WHILE repète une séquence d'instructions aussi longtemps que l'expression conditionnelle est évaluée à vrai. La condition est vérifée juste avant chaque entrée dans le corps de la boucle.

Par exemple :

WHILE amount_owed > 0 AND gift_certificate_balance > 0 LOOP
    -- quelques traitements ici
END LOOP;

WHILE NOT boolean_expression LOOP
    -- quelques traitements ici
END LOOP;

35.7.3.4. FOR (variante avec entier)

[<<label>>]
FOR nom IN [ REVERSE ] expression .. expression LOOP
    instruction
END LOOP;

Cette forme de FOR crée une boucle qui effectue une itération sur une plage de valeurs entières. La variable nom est automatiquement définie comme un type integer et n'existe que dans la boucle. Les deux expressions donnant les limites inférieures et supérieures de la plage sont evaluées une fois en entrant dans la boucle. Le pas de l'itération est normalement de 1, mais est -1 quand REVERSE is spécifié.

Quelques exemples de boucles FOR avec entiers :

FOR i IN 1..10 LOOP
    -- quelques calculs ici
    RAISE NOTICE 'i is %', i;
END LOOP;

FOR i IN REVERSE 10..1 LOOP
    -- quelques calculs ici
END LOOP;

Si la limite basse est plus grande que la limite haute (ou moins grande que, dans le cas du REVERSE case), le corps de la boucle n'est pas exécuté du tout. Aucune erreur n'est renvoyée.