Aufrufen einer gespeicherten Prozedur

Sie können eine gespeicherte Prozedur auf eine von mehreren Arten aufrufen.

Tools für den Aufruf von Prozeduren

Wählen Sie das Tool zum Aufrufen der Prozedur.

Sprache

Ansatz

SQL

Führen Sie einen SQL-Befehl aus, z. B. über die Snowsight.

Führen Sie den Befehl SQL CALL aus, um eine Prozedur aufzurufen.

Java, Python, oder Scala mit Snowpark

Schreiben Sie Code lokal in einer der unterstützten Sprachen und lassen Sie den Aufruf in Snowflake ausführen.

Führen Sie Client-Code aus, der Snowpark-APIs in einer der folgenden Sprachen verwendet.

Befehlszeile

Erstellen und verwalten Sie Snowflake-Entitäten, indem Sie Befehle über die Befehlszeile ausführen.

Ausführen von Befehlen der Snowflake CLI:

Python

Schreiben Sie auf dem Client Code, der Verwaltungsoperationen auf Snowflake ausführt.

Führen Sie Code aus, der die Snowflake Python-API verwendet.

RESTful APIs (sprachunabhängig)

Stellen Sie Anfragen an RESTful-Endpunkte, um Snowflake Entitäten zu erstellen und zu verwalten.

Stellen Sie eine Anfrage zur Erstellung einer Prozedur mit Snowflake REST API

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 anonymer Prozedur). Das Erstellen und Aufrufen einer anonymen Prozedur erfordert keine Rolle mit CREATE PROCEDURE-Schemaberechtigungen.

Nutzungshinweise

  • Prozedurnamen sind im Schema nicht unbedingt eindeutig; gespeicherte Prozeduren werden durch ihre Argumenttypen sowie ihre Namen identifiziert und aufgelöst (d. h. gespeicherte Prozeduren können überladen werden).

  • Außerhalb des Snowflake Scripting-Blocks kann der von der gespeicherten Prozedur zurückgegebene Wert nicht verwendet werden, da der Aufruf nicht Teil eines Ausdrucks sein darf.

    In einem Snowflake Scripting-Block können Sie INTO :snowflake_scripting_variable angeben, um den Rückgabewert der gespeicherten Prozedur in einer Snowflake Scripting-Variablen zu erfassen.

  • Gespeicherte Prozeduren sind nicht atomar. Wenn eine Anweisung in einer gespeicherten Prozedur fehlschlägt, werden die anderen Anweisungen in der gespeicherten Prozedur nicht unbedingt zurückgesetzt. Weitere Informationen zu gespeicherten Prozeduren und Transaktionen finden Sie unter Transaktionsmanagement.

  • Sie können auch eine anonyme Prozedur mit CALL (mit anonymer Prozedur) erstellen und aufrufen.

Aufrufen einer gespeicherten Prozedur mit SQL

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   |
+-------------------+
Sprache: Deutsch