Como sabrás en todas las versiones hasta PostgreSQL 10 no era posible crear un procedimiento en PostgreSQL. En PostgreSQL 11, se agregó PROCEDIMIENTO como un nuevo objeto de esquema que es un objeto similar a FUNCIÓN, pero sin un valor de retorno.
A lo largo de los años, muchas personas estaban ansiosas por tener la funcionalidad y finalmente se agregó en PostgreSQL 11. Tradicionalmente, PostgreSQL ha proporcionado todos los medios para escribir funciones (que se denominaban procedimientos almacenados); sin embargo, en una función no se pueden ejecutar transacciones. Todo lo que realmente puede usar son excepciones, que son básicamente puntos de guardado. Dentro del cuerpo de una función, no puede simplemente confirmar una transacción o abrir una nueva. El nuevo CREATE PROCEDURE cambiará todo eso y proporcionará una funcionalidad para ejecutar transacciones dentro del código de procedimiento.
Beneficios de usar procedimientos almacenados
- Control de transacciones que nos permite COMMIT y ROLLBACK dentro de los procedimientos.
- Muy útil para la migración de Oracle a PostgreSQL, la nueva funcionalidad de procedimiento puede ahorrar mucho tiempo.
- Como puede ver, hay un par de similitudes entre CREAR FUNCIÓN y CREAR PROCEDIMIENTO, por lo que las cosas deberían ser realmente fáciles para la mayoría de los usuarios finales.
Cómo usar el procedimiento almacenado en PostgreSQL
Use CREAR PROCEDIMIENTO para crear un nuevo procedimiento en PostgreSQL 11, le permitirá escribir procedimientos como otras bases de datos. PROCEDIMIENTO es casi lo mismo que FUNCIÓN sin un valor de retorno. PROCEDURE se crea con la declaración CREATE PROCEDURE en PostgreSQL 11. A diferencia de la declaración CREATE FUNCTION, no hay cláusula RETURNS, cláusula ROWS, etc.
Sintaxis
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'
} ...Ejemplo
CREATE PROCEDURE procedure1(INOUT p1 TEXT)
AS $$
BEGIN
RAISE NOTICE 'Procedure Parameter: %', p1 ;
END ;
$$
LANGUAGE plpgsql ;Ejecutar PROCEDIMIENTO en PostgreSQL
Para ejecutar PROCEDURE en PostgreSQL, use la instrucción CALL en lugar de la instrucción SELECT. Esta es una de las diferencias entre PROCEDIMIENTO y FUNCIÓN.
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)También puede especificar el nombre del parámetro en la instrucción CALL. Esta es otra forma de ejecutar el PROCEDIMIENTO.
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)Mostrar lista de PROCEDIMIENTO creado
Puede verificar la definición del PROCEDIMIENTO creado desde el comando psql, es decir, '\ df'. El comando psql '\df' también se usa para mostrar la definición de la FUNCIÓN creada.
El PROCEDIMIENTO muestra la columna Tipo como "proc" y si es FUNCIÓN, la columna Tipo cambió a "func".
En la siguiente lista de funciones, hemos creado un PROCEDIMIENTO para que la columna Tipo cambie a "proc".
postgres=# \df
List of functions
Schema | Name | Result data type | Argument data types | Type
--------+------------+------------------+---------------------+------
public | procedure1 | | INOUT p1 text | proc
(1 row)Aquí, podemos crear una FUNCIÓN para verificar la columna Tipo.
CREATE FUNCTION function1(INOUT p1 TEXT)
AS $$
BEGIN
RAISE NOTICE 'Function Parameter: %', p1 ;
END ;
$$
LANGUAGE plpgsql ;Ejecute la FUNCIÓN usando el comando SELECCIONAR.
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)Ahora puede verificar la columna Tipo y ver la diferencia. Para la función FUNCTION1, la columna Tipo cambió a "func". Puede ver una diferencia más aquí, el PROCEDIMIENTO es casi lo mismo que la FUNCIÓN sin un valor de retorno.
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)Mostrar definición de PROCEDIMIENTO en PostgreSQL
Use '\sf' para mostrar la definición del PROCEDIMIENTO creado.
postgres=# \sf procedure1
CREATE OR REPLACE PROCEDURE public.procedure1(INOUT p1 text)
LANGUAGE plpgsql
AS $procedure$
BEGIN
RAISE NOTICE 'Procedure Parameter: %', p1 ;
END ;
$procedure$Control de transacciones en PROCEDIMIENTO
Control de transacciones que nos permite COMMIT y ROLLBACK dentro de los procedimientos. CREATE FUNCTION no admite transacciones dentro de la función. Esta es la principal diferencia entre FUNCIÓN y PROCEDIMIENTO en PostgreSQL.
Vamos a crear un procedimiento almacenado simple que maneje transacciones.
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 $$;Ejecute el PROCEDIMIENTO usando la instrucción CALL.
postgres=# CALL transaction_test();
CALL Compruebe el resultado de la ejecución.
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)En este blog hemos visto el control de transacciones para CREAR PROCEDIMIENTO utilizando el lenguaje PL/pgSQL, pero el control de transacciones también se proporciona en otros lenguajes como PL/Python, PL/Tcl, PL/Perl.
La sintaxis para el control de transacciones en otros idiomas es la siguiente:
- PL/Python
- plpy.commit()
- plpy.rollback()
- PL/Tcl
- Compromiso
- revertir
- PL/Perl
- spi_commit()
- spi_rollback()
Conclusión
CREAR PROCEDIMIENTO es definitivamente una de las características importantes y deseables en PostgreSQL 11. Esta característica es muy útil para la migración de Oracle a PostgreSQL y muchos casos de uso diferentes y muchas personas seguramente la agradecerán.
