Zoals u wellicht weet in alle versies tot en met PostgreSQL 10, was het niet mogelijk om een procedure in PostgreSQL aan te maken. In PostgreSQL 11 is PROCEDURE toegevoegd als een nieuw schema-object dat vergelijkbaar is met FUNCTION, maar zonder een retourwaarde.
In de loop der jaren wilden veel mensen de functionaliteit hebben en het werd uiteindelijk toegevoegd in PostgreSQL 11. Traditioneel bood PostgreSQL alle middelen om functies te schrijven (die werden genoemd als opgeslagen procedures), maar in een functie kun je geen transacties uitvoeren. Het enige dat u echt kunt gebruiken, zijn uitzonderingen, die in feite spaarpunten zijn. Binnen een functielichaam kun je niet zomaar een transactie uitvoeren of een nieuwe openen. De nieuwe CREATE PROCEDURE zal dat allemaal veranderen en een functionaliteit bieden om transacties binnen procedurele code uit te voeren.
Voordelen van het gebruik van opgeslagen procedures
- Transactiecontrole stelt ons in staat om binnen procedures COMMIT en ROLLBACK te doen.
- Zeer nuttig voor de migratie van Oracle naar PostgreSQL, de nieuwe procedurefunctionaliteit kan een aanzienlijke tijdbesparing opleveren.
- Zoals je kunt zien zijn er een aantal overeenkomsten tussen CREATE FUNCTION en CREATE PROCEDURE, dus het zou voor de meeste eindgebruikers heel gemakkelijk moeten zijn.
Opgeslagen procedure gebruiken in PostgreSQL
Gebruik CREATE PROCEDURE om een nieuwe procedure aan te maken in PostgreSQL 11, het zal u toelaten om de procedure te schrijven net als andere databases. PROCEDURE is bijna hetzelfde als FUNCTIE zonder een retourwaarde. PROCEDURE wordt gemaakt met de instructie CREATE PROCEDURE in PostgreSQL 11. In tegenstelling tot de instructie CREATE FUNCTION zijn er geen RETURNS-clausules, ROWS-clausules, enz.
Syntaxis
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'
} ...Voorbeeld
CREATE PROCEDURE procedure1(INOUT p1 TEXT)
AS $$
BEGIN
RAISE NOTICE 'Procedure Parameter: %', p1 ;
END ;
$$
LANGUAGE plpgsql ;PROCEDURE uitvoeren in PostgreSQL
Gebruik de CALL-instructie in plaats van de SELECT-instructie om PROCEDURE in PostgreSQL uit te voeren. Dit is een van de verschillen tussen PROCEDURE en FUNCTIE.
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)U kunt ook de parameternaam opgeven in de CALL-instructie. Dit is een andere manier om de PROCEDURE uit te voeren.
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)Lijst van aangemaakte PROCEDURE weergeven
U kunt de definitie van de gemaakte PROCEDURE controleren met het psql-commando, d.w.z. '\df'. Het psql-commando '\df' wordt ook gebruikt om de definitie van de gemaakte FUNCTIE weer te geven.
De PROCEDURE toont de kolom Type als "proc" en als het FUNCTION is, wordt de kolom Type gewijzigd in "func".
In de onderstaande lijst met functies hebben we één PROCEDURE gemaakt, zodat de kolom Type is gewijzigd in "proc".
postgres=# \df
List of functions
Schema | Name | Result data type | Argument data types | Type
--------+------------+------------------+---------------------+------
public | procedure1 | | INOUT p1 text | proc
(1 row)Hier kunnen we één FUNCTIE maken om de kolom Type te controleren.
CREATE FUNCTION function1(INOUT p1 TEXT)
AS $$
BEGIN
RAISE NOTICE 'Function Parameter: %', p1 ;
END ;
$$
LANGUAGE plpgsql ;Voer de FUNCTIE uit met het SELECT-commando.
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)Nu kunt u de kolom Type controleren en het verschil zien. Voor de functie FUNCTIE1 is de kolom Type gewijzigd in "func". Je kunt hier nog een verschil zien, PROCEDURE is bijna hetzelfde als FUNCTIE zonder een retourwaarde.
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)Procedure-definitie weergeven in PostgreSQL
Gebruik ‘\sf’ om de definitie van de aangemaakte PROCEDURE weer te geven.
postgres=# \sf procedure1
CREATE OR REPLACE PROCEDURE public.procedure1(INOUT p1 text)
LANGUAGE plpgsql
AS $procedure$
BEGIN
RAISE NOTICE 'Procedure Parameter: %', p1 ;
END ;
$procedure$Transactiecontrole in PROCEDURE
Transactiecontrole stelt ons in staat om binnen procedures COMMIT en ROLLBACK te doen. CREATE FUNCTION ondersteunt geen transacties binnen de functie. Dit is het belangrijkste verschil tussen FUNCTIE en PROCEDURE in PostgreSQL.
Laten we een eenvoudige opgeslagen procedure maken die transacties afhandelt.
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 $$;Voer de PROCEDURE uit met de instructie CALL.
postgres=# CALL transaction_test();
CALL Controleer het uitvoeringsresultaat.
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 deze blog hebben we transactiecontrole gezien voor CREATE PROCEDURE met behulp van PL/pgSQL-taal, maar transactiecontrole is ook beschikbaar in andere talen zoals PL/Python, PL/Tcl, PL/Perl.
De syntaxis voor transactiebeheer in andere talen is als volgt:
- PL/Python
- plpy.commit()
- plpy.rollback()
- PL/Tcl
- Bevestigen
- terugdraaien
- PL/Perl
- spi_commit()
- spi_rollback()
Conclusie
PROCEDURE MAKEN is zeker een van de belangrijke en wenselijke functies in PostgreSQL 11. Deze functie is erg handig voor de migratie van Oracle naar PostgreSQL en voor veel verschillende gebruiksscenario's en veel mensen verwelkomen het zeker.