Wie Sie vielleicht wissen, war es in allen Versionen bis PostgreSQL 10 nicht möglich, eine Prozedur in PostgreSQL zu erstellen. In PostgreSQL 11 wurde PROCEDURE als neues Schemaobjekt hinzugefügt, das ein ähnliches Objekt wie FUNCTION ist, jedoch ohne Rückgabewert.
Im Laufe der Jahre wollten viele Leute diese Funktionalität haben und sie wurde schließlich in PostgreSQL 11 hinzugefügt. Traditionell hat PostgreSQL alle Mittel zum Schreiben von Funktionen (die als gespeicherte Prozeduren bezeichnet wurden) bereitgestellt, jedoch können Sie in einer Funktion keine Transaktionen ausführen. Alles, was Sie wirklich verwenden können, sind Ausnahmen, die im Grunde Sicherungspunkte sind. Innerhalb eines Funktionskörpers können Sie nicht einfach eine Transaktion festschreiben oder eine neue eröffnen. Das neue CREATE PROCEDURE wird all das ändern und eine Funktionalität bieten, um Transaktionen innerhalb von prozeduralem Code auszuführen.
Vorteile der Verwendung gespeicherter Prozeduren
- Transaktionskontrolle, die es uns ermöglicht, innerhalb von Prozeduren COMMIT und ROLLBACK auszuführen.
- Sehr hilfreich für die Migration von Oracle zu PostgreSQL, die neue Prozedurfunktionalität kann eine erhebliche Zeitersparnis sein.
- Wie Sie sehen können, gibt es einige Ähnlichkeiten zwischen CREATE FUNCTION und CREATE PROCEDURE, sodass die Dinge für die meisten Endbenutzer wirklich einfach sein sollten.
So verwenden Sie gespeicherte Prozeduren in PostgreSQL
Verwenden Sie CREATE PROCEDURE, um eine neue Prozedur in PostgreSQL 11 zu erstellen, damit Sie Prozeduren wie andere Datenbanken schreiben können. PROCEDURE ist fast dasselbe wie FUNCTION ohne Rückgabewert. PROCEDURE wird mit der CREATE PROCEDURE-Anweisung in PostgreSQL 11 erstellt. Im Gegensatz zur CREATE FUNCTION-Anweisung gibt es keine RETURNS-Klausel, ROWS-Klausel usw.
Syntax
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'
} ...Beispiel
CREATE PROCEDURE procedure1(INOUT p1 TEXT)
AS $$
BEGIN
RAISE NOTICE 'Procedure Parameter: %', p1 ;
END ;
$$
LANGUAGE plpgsql ;PROCEDURE in PostgreSQL ausführen
Um PROCEDURE in PostgreSQL auszuführen, verwenden Sie die CALL-Anweisung anstelle der SELECT-Anweisung. Dies ist einer der Unterschiede zwischen PROCEDURE und 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)Sie können den Parameternamen auch in der CALL-Anweisung angeben. Dies ist eine weitere Möglichkeit, die Prozedur auszuführen.
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)Liste der erstellten Prozeduren anzeigen
Sie können die Definition des erstellten PROCEDURE mit dem psql-Befehl überprüfen, z. B. '\df'. Der psql-Befehl '\df' wird auch verwendet, um die Definition der erstellten FUNCTION anzuzeigen.
Die PROCEDURE zeigt die Type-Spalte als "proc" und wenn es FUNCTION ist, dann ändert sich die Type-Spalte zu "func".
In der folgenden Liste von Funktionen haben wir eine PROCEDURE erstellt, sodass sich die Type-Spalte in „proc“ geändert hat.
postgres=# \df
List of functions
Schema | Name | Result data type | Argument data types | Type
--------+------------+------------------+---------------------+------
public | procedure1 | | INOUT p1 text | proc
(1 row)Hier können wir eine FUNCTION erstellen, um die Type-Spalte zu prüfen.
CREATE FUNCTION function1(INOUT p1 TEXT)
AS $$
BEGIN
RAISE NOTICE 'Function Parameter: %', p1 ;
END ;
$$
LANGUAGE plpgsql ;Führen Sie die FUNCTION mit dem SELECT-Befehl aus.
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)Jetzt können Sie die Spalte Typ überprüfen und den Unterschied sehen. Für die Funktion FUNKTION1 wurde die Spalte Typ in „func“ geändert. Sie können hier einen weiteren Unterschied sehen, PROCEDURE ist fast dasselbe wie FUNCTION ohne einen Rückgabewert.
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-Definition in PostgreSQL anzeigen
Verwenden Sie „\sf“, um die Definition des erstellten PROCEDURE anzuzeigen.
postgres=# \sf procedure1
CREATE OR REPLACE PROCEDURE public.procedure1(INOUT p1 text)
LANGUAGE plpgsql
AS $procedure$
BEGIN
RAISE NOTICE 'Procedure Parameter: %', p1 ;
END ;
$procedure$Transaktionskontrolle in VERFAHREN
Transaktionskontrolle, die es uns ermöglicht, innerhalb von Prozeduren COMMIT und ROLLBACK auszuführen. CREATE FUNCTION unterstützt keine Transaktionen innerhalb der Funktion. Dies ist der Hauptunterschied zwischen FUNCTION und PROCEDURE in PostgreSQL.
Lassen Sie uns eine einfache gespeicherte Prozedur erstellen, die Transaktionen verarbeitet.
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 $$;Führen Sie die PROCEDURE mit der CALL-Anweisung aus.
postgres=# CALL transaction_test();
CALL Überprüfen Sie das Ausführungsergebnis.
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 diesem Blog haben wir die Transaktionskontrolle für CREATE PROCEDURE mit der Sprache PL/pgSQL gesehen, aber die Transaktionskontrolle wird auch in anderen Sprachen wie PL/Python, PL/Tcl, PL/Perl bereitgestellt.
Die Syntax für die Transaktionssteuerung in anderen Sprachen lautet wie folgt:
- PL/Python
- plpy.commit()
- plpy.rollback()
- PL/Tcl
- Verpflichten
- zurücksetzen
- PL/Perl
- spi_commit()
- spi_rollback()
Schlussfolgerung
CREATE PROCEDURE ist definitiv eine der wichtigen und wünschenswerten Funktionen in PostgreSQL 11. Diese Funktion ist sehr nützlich für die Migration von Oracle zu PostgreSQL und viele verschiedene Anwendungsfälle, und viele Leute begrüßen sie sicherlich.
