35.2. 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 recharger le fichier seulement 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 tourne, vous pouvez charger ou recharger de telles définitions de fonction avec

\i nom_fichier.sql

et alors 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 PgAccess, 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.

35.2.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. 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.2). 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 pourriez é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 pourriez 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 2 guillemets simples dans une chaîne constante (qui compte pour 8 guillemets simples) et qu'elle est adjacente à la fin de cette chaîne constante (2 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 35-6. 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 de guillemets simples dans une_sortie parce que les guillemets seront recalculés avant utilisation.

Une approche différente est d'échapper les guillemets du corps de la fonction avec un antislash plutôt qu'en les doublant. Avec cette méthode, vous vous verrez écrire des choses telles que \'\' au lieu de ''''. Certains trouveront ceci plus lisible, d'autres non.