Aufrufen einer gespeicherten Prozedur

Sie können eine gespeicherte Prozedur mit dem SQL-Befehl CALL aufrufen.

Damit ein Benutzer eine gespeicherte Prozedur aufrufen kann, muss die Rolle des Benutzers die USAGE-Berechtigung für diese gespeicherte Prozedur haben.

Sobald Sie die Berechtigung zum Aufrufen der gespeicherten Prozedur haben, können Sie mit einer CALL-Anweisung die gespeicherte Prozedur aufrufen.

Bemerkung

Um eine anonyme Prozedur sowohl zu erstellen als auch aufzurufen, verwenden Sie CALL (mit anonymen Prozeduren). Das Erstellen und Aufrufen einer anonymen Prozedur erfordert keine Rolle mit CREATE PROCEDURE-Schemaberechtigungen.

Angeben der Argumente

Wenn die gespeicherte Prozedur Argumente hat, können Sie diese Argumente über den Namen oder über die Position angeben.

Die folgende gespeicherte Prozedur akzeptiert zum Beispiel drei Argumente:

CREATE OR REPLACE PROCEDURE sp_concatenate_strings(
    first_arg VARCHAR,
    second_arg VARCHAR,
    third_arg VARCHAR)
  RETURNS VARCHAR
  LANGUAGE SQL
  AS
  $$
  BEGIN
    RETURN first_arg || second_arg || third_arg;
  END;
  $$;
Copy

Wenn Sie die Prozedur aufrufen, können Sie die Argumente über den Namen angeben:

CALL sp_concatenate_strings(
  first_arg => 'one',
  second_arg => 'two',
  third_arg => 'three');
Copy
+------------------------+
| SP_CONCATENATE_STRINGS |
|------------------------|
| onetwothree            |
+------------------------+

Wenn Sie die Argumente über den Namen angeben, müssen Sie die Argumente nicht in einer bestimmten Reihenfolge angeben:

CALL sp_concatenate_strings(
  third_arg => 'three',
  first_arg => 'one',
  second_arg => 'two');
Copy
+------------------------+
| SP_CONCATENATE_STRINGS |
|------------------------|
| onetwothree            |
+------------------------+

Sie können die Argumente auch über die Position angeben:

CALL sp_concatenate_strings(
  'one',
  'two',
  'three');
Copy
+------------------------+
| SP_CONCATENATE_STRINGS |
|------------------------|
| onetwothree            |
+------------------------+

Beachten Sie Folgendes:

  • Sie müssen alle Argumente entweder über den Namen oder über die Position angeben. Sie können nicht einige der Argumente über den Namen und andere Argumente über die Position angeben.

    Wenn Sie ein Argument über den Namen angeben, können Sie den Argumentnamen nicht in doppelten Anführungszeichen einschließen.

  • Wenn zwei Funktionen oder zwei Prozeduren den gleichen Namen, aber unterschiedliche Argumenttypen haben, können Sie die Argumentnamen verwenden, um anzugeben, welche Funktion bzw. Prozedur ausgeführt werden soll, allerdings müssen die Argumentnamen unterschiedlich sein. Weitere Informationen dazu finden Sie unter Überladen von Prozeduren und Funktionen.

Angeben von optionalen Argumenten

Wenn die gespeicherte Prozedur optionale Argumente hat, können Sie die optionalen Argumente beim Aufrufen weglassen. Jedes optionale Argument hat einen Standardwert, der verwendet wird, wenn das Argument weggelassen wird.

Die folgende gespeicherte Prozedur hat zum Beispiel ein erforderliches Argument und zwei optionale Argumente. Jedes optionale Argument hat einen Standardwert.

CREATE OR REPLACE PROCEDURE build_string_proc(
    word VARCHAR,
    prefix VARCHAR DEFAULT 'pre-',
    suffix VARCHAR DEFAULT '-post'
  )
  RETURNS VARCHAR
  LANGUAGE SQL
  AS
  $$
    BEGIN
      RETURN prefix || word || suffix;
    END;
  $$
  ;
Copy

Sie können jedes der optionalen Argumente in dem Aufruf weglassen. Wenn Sie ein Argument weglassen, wird der Standardwert dieses Arguments verwendet.

CALL build_string_proc('hello');
Copy
+-------------------+
| BUILD_STRING_PROC |
|-------------------|
| pre-hello-post    |
+-------------------+
CALL build_string_proc('hello', 'before-');
Copy
+-------------------+
| BUILD_STRING_PROC |
|-------------------|
| before-hello-post |
+-------------------+

Wenn Sie ein optionales Argument weglassen und ein anderes optionales Argument angeben müssen, das in der Signatur nach dem weggelassenen Argument positioniert ist, müssen Sie benannte Argumente und keine Positionsargumente verwenden.

Angenommen, Sie lassen das Argument prefix weg und müssen aber das Argument suffix angeben. Das Argument suffix ist in der Signatur nach dem Argument prefix positioniert, sodass Sie die Argumente mit Namen angeben müssen:

CALL build_string_proc(word => 'hello', suffix => '-after');
Copy
+-------------------+
| BUILD_STRING_PROC |
|-------------------|
| pre-hello-after   |
+-------------------+

Beispiele

Verwenden Sie zum Ausführen einer gespeicherten Prozedur eine CALL-Anweisung. Beispiel:

call stproc1(5.14::FLOAT);
Copy

Jedes Argument für eine gespeicherte Prozedur kann ein allgemeiner Ausdruck sein:

CALL stproc1(2 * 5.14::FLOAT);
Copy

Ein Argument kann eine Unterabfrage sein:

CALL stproc1(SELECT COUNT(*) FROM stproc_test_table1);
Copy

Sie können nur eine gespeicherte Prozedur pro CALL-Anweisung aufrufen. Zum Beispiel schlägt die folgende Aussagen fehl:

call proc1(1), proc2(2);                          -- Not allowed
Copy

Außerdem können Sie den CALL einer gespeicherten Prozedur nicht als Teil eines Ausdrucks verwenden. Beispielsweise schlagen alle folgenden Anweisungen fehl:

call proc1(1) + proc1(2);                         -- Not allowed
call proc1(1) + 1;                                -- Not allowed
call proc1(proc2(x));                             -- Not allowed
select * from (call proc1(1));                    -- Not allowed
Copy

Innerhalb einer gespeicherten Prozedur kann die gespeicherte Prozedur jedoch eine andere gespeicherte Prozedur aufrufen oder sich selbst rekursiv aufrufen.

Vorsicht

Verschachtelte Aufrufe können die maximal zulässige Stapeltiefe überschreiten. Seien Sie daher vorsichtig, wenn Sie Aufrufe verschachteln, insbesondere bei Gebrauch der Rekursion.