Bases de données avancées PL/pgSQL

Transcription

1 Bases de données avancées PL/pgSQL Wies law Zielonka 19 mars 2015 Table des matières 1 Bloc de code 2 2 Déclaration de et initialisation de variables 2 3 Noms de variables. Les types %TYPE et %ROWTYPE 3 4 Noms de paramètres 4 5 IF et CASE IF CASE Plusieurs fonctions avec le même nom 6 7 Boucles Boucles et sortie d une boucle avec EXIT Boucles WHILE Boucles FOR, CONTINUE SELECT... INTO et la variable FOUND 9 9 Boucle FOR sur les résultats de SELECT Paramètres OUT Fonctions avec les types polymorphes Fonctions avec des types composés Les fonction retournant des tables RETURNS SETOF RETURNS TABLE Ajouter des éléments dans la table de résultats : RETURN QUERY et RETURN NEXT Exécuter le code SQL à l intérieur d une fonction EXECUTE pour exécuter les requêtes dynamiques Requête dynamiques dans une boucle FOR. 16 1

2 17 Utilisation de curseur Curseur liés à une requête FETCH MOVE OPEN/CLOSE Retourner le curseur Boucler sur le résultats d un curseur Curseur non liés Afficher des messages, lancer une exception 21 Résumé Ces notes ne sont pas corrigées (cela concerne surtout la qualité du français, le code a été vérifié). Mais peut-être vous les trouverez quand même utile pour préparer l examen ou projet. Ne pas distribuer. Les avantages de l utilisation PL/pgSQL : vitesse - code compilé une fois réside sur le serveur. 1 Bloc de code Le code est Structuré en bloc de code : [ <<label>> ] statements statements END En particulier le corps d une fonction est un bloc de code. 2 Déclaration de et initialisation de variables name [ CONSTANT ] type [ NOT NULL ] [ {DEFAULT := } value] CONSTANT variable non modifiable (read only), NOT NULL par défaut les variables initialisées avec la valeur NULL, Une fonction qui calcule la somme de ses deux arguement : add.sql CREATE FUNCTION add(integer, integer) RETURNS INTEGER AS $$ q INTEGER := 0; q := $1+$2; RETURN q; END $$ LANGUAGE plpgsql; Si on suppose qu une table tab possède des colonnes a, b, en utilisant cette fonction on pourra faire la requête SELECT sum(a,b) from tab; qui est équivalent select a+b from tab; 2

3 3 Noms de variables. Les types %TYPE et %ROWTYPE Pour plus de souplesse on peut déclarer de variables du même type que le type d un attribut ou un type d une table : nom_table.nom_colonne%type nom_de_table%rowtype On rappelle que est l opérateur de concaténation en SQL. La construction expression::type permet de faire un cast et changer le type d une expression concat.sql CREATE OR REPLACE FUNCTION concat(ingredients) RETURNS TEXT AS $$ a ingredients.name%type; b ingredients.unit%type; c ALIAS FOR $1; -- creation d un nom alias pour le parametre $1 x text; a := c.name; b := c.unit; x := (a )::CHAR(30) ; x := x b; RETURN x ; END -- Maintenant o peut faire -- SELECT concat(ingredients) FROM ingredients; -- ou -- SELECT concat(ingredients.*) FROM ingredients; -- Par contre SELECT concat(ingredients); ne marche pas CREATE OR REPLACE FUNCTION concat(a ingredients.name%type, b ingredients.unit%type) RETURNS TEXT AS $$ x text; x := a::char(30); x := x b; RETURN x ; END --select concat(name,units) from ingredients; changer_prix CREATE OR REPLACE FUNCTION changer_prix(f items.price%type, combien REAL ) RETURNS items.price%type AS toto items%rowtype; prix items.price%type DEFAULT 0; prix := f * combien; RETURN prix; END LANGUAGE plpgsql ;

4 select changer_prix(price,1.7),price FROM items WHERE price IS NOT NULL; 4 Noms de paramètres Les paramètres d une fonction sont nommés $1, $2,... etc. On peut donner les noms avec ALIAS et les renommer avec RENAME. nom ALIAS FOR old_name RENAME old_name TO new_name; Utile si les variable NEW et OLD dans les triggers. A noter que c est une déclaration alors à mettre dans addnumbers CREATE OR REPLACE FUNCTION addnumbers(integer, INTEGER) RETURNS INTEGER AS $$ Number_1 ALIAS FOR $1; Number_2 ALIAS FOR $2; RENAME $1 TO Orig_Number; RETURN Orig_Number + Number_2; $$ LANGUAGE plpgsql; Les paramètres peuvent être utilisés uniquement pour passer des données, jamais pour passer les noms de tables. Par exemple INSERT INTO mytable VALUES ($1); est correct mais INSERT INTO $1 VALUES (42); ne l est pas. 5 IF et CASE 5.1 IF IF condition THEN instructions [ ELSIF condition THEN instructions ] [ ELSIF condition THEN instructions ] [ ELSE instructions ] END IF; On peut faire de fonctions récursives, la fonction suivante calcule le factoriel my f actoriel(n) = n. Noter aussi l utilisation d un bloc interne avec son propre......end factorial.sql CREATE OR REPLACE FUNCTION my_factorial(value INTEGER) RETURNS INTEGER AS $$ arg INTEGER; arg := value; IF arg IS NULL OR arg < 0 THEN 4

5 RAISE NOTICE Invalid Number ; -- pour faire un affichage sur la console RETURN NULL; ELSE IF arg = 1 THEN RETURN 1; ELSE next_value INTEGER; next_value := my_factorial(arg - 1) * arg; RETURN next_value; END IF; END IF; CASE CASE search-expression WHEN expression [, expression [...]] THEN instrructions WHEN expression [, expression [...]] THEN instructions... [ ELSE instructions ] END CASE; search-expression est évaluée et comparée avec les expressions dans WHEN. Si search-epression = expression alors les instructions suivant WHEN correspondant sont exécutées. CASE x WHEN 1, 2 THEN msg:=msg+1; ELSE msg:=msg-1; END CASE; Une autre forme de CASE : CASE WHEN bool-expression THEN instrructions WHEN bool-expression THEN instructions... [ ELSE instructions ] END CASE; CASE WHEN w<0 THEN msg:= negatif ELSE msg:= positif ; END CASE; 5

6 Et troisième forme de CASE CASE WHEN bool-expression THEN expression WHEN bool-expression THEN expression... [ ELSE expression ] END CASE; L exemple précédent peut être réécrit comme : msg := CASE WHEN w<0 THEN negatif ELSE positif ; END CASE; 6 Plusieurs fonctions avec le même nom Comme Java PL/pgSQL supporte plusieurs fonctions avec le même nom si les signatures différentes. Pour supprimer une fonction définie par utilisateur on utilise : DROP FUNCTION nom-fonction(parametres); L exemple suivant définit trois fonctions qui portent le même nom compute_date.sql CREATE OR REPLACE FUNCTION compute_due_date(date) RETURNS DATE AS $$ declaration de variables due_date DATE; rental_period INTERVAL := 7 days ; due_date := $1 + rental_period; RETURN due_date; CREATE OR REPLACE FUNCTION compute_due_date(date, INTERVAL) RETURNS DATE AS $$ -- c est un commentaire dans une fonction RETURN( $1 + $2 ); -- SELECT compute_due_date(current_date,interval 1 MONTH ); CREATE OR REPLACE FUNCTION compute_due_date(dans INTERVAL) RETURNS DATE AS $$ RETURN current_date + dans; END -- select compute_due_date(interval 3 months ); Boucles 7.1 Boucles et sortie d une boucle avec EXIT Boucle infinie : 6

7 insctructions On termine cette boucle par RETURN ou EXIT. La forme générale de EXIT : EXIT [ etiquette ] [ WHEN expression-boolenne ] ; EXIT déplace le contrôle après la boucle. On peut étiqueter les boucles par <<etiquette>> ce qui permet de terminer les boucles imbriquées par EXIT <<etiquette>>; Donc EXIT fait la même chose que break en C. x:=x+1; IF x>10 THEN EXIT; END IF; x:=x+1; EXIT WHEN x>10; <<toto>> x:=x+1; y:=y-1; EXIT toto WHEN y<x; 7.2 Boucles WHILE WHILE condition instructions 7.3 Boucles FOR, CONTINUE [ <<etiquatte>> ] FOR iterator IN [ REVERSE ] expression1.. expression2 [ BY expr ] instructions END ; La variable iterator est automatiquement déclarée comme une variable de type INTEGER (pas besoin de la déclarer nous même). Dans la version avec une étiquette iterator peut-être préfixée par l étiquette. Quelques exemples : FOR I IN I Prendra les valeurs 1,2,...,10 FOR I IN REVERSE I Prendra les valeurs 10,9,8,7,...,1 7

8 FOR I IN REVERSE BY 2 --I prendra les valeurs 10,8,6,4,2 <<toto>> FOR i IN 1..n k:=k * toto.i; Dans l exemple suivant la deuxième boucle for n affiche rien et la première affiche une suite de messages i = 10,i = 9 etc. : create or replace function add() returns void as $$ declare i int; c varchar; begin for i in reverse loop c := to_char(i, 999 ); raise notice i=%, i; end loop; for i in loop raise notice i=%,i; end loop; end $$ language plpgsql; Noter l ordre de bornes inférieure et supérieure dans REVERSE, il est l inverse à celui de PL/SQL d ORACLE. create or replace function add(int) returns void as $$ declare i int; c varchar; begin for i in reverse $1..1 loop c := to_char(i, 999 ); raise notice i=%, i; end loop; --for i in loop -- raise notice i=%,i; --end loop; end $$ language plpgsql; CONTINUE à l intérieur de la boucle aura le même effet qu en langage C, on retourne au début de la boucle. La forme générale : CONTINUE [ etiquette ] [ WHEN expression-booleenne ]; new_factorial.sql CREATE OR REPLACE FUNCTION new_factorial(i INTEGER) RETURNS INTEGER AS $$ k INTEGER := 1; -- IF IF i <= 0 THEN RETURN 0; END IF; 8

9 -- Boucle for indexee par variable INTEGER. -- La variable qui indexe la boucle (L) est de type INTEGER. -- Inutile de la declarer (meme il ne faut pas la declarer). -- S il y a deja une variable L declaree dans le bloc externe -- cette anciene variable sera invisible a l interieur de la boucle. FOR L IN 1..i k := k*l; RETURN k; END SELECT... INTO et la variable FOUND On peut récupérer le résultat d une requête SELECT grâce au SELECT... INTO... : SELECT liste-select INTO destination FROM...; La requête SELECT ne doit pas retourner plus qu une ligne ou une valeur. destination après INTO est une variable ou une liste de variables dans lesquelles postgres mettra le résultat de SELECT. Avec FOUND on pourra vérifier si la requête a effectivement retourné une ligne ou non into.sql CREATE OR REPLACE FUNCTION intot(ingredients.ingredientid%type) RETURNS ingredients.unit%type AS $$ a ingredients%rowtype; --Declaration d une variable du type: --ligne de la table ingredients -- Maintenant on peut faire SELECT dans a: SELECT * INTO a FROM ingredients WHERE $1 = ingredients.ingredientid ; IF FOUND THEN --FOUND est TRUE si le select --a trouve des lignes RETURN a.unit; ELSE RETURN unknown ; END IF; Destination peut-être une liste de variables : intob.sql CREATE OR REPLACE FUNCTION intot(ingredients.ingredientid%type) RETURNS TEXT AS $$ a ingredients.unit%type; b ingredients.name%type; SELECT ingredients.unit, ingredients.name INTO a,b FROM ingredients WHERE $1 = ingredients.ingredientid ; IF FOUND THEN RETURN a b ; ELSE RETURN unknown ; 9

10 END IF; -- select intot( CHESE ); 9 Boucle FOR sur les résultats de SELECT. Une boucle for pour le parcours des résultats d une requête SELECT. La variable iterator doit être soit de type RECORD soit %ROWTYPE [<<label>>] FOR iterator IN requete-select instructions forin.sql CREATE OR REPLACE FUNCTION forin(a ingredients.unit%type) RETURNS DECIMAL(5,3) AS $$ toto RECORD; -- noter une variable de type RECORD prix ingredients.unitprice%type; s REAL DEFAULT 0; -- initialisation avec DEFAULT i INTEGER := 0 ; -- initialisation avec := FOR toto IN SELECT name, unitprice FROM ingredients WHERE unit = a s := s + toto.unitprice; i := i + 1 ; IF i = 0 THEN RETURN 0; END IF; RETURN (s/i) :: DECIMAL(5,3) ; --noter un cast -- SELECT forin( slice ); -- retourne le prix moyen par unite de slice (tranche) A la place d une requête SELECT on peut mettre INSERT, UPDATE, DELETE avec une clause RETURNING. 10 Paramètres OUT Certains paramètres peuvent être déclarés OUT, c est-à-dire comme de paramètres de sortie. La dernière valeur affectée sur un paramètres OUT sert de la valeur de sortie sum_n_product CREATE OR REPLACE FUNCTION sum_n_product(x int, y int, OUT sum int, OUT prod int) AS $$ sum := x + y; prod := x * y; $$ LANGUAGE plpgsql;

11 Si on utilise RETURN dans cette fonction elle devra retourner RECORD. La fonction sum_n_product peut-être utilisée comme SELECT sum_n_product(a,b) from tab; (on suppose que a, b sont deux attributs de la table tab. Si nous voulons accéder à juste un paramètre OUT on utilise la syntaxe suivante : SELECT (sum_n_product(a,b)).sum from tab; ou select sum((sum_n_product(a,b))) from tab; 11 Fonctions avec les types polymorphes Les paramètres d une fonction peuvent être déclarés en utilisant les types polymorphes : anyelement, anyarray, anynonarray, anyenum. Nous n utiliserons que anyelement. Dans la fonction add_three_values CREATE FUNCTION add_three_values(v1 anyelement, v2 anyelement, v3 anyelement) RETURNS anyelement AS $$ result ALIAS FOR $0; result := v1 + v2 + v3; RETURN result; $$ LANGUAGE plpgsql; anyelement désigne le type quelconque (à condition que l addition soit supportée par ce type) mais tous les trois arguments et la valeur retournée doivent être du même type (c est-à-dire quelconque mais le même). Une fonction dont le type de retour est polymorphe possède une variable ( le paramètre ) $0, initialisée NULL, qui permet de stocker la valeur à retourner. Sinon $0 est utilisé comme tous les autres $i. 12 Fonctions avec des types composés create emp CREATE TABLE emp ( name text, salary numeric, age integer, cubicle point ); double_salary CREATE FUNCTION double_salary(emp) RETURNS numeric AS $$ SELECT $1.salary * 2 AS salary; $$ LANGUAGE SQL; Dans la fonction ci-dessus le paramètre emp de la fonction signifie que la fonction prend en paramètre une ligne (un record) avec les même types qu une ligne de la table emp. La fonction est ensuite utilisée comme SELECT name, double_salary(emp.*) AS dream FROM emp WHERE emp.cubicle ~= point (2,1) ; Si une fonction retourne un type composé alors pour accéder aux champs on utilise une de deux syntaxes : SELECT (new_emp()).name; SELECT name(new_emp()); 11

12 La notation fonctionnelle peut être aussi utilisée avec les noms d attributs d une table : toto.prix c est la même chose que prix(toto) pour une table toto. Si une fonction retourne un type composé elle peut être utilisée partout où on utilise de tables, par exemple dans FROM (ceci est vrai aussi pour les valeurs scalaires mais dans ce cas peu utile). 13 Les fonction retournant des tables Il y a deux manière à déclarer qu une fonction retourne une table, soit en utilisant RETURNS SETOF type soit avec RETURNS TABLE(nom1 type1,...,nomn typen) La table de résultat est construite avec les appels à RETURN QUERY et/ou RETURN NEXT comme explique le chapitre RETURNS SETOF Une fonction qui retourne une table déclare la valeur de retour comme RETURNS SETOF sometype Dans l exemple suivant on suppose qu il existe la table nommée ingredients. Donc la fonction commander() retourne une table dont chaque ligne a exactement le même type qu une ligne de la table ingredients. On suppose que la table ingredients possède l attribut inventory commander le parametre ingredients ci-dessous indique juste que $1 devait ^etre du m^eme type -- que la table ingredients CREATE OR REPLACE FUNCTION commander() RETURNS SETOF ingredients AS $$ -- le select suivant peut retourner plusieurs lignes. -- Sans SETOF le select retourne une seule ligne. RETURN QUERY SELECT * FROM ingredients WHERE inventory = 0 OR INVENTORY IS NULL; END ; $$ LANGUAGE plpgsql; Dans l exemple précédent on peut aussi écrire RETURNS SETOF ingredients%rowtype à la place RETURNS SETOF ingredients. Si le type de retour de la fonction n existe pas on peut le créer avec CREATE TYPE. Dans l exemple suivant on commence par créer un type doubleint qui représente une ligne avec deux valeurs de type integer. Ensuite on définit une fonction retournant une table dont chaque ligne est composée de deux valeurs integer. Dans cet exemple on suppose qu il existe une table tab avec les attributs a,b,c de type int ajouterunsetof() create type doubleint as (x integer, y integer); drop function ajouterunsetof(); create or replace function ajouterunsetof() returns setof doubleint as $$ declare r record; begin for r in select * from tab where a is not null loop return next (r.a+1,r.b+1); --ceci ajoute une ligne dans la table de resultats end loop; return; end $$ language plpgsql; RETURNS TABLE La fonction suivante retourne une table avec les attributs nom et prix modifier_prix DROP FUNCTION modifier_prix(numeric(10,2)) ; CREATE OR REPLACE FUNCTION modifier_prix(numeric(10,2)) 12

13 RETURNS TABLE(nom items.name%type, prix items.price%type) AS $$ RETURN QUERY SELECT name, price * $1 FROM items ; END ; $$ LANGUAGE plpgsql; Ajouter des éléments dans la table de résultats: RETURN QUERY et RETURN NEXT Les fonctions qui retournent une table doivent construire la table de résultat avant de terminer. Au début la table de résultats est vide. On ajoute les tuples dans cette table en utilisant une des instructions suivantes : RETURN NEXT expression; RETURN QUERY requete; RETURN QUERY EXECUTE string-req [ USING expression [,...] ]; Ces trois formes de RETURN ne terminent pas l exécution de la fonction mais servent à ajouter des tuples dans la table des résultats. La fonction termine si on exécute RETURN sans paramètre ou si l exécution arrive à la dernière instruction de la fonction. En terminant la fonction retourne la table construite. RETURN NEXT expression; ajoute un tuple de résultat expression dans la table des résultats. Cette forme est utilisée dans les fonctions avec RETURN SETOF type. Le type de l expression doit correspondre au type indiqué dans RETURN SETOF type, voir la fonction ajouterunsetof() dans le chapitre Dans les fonction avec RETURNS TABLE(...) on utilise plutôt RETURN NEXT sans expression. Dans la fonction ajouterun() ci-dessous RETURN NEXT; n est pas suivi d une expression. Ce sont les valeurs actuelles de paramètres x et y qui sont utilisées pour ajouter la ligne (x,y) dans la table de résultats au moment uù RETURN NEXT est exécuté. Donc les d attributs de la table de résultat sont utilisés dans la fonction comme de variables locales. Dans cet exemple on suppose que la Base de Données contient une table tab avec les attributs a,b (et peut-être d autres attributs) ajouterun() create or replace function ajouterun() returns table(x integer, y integer) as $$ declare r record; begin for r in select * from tab where a is not null loop x:=r.a+1; y:=r.b+1; return next; --ceci ajoute (x,y) dans la table de resultats end loop; return; end $$ language plpgsql; Ensuite nous pouvons utiliser cette fonction comme dans ici : select * from ajouterun() as t, tab where t.x=tab.a; RETURN QUERY ajoute les résultats d une requête dans la table des résultats. La fonction suivante fait exactement la même chose que la fonction ajouterun() de l exemple précédent en ajoutant un tuple chaque fois : ajouterunbis() create or replace function ajouterunbis() returns table(x integer, y integer) as $$ 13

14 declare r record; begin for r in select * from tab where a is not null loop return query values(r.a+1,r.b+1) ; --ceci ajoute un tuple (r.a+1,r.b+1) -- dans la table de resultats. end loop; return; end $$ language plpgsql; Mais on peut faire la même chose sans boucle : ajouteruntiers() create or replace function ajouteruntiers() returns table(x integer, y integer) as $$ begin return query select a+1,b+1 from tab where a is not null; return; end $$ language plpgsql; Dans la version RETURN QUERY EXECUTE la requête SELECT se trouve dans une chaîne de caractères string-reg. Cette chaîne peut contenir des occurrences de caractère % qui seront remplacées par les valeurs des expressions qui se trouvent après USING. C est RETURN sans paramètre qui termine la fonction et retourne la table construite grâce au RETURN NEXT et RETURN QUERY. 14 Exécuter le code SQL à l intérieur d une fonction Nous pouvons mettre le code SQL directement dans les fonctions PL/pgSQL : CREATE TABLE, INSERT, UPDATE, DELETE, etc. sauf SELECT et sauf l appel à une autre fonction si le résultat de SELECT ou de l appel n est pas récupéré. Si on veut exécuter SELECT sans récupération de résultat on fera PERFORM requete-select ; comme dans PERFORM * FROM ingredients WHERE unitprice < 5; Noter que PERFORM remplace le mot SELECT. PERFORM peut être utilisé pour évaluer une expression SQL sans récupération de résultat, par exemple PERFORM fonction(parametres); Après PERFORM on pourra tester la variable FOUND pour voir si la requête a produit un résultat ou si elle a retourné NULL. Si on utilise PERFORM c est pour les effets de bord de la requête et non pas pour la valeur retournée (la valeur on l ignore sciemment) ajouter_meal() CREATE OR REPLACE FUNCTION ajouter_meal( meals.mealid%type, meals.name%type) RETURNS INTEGER AS $$ id ALIAS FOR $1; nom ALIAS FOR $2; a INTEGER; -- si a la place de l instruction suivante on ecrit -- SELECT * FROM meals WHERE mealid=id; 14

15 -- cela compile OK mais probleme a l execution. a := add(5,6); PERFORM add(7,8); PERFORM * FROM meals WHERE mealid=id; IF FOUND THEN RETURN 0; END IF; INSERT INTO meals VALUES(id,nom); RETURN 1; EXECUTE pour exécuter les requêtes dynamiques. EXECUTE command-string; permet d exécuter une requête contenue dans une chaîne de caractères. Cela permet de faire de requêtes dynamiques qui ne sont pas precompilées. Quelques exemples : exect.sql CREATE OR REPLACE FUNCTION exect(commande VARCHAR) RETURNS INTERVAL AS $$ beg_time TIMESTAMP; end_time TIMESTAMP; beg_time := current_timestamp; EXECUTE commande; end_time := current_timestamp; RETURN end_time - beg_time; END --SELECT exect( SELECT * FROM ingredients ); modif_prix CREATE OR REPLACE FUNCTION modif_prix(varchar(30), DEC(5,2), DEC(6,2)) RETURNS SETOF ingredients AS $$ qui ALIAS FOR $1; plus ALIAS FOR $2; pcent ALIAS FOR $3; val ingredients.unitprice%type; tal ingredients.unitprice%type; r RECORD; u RECORD; FOR r IN EXECUTE SELECT * FROM ingredients WHERE qui val := r.unitprice * ( pcent )/100 ; tal := r.unitprice + plus; IF val > tal THEN u := ROW( r.ingredientid, r.name, r.unit, val, r.foodgroup, r.inventory, r.vendorid )::ingredients; RETURN NEXT u; ELSE u := ROW( r.ingredientid, r.name, r.unit, tal, r.foodgroup, r.inventory, r.vendorid )::ingredients; RETURN NEXT u; END IF; RETURN; 15

16 $$ LANGUAGE plpgsql; test_modif_prix SELECT I.name, I.unitprice, AUG.unitprice FROM ingredients I JOIN modif_prix( foodgroup= Milk, 0.05, 5) AS AUG USING(ingredientid) ; Forme générale de EXECUTE : EXECUTE command-string [ INTO [ STRICT ] target ] [ USING expression,...] ] ; command-string de type text. target est une variable de type RECORD, ou une variable de type ROWTYPE ou une liste de variables simples. Le résultat de la requête sera stocké dans ces variables. Si la requête retourne plusieurs lignes alors c est la première ligne qui sera stockée dans le(s) variable(s) INTO. Avec STRICT il aura une erreur si la requête retourne plusieurs lignes. command-string peur avoir des paramètres, $1, $2,... qui seront substitués par les valeurs calculées dans USING. Cela ne concerne que les paramètres, $1,... ne concerne pas les noms de tables qui doivent être injectés comme les chaînes de caractères. On peut utiliser les fonction quote_lireal quote_ident quote_nullable. quote_indent(text) retourne une chaîne de caractères avec des pour l utilisation comme identificateur.* quote_literal(text) pour que approprié comme string-literal. Elle retourne NULL si l argument NULL. Si on veut NULL pour l argument NULL il faut utiliser quote_nullable(text). 16 Requête dynamiques dans une boucle FOR. [<<label>>] FOR iterator IN EXECUTE string-requete [ USING expression,... ] instructions string-requete s évalue comme une chaîne de caractères contenant une requête SELECT. Exemples : somme2.sql CREATE OR REPLACE FUNCTION somme2(req VARCHAR) RETURNS REAL AS $$ toto REAL := 0; -- noter une variable de type RECORD s REAL DEFAULT 0; -- initialisation par DEFAULT FOR toto IN EXECUTE req s := s + toto; RETURN s; --SELECT somme2( SELECT unitprice FROM ingredients ); somme_square.sql CREATE OR REPLACE FUNCTION somme_square(tables text, col text) RETURNS REAL AS $$ toto REAL := 0; -- noter une variable de type RECORD s REAL DEFAULT 0; -- initialisation par DEFAULT 16

17 FOR toto IN EXECUTE SELECT quote_ident(col) FROM quote_ident(tables) s := s + toto*toto; RETURN sqrt(s); select somme_square( ingredients, unitprice ); Encore un exemple qui calcule la déviation. Par définition une déviation d un ensemble de n valeurs : x 1,...,x n est égale à 1 n n i=1 (xi x) où x = 1 n n i=1xi est la moyenne. Le paramètres de la fonction : t - le nom de la table, col le nom de la colonne, cond - une condition à mettre dans WHERE. So cond est NULL alors il n y aura par WHERE dans SELECT : deviation() drop function deviation(varchar,varchar,varchar); create or replace function deviation(t varchar, col varchar, cond varchar) returns real as $$ declare s real; sq real; i integer; r real; sigma real; m varchar; x varchar; d int := 5; begin s:=0; i:=0; sq:=0; m:= case when cond is null then else where cond end ; -- case peut etre remplace par IF: -- IF cond is null then -- m:= ; -- else -- m:= where cond; -- end if; for r in execute select col from t m loop if r is not null then s=s+r; sq=sq+r*r; i=i+1; end if; end loop; sigma:=sq/i-(s/i)*(s/i); return sigma; end $$ language plpgsql; Dans cet exemple on pourrait utiliser EXECUTE... USING : for r in execute select $1 from t m USING col loop... 17

18 end loop; Noter qu il est impossible de mettre le nom de la table dans USING, uniquement les données. 17 Utilisation de curseur. Pour travailler avec le curseur :, OPEN, FETCH, CLOSE Une fonction peut retourner un curseus et l appelant peut l utiliser pour parcourir la table de résultat. C est moyen efficace pour retourner un enseble de lignes d une table Curseur liés à une requête Déclaration dans la partie d un bloc : nom_cursor CURSOR FOR requete_select ; nom_cursor [ [NO] SCROLL] CURSOR(parametres_formelles) FOR requete_select ; déclarent des curseur liés. SCROLL indique qu on pourra faire un parcours en arrière sur le résultat. Paramètres formelles est une liste de couples nom type_de_donnee. Exemples : curs1 refcursor; --curseur non lie curs2 CURSOR FOR SELECT * FROM tenk1; curs3 CURSOR (key integer) IS SELECT * FROM tenk1 WHERE unique1 = key; Toutes les trois variables sont de type refcursor mais les deux dernières sont liées à des requêtes. De plus curs3 possède un paramètre key de type INTEGER FETCH Pour récupérer les valeurs faire dans une boucle : FETCH [ direction {FROM IN} ] nom_cursor INTO destinations(s) ; où destination(s) une variable RECORD ou une variable %ROWTYPE ou une liste de variables. Ici un exemple qu on aurait pu faire avec FOR. Noter EXIT WHEN NOT FOUND; qui permet de tester si le parcours est fini. Si rien à lire destination prendra la valeur NULL. Les directions NEXT ligne suivante, PRIOR ligne précédente, FIRST la première ligne, LAST la dernière ligne, ABSOLUTE numero ligne numero à partir du début, RELATIVE numero linge numero à partir de la position courante du curseur. Dans ce cas l argument numero peut-être négatif. permettent de récupérer une seule ligne (éventuellement NULL). Les directions ALL FORWARD FORWARD nombre FORWARD ALL BACKWARD BACKWARD nombre BACKWARD ALL permettent de récupérer le nombre de lignes indiqué à partir de la position courante, soit en avant soit en arrière. Ces directions ne font pas partie du standard SQL (ce sont des extension de postgres). FETCH sans direction est équivalent à FETCH NEXT 17.3 MOVE MOVE [ direction { FROM IN } ] cursor; déplace le curseur mais ne retourne pas de résultat. 18

19 17.4 OPEN/CLOSE Pour ouvrir un curseur lié avec les paramètres : OPEN nom_cursor(parametres_actuels); Pour fermer un curseur non utilisé faire : CLOSE cursor; curs.sql CREATE OR REPLACE FUNCTION curs(ingredients.unitprice%type, ingredients.unitprice%type) RETURNS REAL AS $$ -- declaration d un cursor toto CURSOR FOR SELECT * FROM ingredients WHERE unitprice BETWEEN $1 AND $2; resultat RECORD; s REAL DEFAULT 0; -- initialisation par DEFAULT OPEN toto; -- ouvrir le cursor FETCH toto INTO resultat; -- fetch une ligne dans un record EXIT WHEN NOT FOUND; -- Plus rien a lire alors quitter la boucle s := s + resultat.unitprice * resultat.unitprice ; CLOSE toto; -- fermer le cursor RETURN s; --SELECT curs(0.01,0.03); Les curseur utilisent des ressources de système (la mémoire pour la table parcourus par le curseur). Si le curseur n est plus utilisé il est recommander de le fermer Retourner le curseur Un fonction peut retourner le curseur (la fonction RETURNS refcursor). Il faut d abord associer un nom avec le curseur avant OPEN. Pour cela on fait une affectation d une chaîne de caractères sur la variable curseur. Cette chaîne de caractère c est le nom de curseur.(mais ce nom peut être généré automatiquement, donc il n est pas nécessaire d associer un nom au curseur.) Exemple suivant montre comment l appelant passe le nom de curseur vers la fonction, c est le plus simple puisque autrement l appelant devrait trouver le nom de curseur autrement. CREATE TABLE test (col text); INSERT INTO test VALUES ( 123 ); CREATE FUNCTION reffunc(refcursor) RETURNS refcursor AS $$ OPEN $1 FOR SELECT col FROM test; RETURN $1; $$ LANGUAGE plpgsql; ; SELECT reffunc( funccursor ); FETCH ALL IN funccursor; COMMIT; 19

20 17.6 Boucler sur le résultats d un curseur [ <<label>> ] FOR recordvar IN bound_cursorvar [ ( argument_values ) ] statements END [ label ]; Cela concerne uniquement le curseurs liés, le curseur ne peut pas être ouvert à ce moment. La variable recordvar est automatiquement déclarée comme record et existe seulement dans la boucle Curseur non liés On peut déclarer un curseur qui ne sera pas associé à une requête. Le curseur de ce type est déclaré comme une variable de type refcursor : mon_cursor refcursor; Si nous avons un curseur non lié alors au moment de faire OPEN on spécifie la requête SELECT : OPEN mon_cursor_non_lie [[NO] SCROLL] FOR requ^ete; pour une requête fixe ou OPEN mon_cursor [[ NO ] SCROLL ] FOR EXECUTE string-requ^ete; pour une requête dynamique. Ensuite nous pouvons utiliser le curseur pour parcourir les résultats de la requête. L exemple précédent réécrit pour utiliser les curseurs non liés : curspd.sql CREATE OR REPLACE FUNCTION curspd() RETURNS VOID AS $$ -- declaration des cursor non lies vendor refcursor; ingr refcursor; resultat RECORD; val ingredients%rowtype; I INTEGER; OPEN vendor FOR SELECT * FROM vendors; -- ouvrir le cursor FETCH vendor INTO resultat; -- fetch une ligne de vendors dans un record EXIT WHEN NOT FOUND; -- Plus rien a lire alors quitter la boucle I := 0; OPEN ingr FOR SELECT * FROM ingredients WHERE resultat.vendorid = ingredients.vendorid; --boucle interne FETCH ingr INTO val; --fetch une ligne EXIT WHEN NOT FOUND; I := I+1; CLOSE ingr; --fermer cursor IF I > 2 THEN RAISE NOTICE bon vendor %, resultat.repfname; ELSE RAISE NOTICE mauvais vendor %, resultat.repfname; 20

21 END IF; --fin boucle externe CLOSE vendor; -- fermer le cursor RETURN ; utilisation: --SELECT curspd(); L exemple suivant présente une fonction qui calcule la médiane de valeurs d une colonne. Le nom de la table et le nom de la colonne passent comme les paramètres de la fonction median() create or replace function median(tab varchar, col varchar) returns real as $$ declare c refcursor; i integer; r real; begin open c SCROLL for execute select col from tab where col is not null ORDER BY col; i:=0; move next from c ; exit when not found; i:=i+1; end ; FETCH absolute (i+2)/2 FROM c into r; close c; return r; end $$ language plpgsql; Afficher des messages, lancer une exception Pour afficher des messages on utilise : RAISE NOTICE message [,variable..]; Le message peut contenir les % dont les occurrences sont substituées par les variables de la liste cursp.sql CREATE OR REPLACE FUNCTION cursp() RETURNS VOID AS $$ -- declaration d un cursor simple vendor CURSOR FOR SELECT * FROM vendors; -- declaration d un cursor parametre ingr CURSOR(ID ingredients.vendorid%type) FOR SELECT * FROM ingredients WHERE ID = ingredients.vendorid; resultat RECORD; 21

22 val ingredients%rowtype; I INTEGER; OPEN vendor; -- ouvrir le cursor FETCH vendor INTO resultat; -- fetch une ligne de vendors dans un record EXIT WHEN NOT FOUND; -- Plus rien a lire alors quitter la boucle I := 0; OPEN ingr(resultat.vendorid) ; --boucle interne FETCH ingr INTO val; --fetch une ligne EXIT WHEN NOT FOUND; I := I+1; CLOSE ingr; --fermer cursor IF I > 2 THEN RAISE NOTICE bon vendor %, resultat.repfname; ELSE RAISE NOTICE mauvais vendor %, resultat.repfname; END IF; --fin boucle externe CLOSE vendor; -- fermer le cursor RETURN ; utilisation: --SELECT cursp(); Pour lancer une exception on utilise : RAISE EXCEPTION format [,expression [,...]] [ USING option = expression [,...]] ; Il y a plusieurs option possibles, en particulier, par exemple USING ERRCODE= indique le code d erreur. Les codes d erreur existant sont spécifiés dans la documentation de postgres. Si il y a une exception pendant l exécution d une fonction alors PLpgSQL fait automatiquement ROLLBACK jusqu au début du bloc. 22