Gespeicherte Prozedur aufrufen

Mit den Anweisungen execute, open und get können Sie eine gespeicherte SQL-Prozedur aufrufen; in jedem dieser Fälle wird die #sql-Direktive verwendet.

Eine gespeicherte Prozedur besteht (wie eine Funktion in EGL) aus einer Gruppe von Anweisungen für eine Datenbank. Gespeicherte Prozeduren unterscheiden sich von vorbereiteten Anweisungen dahingehend, dass die gespeicherte Prozedur permanent in der Datenbank verbleibt, während eine vorbereitete Anweisung für das Programm oder den Logikabschnitt lokal ist und von der Datenbank nur vorübergehend zwischengespeichert wird. Eine gespeicherte Prozedur kann außerdem aus vielen SQL-Anweisungen bestehen, während eine vorbereitete Anweisung nur aus einer SQL-Anweisung besteht. Grundsätzlich können mit einer gespeicherten Prozedur jedoch dieselben Instruktionen ausgeführt werden wie mit einer vorbereiteten Anweisung.

Voraussetzungen

Mit execute eine gespeicherte Prozedur aufrufen

Das Schlüsselwort execute ist zum Aufrufen gespeicherter Prozeduren geeignet, die keine Ergebnismenge zurückgeben. Ferner können mit execute gespeicherte Prozeduren aufgerufen werden, die eine oder mehrere Ergebnismengen zurückgeben, wobei die Ergebnismengen in diesem Fall aber ignoriert werden.

Verwenden Sie zum Aufrufen einer gespeicherten Prozedur mit execute die #sql-Direktive+++ und geben Sie den Namen der gespeicherten Prozedur im expliziten SQL-Code an:
execute #sql{
    CALL MYSTOREDPROCEDURE
};
Wenn die gespeicherte Prozedur Parameter akzeptiert, werden EGL-Variablen als Hostvariablen übergeben (siehe Hostvariablen):
myParameter int = 5;
execute #sql{
    CALL MYSTOREDPROCEDURE(:myParameter)
};
Im folgenden Beispiel wird eine vorbereitete Anweisung in Kombination mit der Anweisung execute verwendet:
prepare p1 from "CALL MYSTOREDPROCEDURE(?)";
execute p1 using myParameter;

Mit open eine gespeicherte Prozedur aufrufen

Mit dem Schlüsselwort open können nur gespeicherte Prozeduren aufgerufen werden, die genau eine Ergebnismenge zurückgeben. Bei gespeicherten Prozeduren, die keine oder mehrere Ergebnismengen zurückgeben, wird die Anweisung execute verwendet.

Zum Aufrufen einer gespeicherten Prozedur mit open müssen Sie die #sql-Direktive verwenden und den Namen der gespeicherten Prozedur im expliziten SQL-Code angeben:
open myResultSet with #sql{
    CALL GETCUSTOMERS
};
Dann können Sie über die ID myResultSet auf die Ergebnismenge zugreifen (siehe folgendes Beispiel, in dem ein Datensatzabschnitt (Stereotyp SQLRecord) namens MyCustomerPart verwendet wird:
myCustomers MyCustomerPart;
get next from myResultSet into myCustomers;
Wenn die gespeicherte Prozedur Parameter akzeptiert, werden EGL-Variablen als Hostvariablen übergeben:
myParameter int = 5;
open myResultSet with #sql{
    CALL GETCUSTOMERS(:myParameter)
};
Im folgenden Beispiel wird eine vorbereitete Anweisung in Kombination mit der Anweisung open verwendet:
prepare p1 from "CALL GETCUSTOMERS(?)";
open myResultSet with p1 using myParameter;

Mit get eine gespeicherte Prozedur aufrufen

Sie können das Schlüsselwort get zusammen mit einer dynamischen Feldgruppe verwenden, um nur gespeicherte Prozeduren aufzurufen, die genau eine Ergebnismenge zurückgeben. Bei gespeicherten Prozeduren, die keine oder mehrere Ergebnismengen zurückgeben, wird die Anweisung execute verwendet.

Zum Aufrufen einer gespeicherten Prozedur mit get müssen Sie die #sql-Direktive verwenden und den Namen der gespeicherten Prozedur im expliziten SQL-Code angeben:
myCustomers MyCustomerPart[]{};
get myArray with #sql{
    CALL GETCUSTOMERS
};
Wenn die gespeicherte Prozedur Parameter akzeptiert, werden EGL-Variablen als Hostvariablen übergeben:
myCustomers MyCustomerPart[]{};
myParameter int = 5;
get myArray with #sql{
    CALL GETCUSTOMERS(:myParameter)
};
Im folgenden Beispiel wird eine vorbereitete Anweisung in Kombination mit der Anweisung get verwendet:
myCustomers MyCustomerPart[]{};
myParameter int = 5;
prepare p1 from "CALL GETCUSTOMERS(?)";
get myCustomers with p1 using myParameter;

Besondere Hinweise zu Oracle DBMS

Wenn Sie mit einer Oracle-Datenbank arbeiten, können Sie entweder eine gespeicherte Prozedur oder eine gespeicherte Funktion aufrufen.

Bei einer Oracle-Datenbank müssen zum Aufrufen einer gespeicherten Prozedur mit der Anweisungopen oder get die folgenden Regeln beachtet werden:
  • Die Prozedur muss über mindestens einen Parameter verfügen.
  • Der erste Parameter muss über den Änderungswert out oder inOut verfügen und ein REF CURSOR-Typ sein (ein Beispiel für die Definition dieses Typs folgt später). Eine auf diesem Typ basierende Variable wird als Cursorvariable bezeichnet und kann Ergebnismengen zwischen verschiedenen Programmabschnitten übergeben.
  • Der erste Parameter der Prozedur wird mit einem Fragezeichen dargestellt (siehe Beispiele weiter unten).
  • Wenn sich der Prozeduraufruf in einer vorbereiteten Anweisung befindet, darf in die using-Klausel für den ersten Parameter nichts eingefügt werden. Wenn keine anderen Parameter vorhanden sind, können Sie die using-Klausel übergehen.
Im ersten Beispiel (unter Verwendung der #sql-Direktive) verfügt die Prozedur über keine Parameter außer der Cursorvariablen:
open rs1 with #sql { call p1( ? ) };
Im nächsten Beispiel (ebenfalls unter Verwendung der #sql-Direktive) verfügt die Prozedur zusätzlich zur Cursorvariablen über zwei Parameter:
x int = 10;
y int = 1000;
open rs2 with #sql { call p2( ?, :x, :y ) };
Im nächsten Beispiel (unter Verwendung einer vorbereiteten Anweisung) verfügt die Prozedur über keine Parameter außer der Cursorvariablen:
prepare pstmt3 from "call p1( ? )";
open rs3 with pstmt3;
Im nächsten Beispiel (unter Verwendung einer vorbereiteten Anweisung) verfügt die Prozedur zusätzlich zur Cursorvariablen über zwei Parameter:
prepare pstmt4 from "call p2( ?, ?, ? )";
open rs4 with pstmt4 using x, y;
Im folgenden Beispiel wird eine Möglichkeit gezeigt, wie ein REF CURSOR-Typ für Oracle definiert werden kann. (Andere Möglichkeiten finden Sie in der Oracle-Dokumentation.)
execute #sql{ CREATE OR REPLACE PACKAGE MYPKG
   AS
      TYPE RC12 IS REF CURSOR;
   END; };
Der obige Code erstellt einen neuen Typ namens MYPKG.RC12, den Sie für den Typ eines Parameters verwenden können, der die Ergebnisse einer Abfrage enthält. Der folgende EGL-Code definiert eine gespeicherte Prozedur, die Sie mit der EGL-Anweisung open aufrufen können:
execute #sql{ CREATE PROCEDURE ZPQPRM2( c IN OUT MYPKG.RC12, x IN CHAR ) 
   AS
   BEGIN
      OPEN c FOR SELECT firstnme, empno FROM empx WHERE empno > x ORDER BY empno;
   END; };

Darüber hinaus können in Oracle gespeicherte Funktionen erstellt werden. Eine gespeicherte Funktion entspricht einer gespeicherten Prozedur mit der Ausnahme, dass ein Wert zurückgegeben wird (gespeicherte Oracle-Prozeduren können keine Werte zurückgeben). Eine gespeicherte Oracle-Funktion kann in EGL aufgerufen werden. Dazu wird eine SQL-Syntax verwendet, die sich geringfügig von der Syntax für den Aufruf einer gespeicherten Prozedur unterscheidet.

In diesem Beispiel wird die aufgerufene Funktion als Zeichenfolge übergeben und der Rückgabewert ist eine ganze Zahl:
x int;
y string = "hello";
execute #sql{ call :x := func1( :y ) };
writeStdout( "The function returned " :: x );
Im nächsten Beispiel wird dieselbe Funktion mit einer vorbereiteten Anweisung aufgerufen:
prepare q from "call ? := func1( ? )";
execute q using x, y;
writeStdout( "The function returned " :: x );
EGL kann gespeicherte Oracle-Funktionen aufrufen, die die Ergebnisse einer Abfrage zurückgeben. Es gelten die folgenden Regeln:
  • Die Funktion wird mit der EGL-Anweisung open oder get aufgerufen.
  • Die Funktion muss einen REF CURSOR-Typ zurückgeben.
  • Der von einer Anweisung open ausgeführte SQL-Code muss ein Fragezeichen enthalten, um den von der Funktion zurückgegebenen Wert darzustellen.
  • Wenn sich der Funktionsaufruf in einer vorbereiteten Anweisung befindet, darf in die using-Klausel für das erste Fragezeichen nichts eingefügt werden. Wenn die Funktion über keine Parameter verfügt, können Sie die using-Klausel übergehen.
Im ersten Beispiel (unter Verwendung der #sql-Direktive) verfügt die Funktion über keine Parameter außer der Cursorvariablen:
open rs5 with #sql { call ? := f5() };
Im nächsten Beispiel (ebenfalls unter Verwendung der #sql-Direktive) verfügt die Funktion zusätzlich zur Cursorvariablen über zwei Parameter:
x int = 10;
y int = 1000;
open rs6 with #sql { call ? := f6( :x, :y ) };
Im nächsten Beispiel (unter Verwendung einer vorbereiteten Anweisung) verfügt die Funktion über keine Parameter außer der Cursorvariablen:
prepare pstmt7 from "call ? := f5()";
open rs7 with pstmt7;
Im nächsten Beispiel (unter Verwendung einer vorbereiteten Anweisung) verfügt die Funktion zusätzlich zur Cursorvariablen über zwei Parameter:
prepare pstmt8 from "call ? := f6( ?, ? )";
open rs8 with pstmt8 using x, y;

Einschränkungen

Für die Verwendung gespeicherter Prozeduren in EGL gelten die folgenden Einschränkungen:


Feedback