Namenskonventionen für gespeicherte Prozeduren und UDFs

Wenn Sie gespeicherte Prozeduren oder benutzerdefinierte Funktionen (UDF) erstellen oder aufrufen, müssen Sie die Namenskonventionen beachten, die von Snowflake zugelassen und erzwungen wird.

Namen für Prozeduren und UDFs müssen mit den Regeln für Objektbezeichner übereinstimmen.

Namensformat

Wenn Sie eine gespeicherte Prozedur oder UDF erstellen, erstellen Sie diese in einer bestimmten Datenbank und einem bestimmten Schema. Prozeduren und UDFs haben einen durch ihren Namespace definierten, vollqualifizierten Namen im Format db.schema.procedure_or_function_name.

Die folgende Abbildung zeigt das Namensformat für gespeicherte Prozeduren:

CALL temporary_db_qualified_names_test.temporary_schema_1.stproc_pi();

Beim Aufrufen ohne den vollqualifizierten Namen werden Prozeduren und UDFs für die aktuell in der Sitzung verwendete Datenbank und das aktuell verwendete Schema aufgelöst.

Im Gegensatz dazu haben die integrierten systemdefinierten Funktionen von Snowflake keinen Namespace. Diese können von überall aus aufgerufen werden.

Überladen von Namen

Snowflake unterstützt das Überladen von Prozedur- und Funktionsnamen. Verschiedene in demselben Schema gespeicherte Prozeduren und Funktionen können den gleichen Namen haben, sofern sich ihre Signaturen unterscheiden, entweder durch die Anzahl der Argumente oder durch die Argumenttypen. Wenn Sie eine überladene Prozedur oder Funktion aufrufen, überprüft Snowflake die Argumente und ruft die korrekte Funktion auf.

Bemerkung

Allerdings erlaubt Snowflake keine Erstellung von Funktionen, die den gleichen Namen tragen wie eine systemdefinierte Funktion.

Seien Sie vorsichtig, wenn Sie die Überladung verwenden. Durch die Kombination aus automatischer Typkonvertierung und Überladung können kleine Benutzerfehler schnell zu unerwarteten Ergebnissen führen. Ein Beispiel dazu finden Sie unter Beispiele für das Überladen der Namen von gespeicherten Prozeduren.

Betrachten Sie die folgenden Beispiele, in denen zwei SQL-UDFs mit dem Namen add5 erstellt werden:

CREATE OR REPLACE FUNCTION add5 (n number)
  RETURNS number
  AS 'n + 5';

CREATE OR REPLACE FUNCTION add5 (s string)
  RETURNS string
  AS 's || ''5''';

Wichtig

In der zweiten ADD5-Funktion werden einfache Anführungszeichen verwendet, um das Zeichenfolgenliteral '5' zu umgehen. Alle einfachen Anführungszeichen, die in einer UDF-Definition verwendet werden, müssen mit einfachen Anführungszeichen als Escape-Zeichen eingeschlossen werden.

Wenn add5 mit einem numerischen Argument aufgerufen wird, wird die erste Implementierung ausgewählt, während ein Zeichenfolgenargument die zweite Implementierung verwendet. Wenn das Argument weder eine Zahl noch eine Zeichenfolge ist, hängt die Implementierung von den impliziten Typkonvertierungsregeln von Snowflake ab. Beispielsweise wird ein Argument mit Datumstyp in eine Zeichenfolge konvertiert und die Implementierung der Zeichenfolge wird ausgewählt, da die Konvertierung von DATE in NUMBER nicht unterstützt wird.

Beispiel:

select add5(1);

+---------+
| ADD5(1) |
|---------|
|       6 |
+---------+

select add5('1');

+-----------+
| ADD5('1') |
|-----------|
| 15        |
+-----------+

select add5('hello');

+---------------+
| ADD5('HELLO') |
|---------------|
| hello5        |
+---------------+

select add5(to_date('2014-01-01'));

+-----------------------------+
| ADD5(TO_DATE('2014-01-01')) |
|-----------------------------|
| 2014-01-015                 |
+-----------------------------+

Vorsicht

Für UDFs, die nicht in SQL geschrieben sind, können abweichende Regeln gelten.

Beispiele für das Überladen von UDF-Namen

Das folgende Beispiel zeigt, wie durch die Kombination von Überladung und automatischer Typkonvertierung unerwartete Ergebnisse auftreten können:

  1. Erstellen Sie eine Funktion mit einem FLOAT-Parameter:

    CREATE FUNCTION add_pi(PARAM_1 FLOAT)
    RETURNS FLOAT
    LANGUAGE SQL
    AS $$
        PARAM_1 + 3.1415926::FLOAT
    $$;

  2. Rufen Sie die Funktion zweimal auf: Übergeben Sie beim ersten Mal einen FLOAT-Wert. Übergeben Sie beim zweiten Mal eine VARCHAR-Wert. Der VARCHAR-Wert wird in einen FLOAT-Wert konvertiert, und die Ausgabe jedes Aufrufs ist identisch:

    SELECT add_pi(1.0), add_pi('1.0');
+-------------+---------------+
| ADD_PI(1.0) | ADD_PI('1.0') |
|-------------+---------------|
|   4.1415926 |     4.1415926 |
+-------------+---------------+

  3. Erstellen Sie eine überladene Funktion mit einem VARCHAR-Parameter:

    CREATE FUNCTION add_pi(PARAM_1 VARCHAR)
    RETURNS VARCHAR
    LANGUAGE SQL
    AS $$
        PARAM_1 || ' + 3.1415926'
    $$;

  4. Verwenden Sie dieselben CALLs wie zuvor. Beachten Sie den Unterschied in der Ausgabe zwischen diesen beiden CALLs und den beiden vorherigen CALLs.

    SELECT add_pi(1.0), add_pi('1.0');
+-------------+-----------------+
| ADD_PI(1.0) | ADD_PI('1.0')   |
|-------------+-----------------|
|   4.1415926 | 1.0 + 3.1415926 |
+-------------+-----------------+

Beispiele für das Überladen der Namen von gespeicherten Prozeduren

Das folgende Beispiel zeigt, wie durch die Kombination von Überladung und automatischer Typkonvertierung unerwartete Ergebnisse auftreten können:

  1. Erstellen Sie zwei gespeicherte Prozeduren, die denselben Namen, aber unterschiedlich viele Argumente haben.

    create or replace procedure stproc1(FLOAT_PARAM1 FLOAT)
    returns string
    language javascript
    strict
    as
    $$
    return FLOAT_PARAM1;
    $$
    ;

    create or replace procedure stproc1(FLOAT_PARAM1 FLOAT, FLOAT_PARAM2 FLOAT)
    returns string
    language javascript
    strict
    as
    $$
    return FLOAT_PARAM1 * FLOAT_PARAM2;
    $$
    ;

  2. Rufen Sie die beiden Prozeduren auf:

    call stproc1(5.14::FLOAT);
+---------+
| STPROC1 |
|---------|
| 5.14    |
+---------+

    call stproc1(5.14::FLOAT, 2.00::FLOAT);
+---------+
| STPROC1 |
|---------|
| 10.28   |
+---------+

Bemerkung

Für einige andere Operationen auf gespeicherten Prozeduren müssen Sie auch die Datentypen der Argumente angeben. Beispielsweise erfordern GRANT und REVOKE die Argumenttypen sowie den Namen der gespeicherten Prozedur.

Das nächste Beispiel für Überladung zeigt, wie durch die Kombination von Überladung und automatischer Typkonvertierung unerwartete Ergebnisse auftreten können:

  1. Erstellen Sie eine gespeicherte Prozedur mit einem FLOAT-Parameter:

    CREATE PROCEDURE add_pi(PARAM_1 FLOAT)
    RETURNS FLOAT
    LANGUAGE JAVASCRIPT
    AS $$
        return PARAM_1 + 3.1415926;
    $$;

  2. Rufen Sie die gespeicherte Prozedur auf: Übergeben Sie beim ersten Mal einen FLOAT-Wert. Übergeben Sie beim zweiten Mal eine VARCHAR-Wert. Der VARCHAR-Wert wird in einen FLOAT-Wert konvertiert, und die Ausgabe jedes Aufrufs ist identisch:

    CALL add_pi(1.0);
+-----------+
|    ADD_PI |
|-----------|
| 4.1415926 |
+-----------+
CALL add_pi('1.0');
+-----------+
|    ADD_PI |
|-----------|
| 4.1415926 |
+-----------+

  3. Erstellen Sie eine überladene gespeicherte Prozedur mit einem VARCHAR-Parameter:

    CREATE PROCEDURE add_pi(PARAM_1 VARCHAR)
    RETURNS VARCHAR
    LANGUAGE JAVASCRIPT
    AS $$
        return PARAM_1 + '3.1415926';
    $$;

  4. Rufen Sie die gespeicherte Prozedur exakt genauso wie zuvor auf. Beachten Sie den Unterschied in der Ausgabe zwischen diesen beiden Aufrufen und den beiden vorherigen Aufrufen.

    CALL add_pi(1.0);
+-----------+
|    ADD_PI |
|-----------|
| 4.1415926 |
+-----------+
CALL add_pi('1.0');
+--------------+
| ADD_PI       |
|--------------|
| 1.03.1415926 |
+--------------+
Sprache: Deutsch