Aufrufen einer gespeicherten Prozedur¶

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 VARCHAR,
    second VARCHAR,
    third VARCHAR)
  RETURNS VARCHAR
  LANGUAGE SQL
  AS
  $$
  BEGIN
    RETURN first || second || third;
  END;
  $$;

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

CALL sp_concatenate_strings(
  first => 'one',
  second => 'two',
  third => 'three');

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

CALL sp_concatenate_strings(
  third => 'three',
  first => 'one',
  second => 'two');

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

CALL sp_concatenate_strings(
  'one',
  'two',
  'three');

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

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');

+-------------------+
| BUILD_STRING_PROC |
|-------------------|
| pre-hello-post    |
+-------------------+

CALL build_string_proc('hello', 'before-');

+-------------------+
| 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');

+-------------------+
| BUILD_STRING_PROC |
|-------------------|
| pre-hello-after   |
+-------------------+

Beispiele¶

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

call stproc1(5.14::FLOAT);

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

CALL stproc1(2 * 5.14::FLOAT);

Ein Argument kann eine Unterabfrage sein:

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

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

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

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