Comme vous le savez peut-être dans toutes les versions jusqu'à PostgreSQL 10, il n'était pas possible de créer une procédure dans PostgreSQL. Dans PostgreSQL 11, PROCEDURE a été ajouté en tant que nouvel objet de schéma qui est un objet similaire à FUNCTION, mais sans valeur de retour.
Au fil des ans, de nombreuses personnes étaient impatientes d'avoir la fonctionnalité et elle a finalement été ajoutée dans PostgreSQL 11. Traditionnellement, PostgreSQL a fourni tous les moyens d'écrire des fonctions (appelées procédures stockées), mais dans une fonction, vous ne pouvez pas exécuter de transactions. Tout ce que vous pouvez vraiment utiliser, ce sont des exceptions, qui sont essentiellement des points de sauvegarde. Dans le corps d'une fonction, vous ne pouvez pas simplement valider une transaction ou en ouvrir une nouvelle. Le nouveau CREATE PROCEDURE changera tout cela et fournira une fonctionnalité pour exécuter des transactions à l'intérieur du code procédural.
Avantages de l'utilisation de procédures stockées
- Contrôle des transactions nous permettant de COMMIT et ROLLBACK à l'intérieur des procédures.
- Très utile pour la migration d'Oracle vers PostgreSQL, la nouvelle fonctionnalité de procédure peut être un gain de temps considérable.
- Comme vous pouvez le constater, il existe quelques similitudes entre CREATE FUNCTION et CREATE PROCEDURE. Les choses devraient donc être très simples pour la plupart des utilisateurs finaux.
Comment utiliser une procédure stockée dans PostgreSQL
Utilisez CREATE PROCEDURE pour créer une nouvelle procédure dans PostgreSQL 11, cela vous permettra d'écrire une procédure comme les autres bases de données. PROCEDURE est presque identique à FUNCTION sans valeur de retour. PROCEDURE est créé avec l'instruction CREATE PROCEDURE dans PostgreSQL 11. Contrairement à l'instruction CREATE FUNCTION, il n'y a pas de clause RETURNS, de clause ROWS, etc.
Syntaxe
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'
} ...Exemple
CREATE PROCEDURE procedure1(INOUT p1 TEXT)
AS $$
BEGIN
RAISE NOTICE 'Procedure Parameter: %', p1 ;
END ;
$$
LANGUAGE plpgsql ;Exécuter PROCEDURE dans PostgreSQL
Pour exécuter PROCEDURE dans PostgreSQL, utilisez l'instruction CALL au lieu de l'instruction SELECT. C'est l'une des différences entre PROCEDURE et FUNCTION.
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)Vous pouvez également spécifier le nom du paramètre dans l'instruction CALL. C'est une autre manière d'exécuter la PROCEDURE.
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)Afficher la liste des PROCÉDURES créées
Vous pouvez vérifier la définition de la PROCÉDURE créée à partir de la commande psql, c'est-à-dire '\df'. La commande psql '\df' est également utilisée pour afficher la définition de la FONCTION créée.
La PROCEDURE affiche la colonne Type comme "proc" et si c'est FUNCTION alors la colonne Type est changée en "func".
Dans la liste de fonctions ci-dessous, nous avons créé une PROCÉDURE afin que la colonne Type soit remplacée par "proc".
postgres=# \df
List of functions
Schema | Name | Result data type | Argument data types | Type
--------+------------+------------------+---------------------+------
public | procedure1 | | INOUT p1 text | proc
(1 row)Ici, nous pouvons créer une FONCTION pour vérifier la colonne Type.
CREATE FUNCTION function1(INOUT p1 TEXT)
AS $$
BEGIN
RAISE NOTICE 'Function Parameter: %', p1 ;
END ;
$$
LANGUAGE plpgsql ;Exécutez la FONCTION à l'aide de la commande 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)Vous pouvez maintenant vérifier la colonne Type et voir la différence. Pour la fonction FUNCTION1, la colonne Type est remplacée par « func ». Vous pouvez voir une autre différence ici, PROCEDURE est presque identique à FUNCTION sans valeur de retour.
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)Afficher la définition de PROCEDURE dans PostgreSQL
Utilisez ‘\sf’ pour afficher la définition de la PROCEDURE créée.
postgres=# \sf procedure1
CREATE OR REPLACE PROCEDURE public.procedure1(INOUT p1 text)
LANGUAGE plpgsql
AS $procedure$
BEGIN
RAISE NOTICE 'Procedure Parameter: %', p1 ;
END ;
$procedure$Contrôle des transactions dans la PROCÉDURE
Contrôle des transactions nous permettant de COMMIT et ROLLBACK à l'intérieur des procédures. CREATE FUNCTION ne prend pas en charge les transactions à l'intérieur de la fonction. C'est la principale différence entre FUNCTION et PROCEDURE dans PostgreSQL.
Créons une procédure stockée simple qui gère les transactions.
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 $$;Exécutez la PROCÉDURE à l'aide de l'instruction CALL.
postgres=# CALL transaction_test();
CALL Vérifiez le résultat de l'exécution.
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)Dans ce blog, nous avons vu le contrôle des transactions pour CREATE PROCEDURE en utilisant le langage PL/pgSQL, mais le contrôle des transactions est également fourni dans d'autres langages comme PL/Python, PL/Tcl, PL/Perl.
La syntaxe du contrôle des transactions dans d'autres langages est la suivante :
- PL/Python
- plpy.commit()
- plpy.rollback()
- PL/Tcl
- Engager
- rollback
- PL/Perl
- spi_commit()
- spi_rollback()
Conclusion
CREATE PROCEDURE est certainement l'une des fonctionnalités importantes et souhaitables de PostgreSQL 11. Cette fonctionnalité est très utile pour la migration d'Oracle vers PostgreSQL et de nombreux cas d'utilisation différents et de nombreuses personnes l'apprécient sûrement.
