PostgreSQLLa base de données la plus sophistiquée au monde.

Version anglaise

42.11. Astuces pour développer en PL/pgSQL

Un bon moyen de développer en PL/pgSQL est d'utiliser l'éditeur de texte de votre choix pour créer vos fonctions, et d'utiliser psql dans une autre fenêtre pour charger et tester ces fonctions. Si vous procédez ainsi, une bonne idée est d'écrire la fonction en utilisant CREATE OR REPLACE FUNCTION. De cette façon vous pouvez simplement recharger le fichier pour mettre à jour la définition de la fonction. Par exemple :

            CREATE OR REPLACE FUNCTION fonction_test(integer) RETURNS integer AS $$
          ....
$$ LANGUAGE plpgsql;
 

Pendant que psql s'exécute, vous pouvez charger ou recharger des définitions de fonction avec :

\i nom_fichier.sql
 

puis immédiatement soumettre des commandes SQL pour tester la fonction.

Un autre bon moyen de développer en PL/pgSQL est d'utiliser un outil d'accès à la base de données muni d'une interface graphique qui facilite le développement dans un langage de procédures. Un exemple d'un tel outil est pgAdmin, bien que d'autres existent. Ces outils fournissent souvent des fonctionnalités pratiques telles que la détection des guillemets ouverts et facilitent la re-création et le débogage des fonctions.

42.11.1. Utilisation des guillemets simples (quotes)

Le code d'une fonction PL/pgSQL est spécifié dans la commande CREATE FUNCTION comme une chaîne de caractères. Si vous écrivez la chaîne littérale de la façon ordinaire en l'entourant de guillemets simples, alors tout guillemet simple dans le corps de la fonction doit être doublé ; de la même façon, les antislashs doivent être doublés (en supposant que la syntaxe d'échappement de chaînes est utilisée). Doubler les guillemets devient rapidement difficile et, dans la plupart des cas compliqués, le code peut devenir rapidement incompréhensible parce que vous pouvez facilement vous trouver avec une douzaine, voire plus, de guillemets adjacents. À la place, il est recommandé d'écrire le corps de la fonction en tant qu'une chaîne littérale « avec guillemets dollar » (voir la Section 4.1.2.4, « Constantes de chaînes avec guillemet dollar »). Dans cette approche, vous ne doublez jamais les marques de guillemets mais vous devez faire attention à choisir un délimiteur dollar différent pour chaque niveau d'imbrication dont vous avez besoin. Par exemple, vous pouvez écrire la commande CREATE FUNCTION en tant que :

              CREATE OR REPLACE FUNCTION fonction_test(integer) RETURNS integer AS $PROC$
   ....
$PROC$ LANGUAGE plpgsql;
  

À l'intérieur de ceci, vous pouvez utiliser des guillemets pour les chaînes littérales simples dans les commandes SQL et $$ pour délimiter les fragments de commandes SQL que vous assemblez comme des chaînes. Si vous avez besoin de mettre entre guillemets du texte qui inclut $$, vous pouvez utiliser $Q$, et ainsi de suite.

Le graphe suivant montre ce que vous devez faire lors de l'écriture de guillemets simples sans guillemets dollar. Cela pourrait être utile lors de la traduction de code avec guillemets simples en quelque chose de plus compréhensible.

1 guillemet simple

Pour commencer et terminer le corps de la fonction, par exemple :

                    CREATE FUNCTION foo() RETURNS integer AS '
        .....
' LANGUAGE plpgsql;
     

Partout au sein du corps de la fonction entouré de guillemets simples, les guillemets simples doivent aller par paires.

2 guillemets simples

Pour les chaînes de caractères à l'intérieur du corps de la fonction, par exemple :

une_sortie := ''Blah'';
SELECT * FROM utilisateurs WHERE f_nom=''foobar'';
     

Dans l'approche du guillemet dollar, vous devriez juste écrire :

une_sortie := 'Blah';
SELECT * FROM utilisateurs WHERE f_nom='foobar';
     

ce qui serait exactement ce que l'analyseur PL/pgSQL verrait dans les deux cas.

4 guillemets simples

Quand vous avez besoin d'un guillemet simple dans une chaîne constante à l'intérieur du corps de la fonction, par exemple :

                    une_sortie := une_sortie || '' AND nom LIKE ''''foobar'''' AND xyz''
     

La valeur effectivement concaténée à une_sortie est : AND nom LIKE 'foobar' AND xyz.

Dans l'approche du guillemet dollar, vous auriez écrit :

                    une_sortie := une_sortie || $$ AND nom LIKE 'foobar' AND xyz$$
     

Faites attention que chaque délimiteur en guillemet dollar ne soient pas simplement $$.

6 guillemets simples

Quand un simple guillemet dans une chaîne à l'intérieur du corps d'une fonction est adjacent à la fin de cette chaîne constante, par exemple :

                    une_sortie := une_sortie || '' AND nom LIKE ''''foobar''''''
     

La valeur effectivement concaténée à une_sortie est alors : AND nom LIKE 'foobar'.

Dans l'approche guillemet dollar, ceci devient :

                    une_sortie := une_sortie || $$ AND nom LIKE 'foobar'$$
     
10 guillemets simples

Lorsque vous voulez deux guillemets simples dans une chaîne constante (qui compte pour huit guillemets simples) et qu'elle est adjacente à la fin de cette chaîne constante (deux de plus). Vous n'aurez probablement besoin de ceci que si vous écrivez une fonction qui génère d'autres fonctions comme dans l'Exemple 42.10, « Portage d'une fonction qui crée une autre fonction de PL/SQL vers PL/pgSQL ». Par exemple :

                    une_sortie := une_sortie || '' if v_'' ||
    referrer_keys.kind || '' like ''''''''''
    || referrer_keys.key_string || ''''''''''
    then return ''''''  || referrer_keys.referrer_type
    || ''''''; end if;'';
     

La valeur de une_sortie sera alors :

                    if v_... like ''...'' then return ''...''; end if;
     

Dans l'approche du guillemet dollar, ceci devient :

                    une_sortie := une_sortie || $$ if v_$$ || referrer_keys.kind || $$ like '$$
|| referrer_keys.key_string || $$'
then return '$$  || referrer_keys.referrer_type
|| $$'; end if;$$;
     

où nous supposons que nous avons seulement besoin de placer des marques de guillemets simples dans une_sortie parce que les guillemets seront recalculés avant utilisation.

42.11.2. Vérifications supplémentaires à la compilation

Pour aider l'utilisateur à trouver les problèmes simples mais fréquents avant qu'ils ne posent de vrais problèmes, PL/PgSQL fournit des vérifications supplémentaires. Une fois activées, suivant la configuration, elles peuvent être utilisées pour émettre soit un WARNING soit un ERROR pendant la compilation d'une fonction. Une fonction qui a reçu un WARNING peut être exécutée sans produire d'autres messages, mais vous êtes averti de la tester dans un environnement de développement séparé.

Ces vérifications supplémentaires sont activées via les variables de configuration plpgsql.extra_warnings pour les messages d'avertissement et plpgsql.extra_errors pour les erreurs. Les deux peuvent être configurés soit avec une liste de vérifications séparées par des virgules, soit pour aucune ("none"), soit pour toutes ("all"). La valeur par défaut est "none". La liste actuelle des vérifications disponibles ne contient qu'un membre :

shadowed_variables

Vérifie si une déclaration cache une variable définie précédemment.

L'exemple suivant montre l'effet de plpgsql.extra_warnings configuré à shadowed_variables :

SET plpgsql.extra_warnings TO 'shadowed_variables';

CREATE FUNCTION foo(f1 int) RETURNS int AS $$
DECLARE
f1 int;
BEGIN
RETURN f1;
END
$$ LANGUAGE plpgsql;
WARNING:  variable "f1" shadows a previously defined variable
LINE 3: f1 int;
        ^
CREATE FUNCTION