PL/pgSQL : les bases

Création d’une fonction PL/pgSQL :

La déclaration de la fonction :

Cette méthode est valable quelle que soit la méthode d’accès à la base postgres. Il existe toutefois des outils graphiques (phppgadmin en mode web, pgadmin en client lourd) qui permettent d’alléger la syntaxe.

CREATE [OR REPLACE] FUNCTION nom_fonction([arg1],[arg2],...)
RETURNS integer AS $BODY$
<Code de la fonction >
$BODY$
LANGUAGE plpgsql;

Étudions en détail cette première partie :

  • La syntaxe pour créer une fonction est CREATE FUNCTION nom_fonction(arg1,arg2). Cette syntaxe va créer la fonction appelée nom_fonction, qui accepte en paramètres deux paramètres : arg1 et arg2. Si une fonction nom_fonction existe déjà avec les mêmes types de paramètres, un message d’erreur sera retourné. Si vous souhaitez alors remplacer cette fonction, il faudra écrire CREATE OR REPLACE nom_fonction(arg1,arg2)
  • Une fonction peut recevoir autant d’arguments que nécessaires. Les arguments peuvent être de n’importe quel type accepté par la base de données (y compris des types créés par l’utilisateur). Pour les versions de postgreSQL inférieures à 8, il ne faut noter que le type de paramètre (par exemple : create function nom_fonction(integer,integer) ), pour les versions supérieurs ou égales à la 8, on peut directement affecter un nom de variable : create function nom_fonction(arg1 integer,arg2 integer). Dans ce cas, les variables arg1 et arg2 seront implicitement déclarées dans la fonction, en prendront les valeurs données en arguments.
  • La mention RETURNS integer signifie que le retour de la fonction sera un entier. Une fonction peut retourner n’importe quel type supporté par la base de données, des tableaux, des enregistrements, plusieurs valeurs…

Le corps

Le corps d’une fonction PL/pgSQL est découpé en deux parties : les déclarations, et les instructions :

DECLARE
<bloc de déclarations>
BEGIN
<bloc d'instructions>
END;

 Les déclarations de variables

Voici un exemple type de déclarations :

id_utilisateur integer;
quantité numeric(5);
url varchar;
ma_ligne nom_table%ROWTYPE;
mon_champ nom_table.nom_colonne%TYPE;
une_ligne RECORD;
Dans cet exemple, la fonction comprendra 6 variables :
  • id_utilisateur, de type entier (integer)
  • quantite, de type numeric
  • url, de type varchar
  • ma_ligne, qui aura pour type un enregistrement de la table nom_table
  • mon_champ, qui aura pour type le type du champ nom_colonne de la tabe nom_table
  • une_ligne, qui sera de type record (nous verrons plus loin un exemple de type record)

Nous pouvons affecter directement des valeurs aux variables lors des déclarations :

quantité integer DEFAULT 32;
url varchar := 'http://mysite.com';
id_utilisateur CONSTANT integer := 10;

Dans ce cas :

  • quantite est un entier qui aura la valeur 32
  • url est un varchar qui aura la valeur http://mysite.com
  • L’utilisation de DEFAULT ou l’affection directe avec l’opérateur := aura le même effet
  • id_utilisateur est un entier constant, ayant la valeur 10. Toute tentative de modification de la variable id_utilisateur pendant le fonction entraînera une erreur.

Cas particulier des arguments

A partir de la version 8 de PostgreSQL, on peut définir directement le nom d’un argument dans la déclaration de la fonction :

CREATE OR REPLACE FUNCTION nom_fonction(arg1 integer, arg2 integer)

Dans ce cas, il ne faut pas inclure arg1 et arg2 dans le bloc de déclaration.

En revanche, si la déclaration de la fonction ne comprend pas les noms des arguments, il faut déclarer les variables avec la syntaxe nom_var alias for $x (nom_var étant le nom de la variable, x étant la position de l’argument en partant de la position 1) :

CREATE OR REPLACE FUNCTION nom_fonction(integer,integer)

Alors, dans le bloc de declaration, il faut ajouter :

arg1 alias for $1;
arg2 alias for $2;

Laisser un commentaire

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur comment les données de vos commentaires sont utilisées.