Instructions PL/pgSQL prises en charge

IF ... THEN

IF boolean-expression THEN
  statements
END IF;

Vous en trouverez un exemple ci-dessous.

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

IF ... THEN ... ELSE

IF boolean-expression THEN
  statements
ELSE
  statements
END IF;

Vous en trouverez un exemple ci-dessous.

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

IF ... THEN ... ELSIF ... THEN ... ELSE

Le mot clé ELSIF peut également être orthographié ELSEIF.

IF boolean-expression THEN
  statements
[ ELSIF boolean-expression THEN
  statements
[ ELSIF boolean-expression THEN
  statements
    ...] ]
[ ELSE
  statements ]
END IF;

Vous en trouverez un exemple ci-dessous.

IF number = 0 THEN
  result := 'zero';
ELSIF number > 0 THEN
  result := 'positive';
ELSIF number < 0 THEN
  result := 'negative';
ELSE
  -- the only other possibility is that number is null
  result := 'NULL';
END IF;                  

CASE simple

CASE search-expression
WHEN expression [, expression [ ... ]] THEN
  statements
[ WHEN expression [, expression [ ... ]] THEN
  statements
  ... ]
[ ELSE
  statements ]
END CASE;

Une instruction CASE simple fournit une exécution conditionnelle basée sur l'égalité des opérandes.

La valeur search-expression est évaluée une fois et comparée successivement à chaque expression dans les clauses WHEN. Si une correspondance est trouvée, les instructions (statements) correspondantes s'exécutent, puis le contrôle passe à l'instruction qui suit END CASE. Les expressions WHEN suivantes ne sont pas évaluées. Si aucune correspondance n'est trouvée, les instructions (statements) ELSE s'exécutent. Toutefois, en l'absence de ELSE, une exception CASE_NOT_FOUND est levée.

Vous en trouverez un exemple ci-dessous.

CASE x
WHEN 1, 2 THEN
  msg := 'one or two';
ELSE
  msg := 'other value than one or two';
END CASE;                  

CASE avec recherche

CASE
WHEN boolean-expression THEN
  statements
[ WHEN boolean-expression THEN
  statements
  ... ]
[ ELSE
  statements ]
END CASE;

La forme de CASE avec recherche fournit une exécution conditionnelle basée sur la véracité des expressions booléennes.

Chaque expression booléenne (boolean-expression) de la clause WHEN est évaluée à son tour jusqu'à ce qu'une d'elles fournisse la valeur true. Les instructions correspondantes s'exécutent alors, puis le contrôle passe à l'instruction qui suit END CASE. Les expressions WHEN suivantes ne sont pas évaluées. Si aucun résultat true n'est trouvé, les instructions (statements) ELSE sont exécutées. Toutefois, en l'absence de ELSE, une exception CASE_NOT_FOUND est levée.

Vous en trouverez un exemple ci-dessous.

CASE
WHEN x BETWEEN 0 AND 10 THEN
  msg := 'value is between zero and ten';
WHEN x BETWEEN 11 AND 20 THEN
  msg := 'value is between eleven and twenty';
END CASE;                                

Boucle simple

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

Une boucle simple définit une boucle sans condition qui se répète indéfiniment jusqu'à ce qu'elle soit terminée par une instruction EXIT ou RETURN. Une étiquette facultative peut être utilisée par les instructions EXIT et CONTINUE au sein de boucles imbriquées pour spécifier à quelle boucle l'instruction EXIT ou CONTINUE fait référence.

Vous en trouverez un exemple ci-dessous.

CREATE OR REPLACE PROCEDURE simple_loop()
LANGUAGE plpgsql
AS $$
BEGIN
  <<simple_while>>
  LOOP
    RAISE INFO 'I am raised once';  
    EXIT simple_while;
    RAISE INFO 'I am not raised';
  END LOOP;
  RAISE INFO 'I am raised once as well';
END;
$$;                

Quitter une boucle

EXIT [ label ] [ WHEN expression ];

Si aucune étiquette (label) n'est présente, la boucle la plus interne est interrompue et l'instruction qui suit le END LOOP s'exécute alors. Si une étiquette label est présente, ce doit être l'étiquette du niveau actuel ou d'un niveau extérieur de la boucle imbriquée ou du bloc. La boucle ou le bloc nommé est alors interrompu et le contrôle passe à l'instruction située après le END correspondant à la boucle ou au bloc.

Si WHEN est spécifié, la sortie de la boucle se produit uniquement si l'expression est vraie. Dans le cas contraire, le contrôle passe à l'instruction qui suit EXIT.

Vous pouvez utiliser EXIT avec tous les types de boucle. Il n'est pas limité à une utilisation avec des boucles sans condition.

Lorsqu'il est utilisé avec un bloc BEGIN, EXIT passe le contrôle à l'instruction suivante située après la fin du bloc. Une étiquette doit être utilisée à cet effet. Une instruction EXIT sans étiquette n'est jamais considérée comme correspondant à un bloc BEGIN.

Vous en trouverez un exemple ci-dessous.

CREATE OR REPLACE PROCEDURE simple_loop_when(x int)
LANGUAGE plpgsql
AS $$
DECLARE i INTEGER := 0;
BEGIN
  <<simple_loop_when>>
  LOOP
    RAISE INFO 'i %', i;
    i := i + 1;
    EXIT simple_loop_when WHEN (i >= x);
  END LOOP;
END;
$$;                     

Continuer une boucle

CONTINUE [ label ] [ WHEN expression ];

Si aucune étiquette (label) n'est fournie, l'exécution saute à l'itération suivante de la boucle la plus interne. Ainsi, toutes les instructions restantes du corps de la boucle sont ignorées. Le contrôle retourne ensuite à l'expression de contrôle de boucle (le cas échéant) pour déterminer si une autre itération de boucle est requise. Si une étiquette (label) est présente, elle spécifie l'étiquette de la boucle dont l'exécution est poursuivie.

Si l'instruction WHEN est spécifiée, l'itération suivante de la boucle est commencée seulement si l'expression est vraie. Dans le cas contraire, le contrôle passe à l'instruction qui suit CONTINUE.

Vous pouvez utiliser CONTINUE avec tous les types de boucle. Il n'est pas limité à une utilisation avec des boucles sans condition.

CONTINUE mylabel;

Boucle WHILE

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

L'instruction WHILE répète une série d'instructions tant que l'expression booléenne (boolean-expression) équivaut à true. L'expression est vérifiée juste avant chaque entrée dans le corps de la boucle.

Vous en trouverez un exemple ci-dessous.

WHILE amount_owed > 0 AND gift_certificate_balance > 0 LOOP
  -- some computations here
END LOOP;

WHILE NOT done LOOP
  -- some computations here
END LOOP;                  

Boucle FOR (variante avec entier)

[<<label>>]
FOR name IN [ REVERSE ] expression .. expression LOOP
  statements
END LOOP [ label ];

La boucle FOR (variante avec entier) crée une boucle qui effectue des itérations sur une plage de valeurs entières. Le nom de la variable est défini automatiquement de type entier et existe uniquement au sein de la boucle. Toute définition existante du nom de la variable est ignorée au sein de la boucle. Les deux expressions qui donnent les limites inférieure et supérieure de la plage sont évaluées une fois à l'entrée de la boucle. Si vous spécifiez REVERSE, la valeur du pas est soustraite au lieu d'être ajoutée après chaque itération.

Si la limite inférieure est supérieure à la limite supérieure (ou inférieure à celle-ci si REVERSE est utilisé), le corps de la boucle ne s'exécute pas. Aucune erreur n'est levée.

Si une étiquette est attachée à la boucle FOR, Vous pouvez référencer la variable entière de boucle avec un nom complet en utilisant cette étiquette.

Vous en trouverez un exemple ci-dessous.

FOR i IN 1..10 LOOP
  -- i will take on the values 1,2,3,4,5,6,7,8,9,10 within the loop
END LOOP;

FOR i IN REVERSE 10..1 LOOP
  -- i will take on the values 10,9,8,7,6,5,4,3,2,1 within the loop
END LOOP;                

Boucle FOR (variante avec ensemble de résultats)

[<<label>>]
FOR target IN query LOOP
  statements
END LOOP [ label ];

La cible (target) est une variable d'enregistrement ou une liste séparée par des virgules de variables scalaires. La cible se voit successivement attribuer chaque ligne résultant de la requête et le corps de la boucle est exécuté pour chaque ligne.

La boucle FOR (variante avec ensemble de résultats) permet à une procédure stockée d'itérer sur les résultats d'une requête et de manipuler ces données en conséquence.

Vous en trouverez un exemple ci-dessous.

CREATE PROCEDURE cs_refresh_reports() AS $$
DECLARE
  reports RECORD;
BEGIN
  FOR reports IN SELECT * FROM cs_reports ORDER BY sort_key LOOP
    -- Now "reports" has one record from cs_reports
    EXECUTE 'INSERT INTO ' || quote_ident(reports.report_name) || ' ' || reports.report_query;
  END LOOP;
  RETURN;
END;
$$ LANGUAGE plpgsql;                   

Boucle FOR avec instruction SQL dynamique

[<<label>>]
FOR record_or_row IN EXECUTE text_expression LOOP 
  statements
END LOOP;

Une boucle FOR avec instruction SQL dynamique permet à une procédure stockée d'itérer sur les résultats d'une requête dynamique et de manipuler ces données en conséquence.

Vous en trouverez un exemple ci-dessous.

CREATE OR REPLACE PROCEDURE for_loop_dynamic_sql(x int)
LANGUAGE plpgsql
AS $$
DECLARE
  rec RECORD;
  query text;
BEGIN
  query := 'SELECT * FROM tbl_dynamic_sql LIMIT ' || x;
  FOR rec IN EXECUTE query
  LOOP
    RAISE INFO 'a %', rec.a;
  END LOOP;
END;
$$;

Ouverture pour sélection : la variable de curseur est ouverte et reçoit la requête spécifiée à exécuter. Le curseur ne doit pas être déjà ouvert. De plus, il doit avoir été déclaré en tant que curseur non lié (c'est-à-dire, en tant que simple variable refcursor). La requête SELECT est traitée de la même manière que les autres instructions SELECT dans le langage PL/pgSQL.

OPEN cursor_name FOR SELECT ...;                     

Vous en trouverez un exemple ci-dessous.

OPEN curs1 FOR SELECT * FROM foo WHERE key = mykey;    

Ouverture pour exécution : la variable de curseur est ouverte et reçoit la requête spécifiée à exécuter. Le curseur ne doit pas être déjà ouvert. De plus, il doit avoir été déclaré en tant que curseur non lié (c'est-à-dire, en tant que simple variable refcursor). La requête est spécifiée en tant qu'expression de chaîne de la même manière que dans la commande EXECUTE. Cette approche est flexible et permet à la requête de varier d'une exécution à l'autre.

OPEN cursor_name FOR EXECUTE query_string;

Vous en trouverez un exemple ci-dessous.

OPEN curs1 FOR EXECUTE 'SELECT * FROM ' || quote_ident($1);

Ouverture d'un curseur lié : cette forme d'instruction OPEN est utilisée pour ouvrir une variable de curseur à laquelle sa requête a été liée quand elle a été déclarée. Le curseur ne doit pas être déjà ouvert. La liste des expressions des valeurs d'argument réelles doit apparaître si et seulement si le curseur a été déclaré comme acceptant des arguments. Ces valeurs sont substituées dans la requête.

OPEN bound_cursor_name [ ( argument_values ) ];

Vous en trouverez un exemple ci-dessous.

OPEN curs2;
OPEN curs3(42);

L'instruction FETCH extrait la ligne suivante du curseur dans une cible. Cette cible peut être une variable de ligne, une variable d'enregistrement ou une liste séparée par des virgules de variables simples, comme avec SELECT INTO. Comme avec SELECT INTO, vous pouvez vérifier la variable spéciale FOUND pour voir si une ligne a été obtenue.

FETCH cursor INTO target;

Vous en trouverez un exemple ci-dessous.

FETCH curs1 INTO rowvar;

L'instruction CLOSE ferme le portail sous-jacent à un curseur ouvert. Vous pouvez utiliser cette instruction pour libérer des ressources avant la fin de la transaction. Vous pouvez également utiliser cette instruction pour libérer la variable de curseur, qui pourra ainsi être de nouveau ouverte.

CLOSE cursor;

Vous en trouverez un exemple ci-dessous.

CLOSE curs1;