Come forse saprai in tutte le versioni fino a PostgreSQL 10, non è stato possibile creare una procedura in PostgreSQL. In PostgreSQL 11, PROCEDURE è stato aggiunto come un nuovo oggetto schema che è un oggetto simile a FUNCTION, ma senza un valore di ritorno.
Nel corso degli anni molte persone erano ansiose di avere la funzionalità ed è stata finalmente aggiunta in PostgreSQL 11. Tradizionalmente, PostgreSQL ha fornito tutti i mezzi per scrivere funzioni (che erano chiamate procedure memorizzate), tuttavia, in una funzione non è possibile eseguire transazioni. Tutto ciò che puoi davvero usare sono le eccezioni, che sono fondamentalmente dei punti di salvataggio. All'interno di un corpo di funzione non puoi semplicemente eseguire il commit di una transazione o aprirne una nuova. La nuova CREATE PROCEDURE cambierà tutto questo e fornirà una funzionalità per eseguire transazioni all'interno del codice procedurale.
Vantaggi dell'utilizzo delle stored procedure
- Controllo delle transazioni che ci consente di IMPEGNO e ROLLBACK all'interno delle procedure.
- Molto utile per la migrazione da Oracle a PostgreSQL, la nuova funzionalità della procedura può far risparmiare molto tempo.
- Come puoi vedere, ci sono un paio di somiglianze tra CREATE FUNCTION e CREATE PROCEDURE, quindi le cose dovrebbero essere davvero facili per la maggior parte degli utenti finali.
Come utilizzare la stored procedure in PostgreSQL
Usa CREATE PROCEDURE per creare una nuova procedura in PostgreSQL 11, ti consentirà di scrivere la procedura proprio come altri database. PROCEDURE è quasi la stessa di FUNCTION senza un valore di ritorno. PROCEDURE viene creato con l'istruzione CREATE PROCEDURE in PostgreSQL 11. A differenza dell'istruzione CREATE FUNCTION, non ci sono clausole RETURNS, clausole ROWS ecc.
Sintassi
postgres=# \h CREATE PROCEDURE
Command: CREATE PROCEDURE
Description: define a new procedure
Syntax:
CREATE [ OR REPLACE ] PROCEDURE
name ( [ [ argmode ] [ argname ] argtype [ { DEFAULT | = } default_expr ] [, ...] ] )
{ LANGUAGE lang_name
| TRANSFORM { FOR TYPE type_name } [, ... ]
| [ EXTERNAL ] SECURITY INVOKER | [ EXTERNAL ] SECURITY DEFINER
| SET configuration_parameter { TO value | = value | FROM CURRENT }
| AS 'definition'
| AS 'obj_file', 'link_symbol'
} ...Esempio
CREATE PROCEDURE procedure1(INOUT p1 TEXT)
AS $$
BEGIN
RAISE NOTICE 'Procedure Parameter: %', p1 ;
END ;
$$
LANGUAGE plpgsql ;Esegui PROCEDURA in PostgreSQL
Per eseguire PROCEDURE in PostgreSQL, utilizzare l'istruzione CALL invece dell'istruzione SELECT. Questa è una delle differenze tra PROCEDURA e FUNZIONE.
postgres=# CALL procedure1 (' CREATE PROCEDURE functionality supported in PostgreSQL 11! ');
NOTICE: Procedure Parameter: CREATE PROCEDURE functionality supported in PostgreSQL 11!
p1
--------------------------------------------------------------
CREATE PROCEDURE functionality supported in PostgreSQL 11!
(1 row)È inoltre possibile specificare il nome del parametro nell'istruzione CALL. Questo è un altro modo per eseguire la PROCEDURA.
postgres=# CALL procedure1 (p1=>'CREATE PROCEDURE functionality supported in PostgreSQL 11!');
NOTICE: Procedure Parameter: CREATE PROCEDURE functionality supported in PostgreSQL 11!
p1
------------------------------------------------------------
CREATE PROCEDURE functionality supported in PostgreSQL 11!
(1 row)Visualizza l'elenco delle PROCEDURE create
Puoi controllare la definizione della PROCEDURA creata dal comando psql, ad esempio '\df'. Il comando psql '\df' viene utilizzato anche per visualizzare la definizione della FUNZIONE creata.
La PROCEDURA mostra la colonna Tipo come "proc" e se è FUNZIONE la colonna Tipo cambia in "func".
Nell'elenco di funzioni sottostante, abbiamo creato una PROCEDURA in modo che la colonna Tipo sia cambiata in "proc".
postgres=# \df
List of functions
Schema | Name | Result data type | Argument data types | Type
--------+------------+------------------+---------------------+------
public | procedure1 | | INOUT p1 text | proc
(1 row)Qui possiamo creare una FUNZIONE per controllare la colonna Tipo.
CREATE FUNCTION function1(INOUT p1 TEXT)
AS $$
BEGIN
RAISE NOTICE 'Function Parameter: %', p1 ;
END ;
$$
LANGUAGE plpgsql ;Esegui la FUNZIONE usando il comando SELECT.
postgres=# SELECT function1('CREATE PROCEDURE functionality supported in PostgreSQL 11!');
NOTICE: Function Parameter: CREATE PROCEDURE functionality supported in PostgreSQL 11!
function1
------------------------------------------------------------
CREATE PROCEDURE functionality supported in PostgreSQL 11!
(1 row)Ora puoi controllare la colonna Tipo e vedere la differenza. Per la funzione FUNCTION1, la colonna Tipo è cambiata in "func". Puoi vedere un'altra differenza qui, PROCEDURE è quasi la stessa di FUNCTION senza un valore di ritorno.
postgres=# \df
List of functions
Schema | Name | Result data type | Argument data types | Type
--------+------------+------------------+---------------------+------
public | function1 | text | INOUT p1 text | func
public | procedure1 | | INOUT p1 text | proc
(2 rows)Visualizza la definizione della PROCEDURA in PostgreSQL
Utilizzare '\sf' per visualizzare la definizione della PROCEDURA creata.
postgres=# \sf procedure1
CREATE OR REPLACE PROCEDURE public.procedure1(INOUT p1 text)
LANGUAGE plpgsql
AS $procedure$
BEGIN
RAISE NOTICE 'Procedure Parameter: %', p1 ;
END ;
$procedure$Controllo delle transazioni in PROCEDURA
Controllo delle transazioni che ci consente di COMMIT e ROLLBACK all'interno delle procedure. CREATE FUNCTION non supporta la transazione all'interno della funzione. Questa è la principale differenza tra FUNZIONE e PROCEDURA in PostgreSQL.
Creiamo una semplice procedura memorizzata che gestisce le transazioni.
CREATE OR REPLACE PROCEDURE transaction_test()
LANGUAGE plpgsql
AS $$
DECLARE
BEGIN
CREATE TABLE committed_table (id int);
INSERT INTO committed_table VALUES (1);
COMMIT;
CREATE TABLE rollback_table (id int);
INSERT INTO rollback_table VALUES (1);
ROLLBACK;
END $$;Eseguire la PROCEDURA utilizzando l'istruzione CALL.
postgres=# CALL transaction_test();
CALL Controlla il risultato dell'esecuzione.
postgres=# \d
List of relations
Schema | Name | Type | Owner
--------+-----------------+-------+----------
public | committed_table | table | postgres
(1 row)
postgres=# SELECT * FROM committed_table;
id
----
1
(1 row)In questo blog abbiamo visto il controllo delle transazioni per CREATE PROCEDURE utilizzando il linguaggio PL/pgSQL ma il controllo delle transazioni è fornito anche in altri linguaggi come PL/Python, PL/Tcl, PL/Perl.
La sintassi per il controllo delle transazioni in altre lingue è la seguente:
- PL/Python
- plpy.commit()
- plpy.rollback()
- PL/Tcl
- Impegnati
- ritorno
- PL/Perl
- spi_commit()
- spi_rollback()
Conclusione
CREATE PROCEDURE è sicuramente una delle funzionalità importanti e desiderabili in PostgreSQL 11. Questa funzionalità è molto utile per la migrazione da Oracle a PostgreSQL e molti casi d'uso diversi e molte persone sicuramente la accolgono con favore.
