Přehled nových uložených procedur v PostgreSQL 11

Jak možná víte, ve všech verzích až do PostgreSQL 10 nebylo možné vytvořit proceduru v PostgreSQL. V PostgreSQL 11 byl PROCEDURE přidán jako nový objekt schématu, který je podobný objektu FUNCTION, ale bez návratové hodnoty.

V průběhu let se mnoho lidí snažilo mít tuto funkcionalitu a nakonec byla přidána do PostgreSQL 11. Tradičně PostgreSQL poskytoval všechny prostředky k zápisu funkcí (které byly nazývány jako uložené procedury), ale ve funkci nemůžete spouštět transakce. Jediné, co můžete skutečně použít, jsou výjimky, což jsou v podstatě body uložení. Uvnitř těla funkce nemůžete jen potvrdit transakci nebo otevřít novou. Nový CREATE PROCEDURE to vše změní a poskytne funkcionalitu pro spouštění transakcí v rámci procedurálního kódu.

Výhody používání uložených procedur

• Kontrola transakcí, která nám umožňuje ZAKÁZAT a VRÁTIT V rámci procedur.
• Velmi užitečné pro migraci Oracle na PostgreSQL, nová funkce procedur může významně ušetřit čas.
• Jak můžete vidět, existuje několik podobností mezi CREATE FUNCTION a CREATE PROCEDURE, takže věci by měly být pro většinu koncových uživatelů opravdu snadné.

Jak používat uloženou proceduru v PostgreSQL

Pomocí CREATE PROCEDURE vytvořte novou proceduru v PostgreSQL 11, umožní vám to napsat proceduru stejně jako jiné databáze. PROCEDURE je téměř stejný jako FUNCTION bez návratové hodnoty. PROCEDURE se vytváří pomocí příkazu CREATE PROCEDURE v PostgreSQL 11. Na rozdíl od příkazu CREATE FUNCTION zde nejsou žádné klauzule RETURNS, klauzule ROWS atd.

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'
  } ...

Příklad

CREATE PROCEDURE procedure1(INOUT p1 TEXT) 
AS $$
BEGIN
    RAISE NOTICE 'Procedure Parameter: %', p1 ;
END ;
$$
LANGUAGE plpgsql ;

Proveďte PROCEDURE v PostgreSQL

Chcete-li provést PROCEDURE v PostgreSQL, použijte místo příkazu SELECT příkaz CALL. Toto je jeden z rozdílů mezi PROCEDURE a 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)

Název parametru můžete zadat také v příkazu CALL. Toto je další způsob, jak provést 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)

Zobrazit seznam vytvořeného POSTUPU

Definici vytvořeného PROCEDURE můžete zkontrolovat z příkazu psql, tj. '\df'. Příkaz psql '\df' se také používá k zobrazení definice vytvořené FUNKCE.

PROCEDURE ukazuje sloupec Type jako "proc" a pokud je to FUNCTION, pak se sloupec Type změní na "func".

V níže uvedeném seznamu funkcí jsme vytvořili jeden POSTUP, takže sloupec Type se změnil na "proc".

postgres=# \df
                          List of functions
Schema |    Name    | Result data type | Argument data types | Type
--------+------------+------------------+---------------------+------
public | procedure1 |                  | INOUT p1 text       | proc
(1 row)

Zde můžeme vytvořit jednu FUNKCI pro kontrolu sloupce Typ.

CREATE FUNCTION function1(INOUT p1 TEXT) 
AS $$
BEGIN
    RAISE NOTICE 'Function Parameter: %', p1 ;
END ;
$$
LANGUAGE plpgsql ;

Spusťte FUNCTION pomocí příkazu 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)

Nyní můžete zkontrolovat sloupec Typ a vidět rozdíl. U funkce FUNCTION1 se sloupec Type změnil na "func". Zde můžete vidět ještě jeden rozdíl, PROCEDURE je téměř stejný jako FUNCTION bez návratové hodnoty.

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)

Zobrazení definice POSTUPU v PostgreSQL

Pomocí ‚\sf‘ zobrazíte definici vytvořeného POSTUPU.

postgres=# \sf procedure1                                                    
CREATE OR REPLACE PROCEDURE public.procedure1(INOUT p1 text)                 
 LANGUAGE plpgsql                                                            
AS $procedure$                                                               
BEGIN                                                                        
 RAISE NOTICE 'Procedure Parameter: %', p1 ;                                 
END ;                                                                        
$procedure$

Kontrola transakcí v PROCEDURE

Transakční kontrola, která nám umožňuje ZAVÁDĚT a ZPĚT ZPĚT uvnitř procedur. CREATE FUNCTION nepodporuje transakce uvnitř funkce. Toto je hlavní rozdíl mezi FUNCTION a PROCEDURE v PostgreSQL.

Vytvořme jednoduchou uloženou proceduru, která zpracovává transakce.

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 $$;

Proveďte PROCEDURE pomocí příkazu CALL.

postgres=# CALL transaction_test();                                                      
CALL 

Zkontrolujte výsledek provedení.

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)

V tomto blogu jsme viděli řízení transakcí pro CREATE PROCEDURE pomocí jazyka PL/pgSQL, ale řízení transakcí je poskytováno také v jiných jazycích, jako je PL/Python, PL/Tcl, PL/Perl.

Syntaxe pro řízení transakcí v jiných jazycích je následující:

• PL/Python
  • plpy.commit()
  • plpy.rollback()
• PL/Tcl
  • Zavázat se
  • vrácení zpět
• PL/Perl
  • spi_commit()
  • spi_rollback()

Závěr

CREATE PROCEDURE je rozhodně jednou z důležitých a žádoucích funkcí v PostgreSQL 11. Tato funkce je velmi užitečná pro migraci Oracle na PostgreSQL a mnoho různých případů použití a mnoho lidí ji jistě vítá.