Stored Procedure Antonella Poggi Dipartimento di informatica e Sistemistica Sapienza Università di Roma Progetto di Applicazioni Software Anno accademico 2010-2011 Questi lucidi sono stati prodotti sulla base del materiale preparato per il corso di Progetto di Basi di Dati da D. Lembo e M. Ruzzi.
Stored procedure e User Defined Function Le stored procedure e le user defined function sono di fatto l estensione procedurale di SQL (di natura dichiarativo) Indipendentemente da come sono definite, la principale peculiarità delle stored procedure/user defined function è quella di poter essere invocate tramite comandi SQL oppure direttamente dalle applicazioni che interagiscono con il database (ad es., tramite JDBC) A. Poggi 1
Il linguaggio SQL/PSM Inizialmente, le stored procedure erano semplici programmi contenenti un singolo statement SQL, che risiedevano sul DBMS e che erano invocabili dai client A partire da SLQ 99, si è definito un vero e proprio linguaggio standardizzato per la definizione di stored procedure Secondo lo standard, i moduli persistenti (funzioni o procedure) possono essere definiti completamente in SQL, con comandi nel linguaggio standard SQL/PSM(Persistent Stored Modules), o utilizzando un diverso linguaggio di programmazione (e.g. Java) La maggior parte dei DBMS offre estensioni proprietarie e specifiche che vanno oltre lo standard A. Poggi 2
Utilità delle stored procedure Semplificano la comunicazione client-server Migliorano lo sviluppo favorendo il riuso del codice diversi client del DBMS (eventualmente scritti in linguaggi diversi ed eseguiti su diverse piattaforme) possono invocare le stesse stored procedure Possono essere usate per la gestione ed il controllo dell integrità dei dati Agevolano la definizione di politiche di controllo dell accesso, aumentando così la sicurezza Forniscono un mezzo di astrazione chi invoca la procedura può ignorare i dettagli implementativi sia della procedura che dello schema della base di dati A. Poggi 3
Nota importante Non si deve però cedere alla tentazione di inglobare tutta la logica dell applicazione nel DBMS tramite stored procedure: per applicazioni complesse questa strada non è percorribile! IMPORTANTE: le stored procedure non devono mai implementare funzionalità che non hanno direttamente a che fare con i dati A. Poggi 4
Definire Stored Procedure Una stored procedure deve avere un nome Può avere parametri, dove ogni parametro è una tripla che composta da: la modalità; esistono tre modalità differenti: IN: sono argomenti di ingresso per la procedura; al parametro deve essere assegnato un valore al momento dell invocazione della procedura che successivamente non viene cambiato; OUT: rappresenta l uscita della procedura che assegna loro i valori che l utente può utilizzare IN OUT: combinano le caratteristiche precedenti A. Poggi 5
il nome del parametro; il tipo SQL del parametro. N.B. Le stored procedure richiedono una conformità rigida ai tipi definiti nella dichiarazione. A. Poggi 6
Esempi di stored procedure Consideriamo due semplici casi di stored procedure. Stored procedure scritta in SQL: CREATE PROCEDURE AggiungiInventario( IN isbn CHAR(9), IN aggiungiqta INTEGER) UPDATE Libri SET qta_in_stock = qta_in_stock + aggiungiqta WHERE libro_isbn=isbn Stored Procedure scritta in Java: CREATE PROCEDURE AggiungiInventarioJava( IN isbn CHAR(9), IN aggiungiqta INTEGER) LANGUAGE Java EXTERNAL NAME file:///c:/procedureinterne/aggiungiinv.jar A. Poggi 7
Definire Stored Procedure in PSM La sintassi per dichiarare stored procedure è la seguente: CREATE PROCEDURE nome(par1,..., parn) codice procedura; La sintassi standard prevede ulteriori opzioni Noi vedremo direttamente la sua implementazione in MySQL A. Poggi 8
Esempio di dichiarazione di stored procedure in PSM Si vuole definire una stored procedure che prende in ingresso il nome di un cliente, identificato dal suo codice cliente cid e restituisce un punteggio così assegnato: i clienti che hanno comprato più di 10 libri ottengono il punteggio 2; i clienti che hanno comprato tra 5 e 10 libri ottengono 1; gli altri ottengono 0. A. Poggi 9
CREATE PROCEDURE calcolapunteggio (IN cid INTEGER, OUT punteggio INTEGER) BEGIN DECLARE numordini INTEGER; SET numordini = (SELECT COUNT(*) FROM Ordini O WHERE O.cid=cid); IF (numordini>10) THEN punteggio=2; ELSEIF (numordini>5) THEN punteggio=1; ELSEIF punteggio=0; ENDIF; END; A. Poggi 10
Invocare stored procedure Le stored procedure possono essere invocate dall interprete dei comandi (ad es., MySQL per MySQL, MSQL per Oracle) Attraverso l uso del comando CALL CALL nomestoredprocedure(arg1, arg2,..., arg3) da applicazione (ad es., tramite ODBC, JDBC, PHP) Lo vedremo più avanti A. Poggi 11
Esempio di invocazione di stored procedure Da un interprete dei comandi SQL, la stored procedure definita in precedenza può essere invocata, ad esempio, all interno di un altra stored procedure:... DECLARE punt INTEGER; CALL calcolapunteggio(21,punt);... A. Poggi 12
Definire user defined function in PSM Le funzioni sono un tipo particolare di stored procedure che: restituisce un singolo valore o una singola tabella non modifica lo stato del db è invocata come parte di un comando SQL (espressione) Sono definite tramite la seguente sintassi: CREATE FUNCTION nome(par1, par2,...,parn) RETURNS tiposql codice funzione; Secondo lo standard, non possono ricevere parametri di tipo OUT e IN OUT A. Poggi 13
Esempio di dichiarazione di user defined function in PSM Una funzione con semantica analoga alla procedura definita in precedenza è la seguente: CREATE FUNCTION calcolapunteggio (IN cid INTEGER) RETURNS INTEGER BEGIN DECLARE numordini INTEGER; DECLARE punteggio INTEGER; SET numordini = (SELECT COUNT(*) FROM Ordini O WHERE O.cid=cid); IF (numordini>10) THEN punteggio=2; ELSEIF (numordini>5) THEN punteggio=1; ELSEIF punteggio=0; ENDIF; RETURN punteggio; END; A. Poggi 14
Esempio di invocazione di user defined function La user defined function definita in precedenza può essere invocata, in un espressione SQL: DECLARE c INTEGER;... IF calcolapunteggio(c)=2 THEN INSERT INTO premi VALUE (c);... A. Poggi 15
Stored Procedures in MySQL RIFERIMENTO: MySQL 5.0 manual (capitolo 17) MySQL consente esclusivamente la definizione di stored procedure scritte in SQL Sotto altri punti di vista, Mysql prevede un estensione dello standard A. Poggi 16
Definire stored procedure e user defined function in MySQL Sintassi per definire stored procedure in MySQL: CREATE [DEFINER = { user CURRENT_USER }] PROCEDURE nome_proc ([par1,...,parn]) [<opzioni>] corpo per definire user defined function: CREATE [DEFINER = { user CURRENT_USER }] FUNCTION nome_func ([par1,...,parn]) RETURNS tipo [<opzioni>] corpo A. Poggi 17
l opzione DEFINER (non obbligatoria) è un estensione di Mysql che permette di specificare l utente creatore e perciò proprietario della stored procedure. La scelta di default è l utente corrente come nello standard, una procedura/funzione può essere caratterizzata da una lista di parametri costituiti da triple (<modalità> nome parametro <tipo sql>) A. Poggi 18
sempre in accordo con lo standard, una procedura o una funzione possono essere caratterizzate da diverse opzioni che sono: <opzioni>: COMMENT string LANGUAGE SQL [NOT] DETERMINISTIC SQL SECURITY { DEFINER INVOKER } {CONTAINS SQL NO SQL READS SQL DATA MODIFIES SQL DATA} dove: COMMENT è un estensione di MySQL che può essere usata per descrivere la stored procedure; LANGUAGE SQL indica che la procedura è scritta nel linguaggio SQL; ad oggi MySQL non permette di usare altri linguaggi (quindi SQL è il default). A. Poggi 19
DETERMINISTIC NOT DETERMINISTIC indica se, dato un certo input, una procedura restituisce sempre lo stesso risultato; MySQL non fa alcuna verifica sull effettivo determinismo di una stored procedure, ma, in alcune versioni, tiene conto di come è definita per applicare eventuali ottimizzazioni; di default, una procedura è definita come NOT DETERMINISTIC. SQL SECURITY indica se la procedura deve essere eseguita usando i privilegi dell utente che definisce o invoca la procedura. A. Poggi 20
l opzione CONTAINS SQL NO SQL READS SQL DATA MODIFIES SQL DATA fornisce un indicazione sul tipo di accesso ai dati SQL che fa la procedura CONTAINS SQL indica che la procedura contiene comandi SQL (e.g. SET, RELEASE-LOCK), ma non contiene istruzioni che scrivono o leggono dati sul/dal db questo è il default NO SQL indica che la procedura non contiene comandi SQL READS SQL DATA indica che la procedura contiene comandi SQL che leggono dati (e.g. SELECT) MODIFIES SQL DATA indica che la procedura contiene comandi SQL che scrivono dati (e.g. INSERT) N.B. Anche in questo caso MySQL non fa nessuna verifica sull effettivo contenuto della procedura. A. Poggi 21
il corpo consiste di un valido statement di procedura, ovvero un semplice statement SQL, come SELECT o INSERT un compound statement: [begin_label:] BEGIN [statement_list] END [end_label] Un compound statement può contenere dichiarazioni di variabili locali, loop e altri tipi di statement per strutture di controllo. Più avanti li vedremo uno per uno. A. Poggi 22
Stored procedure e ricorsione PSM vs. MySQL Al fine di permettere la definizione di routine ricorsive PSM prevede, attraverso l uso del comando ALTER ROUTINE, la possibilità di modificare stored procedure/user defined function. Al contrario, MySQL non permette la definizione di routine ricorsive Attraverso l uso del comando ALTER PROCEDURE (ALTER FUNCTION) è possibile modificare solamente le opzioni di una stored procedure (user defined function). Per modificare i parametri o il corpo di una routine, si deve prima cancellare la routine con il comando DROP PROCEDURE (DROP FUNCTION) e poi ridefinirla. A. Poggi 23
Stored Procedure in MySQL (esempio) CREATE PROCEDURE ex_proc (OUT numero_utenti INTEGER, INOUT incr_param INTEGER) BEGIN # Imposto il valore del parametro OUT SELECT count(*) INTO numero_utenti from mysql.user; # incremento il valore del parametro INOUT SET incr_param = incr_param + 1; END; Cosa fa questa procedura? A. Poggi 24
Invocare stored procedure in MySQL (esempio) mysql> SET @increment = 10; mysql> CALL ex_proc(@users, @increment); mysql> SELECT @users, @increment; +------------+------------+ @version @increment +------------+------------+ #utenti 11 +------------+------------+ A. Poggi 25
Statement SQL nel corpo di procedure PSM Gli statement che possono apparire nel corpo di una procedura possono essere di vario tipo: 1. normali statement SQL 2. DECLARE statement (a) per variabili (b) per handler (c) per cursori 3. statement di apertura/chiusura/fetch di un cursore 4. flow control statement IF, CASE, REPEAT, WHILE, LOOP, LEAVE, ITERATE A. Poggi 26
Dichiarazione di variabili nelle stored procedure E possibile dichiarare delle variabili all interno delle stored procedure DECLARE nome_var[,...] tipo_sql [DEFAULT valore] Le variabili cosi dichiarate sono locali alla procedura. A. Poggi 27
Impostazione di variabili nelle stored procedure Per impostare il valore di una variabile si utilizza il comando SET all interno della procedura SET nome_var = espr [, nome_var = espr]... Per prelevare il risultato di una query ed inserirlo in una variabile si usa il comando SELECT INTO SELECT nome_col[,...] INTO nome_var[,...] FROM claus_from [WHERE claus_where] A. Poggi 28
Uso delle variabili in MySQL (esempio) CREATE PROCEDURE sp1 (xname VARCHAR(5)) BEGIN DECLARE newname VARCHAR(5) DEFAULT bob ; DECLARE xid INTEGER; SELECT xname,id INTO newname,xid FROM table1 WHERE name = xname; SELECT newname; END; A. Poggi 29
Uso dei cursori Un cursore e un particolare tipo di variabile che permette di gestire le tuple restituite da una query. Dichiarazione di un cursore: DECLARE nome_cursore CURSOR FOR statement_select Apertura del cursore: OPEN nome_cursore Prelievo delle tuple successive: FETCH nome_cursore INTO nome_var [, nome_var]... Chiusura del cursore: CLOSE nome_cursore A. Poggi 30
Handlers Gli handlers permettono di definire il trattamento da eseguire a fronte del realizzarsi di una (o più condizioni). DECLARE tipo_handler HANDLER FOR val_condizione[,...] statement tipo_handler: CONTINUE EXIT UNDO val_condizione: SQLSTATE [VALUE] valore_sqlstate SQLWARNING NOT FOUND SQLEXCEPTION A. Poggi 31
Uso dei cursori: esempio CREATE PROCEDURE curdemo() BEGIN DECLARE done INT DEFAULT 0; DECLARE a CHAR(16); DECLARE b,c INT; DECLARE cur1 CURSOR FOR SELECT id,data FROM test.t1; DECLARE cur2 CURSOR FOR SELECT i FROM test.t2; DECLARE CONTINUE HANDLER FOR NOT FOUND SET done = 1; OPEN cur1; OPEN cur2; REPEAT A. Poggi 32
FETCH cur1 INTO a, b; FETCH cur2 INTO c; IF NOT done THEN IF b < c THEN INSERT INTO test.t3 VALUES (a,b); ELSE INSERT INTO test.t3 VALUES (a,c); END IF; END IF; UNTIL done END REPEAT; END CLOSE cur1; CLOSE cur2; A. Poggi 33
Controllo del flusso: IF-THEN-ELSE IF condizion_ricerca THEN lista_statement [ELSEIF condizione_ricerca THEN lista_statement]... [ELSE lista_statement] END IF A. Poggi 34
Controllo del flusso: CASE Ci sono due modi di utilizzare il costrutto CASE. 1. Nel modo classico, mediante il controllo sul valore di un operando: CASE operando_case WHEN valore THEN lista_statement [WHEN valore THEN lista_statement]... [ELSE lista_statement] END CASE A. Poggi 35
2. Oppure mediante una serie di condizioni: CASE WHEN condizione_ricerca THEN lista_statement [WHEN condizione_ricerca THEN lista_statement]... [ELSE lista_statement] END CASE questo secondo metodo è più generale in quanto permette di fare riferimento al valore di più operandi utile per rimpiazzare lunghe sequenze di IF-THEN-ELSE A. Poggi 36
Controllo del flusso: LOOP, LEAVE, ITERATE Sintassi del comando LOOP: [begin_label:] LOOP lista_statement END LOOP [end_label] E possibile dichiarare delle etichette (label) per identificare una certa istruzione di LOOP Per eseguire nuovamente il blocco di istruzioni del ciclo LOOP si utilizza il comando ITERATE ITERATE label Per uscire del ciclo, si usa il comando LEAVE LEAVE label A. Poggi 37
Esempio del controllo di flusso con LOOP in MySQL Esempio di utilizzo del comando LOOP: CREATE PROCEDURE iterazione(inout p1 INT) BEGIN label1: LOOP SET p1 = p1 + 1; IF p1 > 10 THEN LEAVE label1; END IF; END LOOP label1; SET @x = p1; END A. Poggi 38
Controllo del flusso: REPEAT e WHILE Sintassi del comando REPEAT [begin_label:] REPEAT lista_statement UNTIL condizione_ricerca END REPEAT [end_label] Sintassi del comando WHILE [begin_label:] WHILE condizione_ricerca DO lista_statement END WHILE [end_label] A. Poggi 39
Esempio del controllo di flusso con REPEAT CREATE PROCEDURE dorepeat(p1 INT) BEGIN SET @x = 0; REPEAT SET @x = @x + 1; UNTIL @x > p1 END REPEAT; END A. Poggi 40
Esempio del controllo di flusso con WHILE CREATE PROCEDURE ciclo-while() BEGIN DECLARE v1 INT DEFAULT 5; WHILE v1 > 0 DO... SET v1 = v1-1; END WHILE; END A. Poggi 41