Benennen und Überladen von 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.
Sie können auch gespeicherte Prozeduren und UDFs überladen und so verschiedene Signaturen für eine bestimmte Prozedur oder Funktion bereitstellen.
Bemerkung
Die Länge des Namens einer benutzerdefinierten Funktion – die gesamte Länge ihres Namens, des Rückgabetyps und der Namen aller ihrer Parameter – darf 10.000 Bytes nicht überschreiten. Der Versuch, eine Funktion zu erstellen, deren Name diese Grenze überschreitet, führt zu der folgenden Fehlermeldung:
Function name (including parameter and return type) too long.
Auswählen eines Namens für eine Prozedur oder UDF¶
Namen für Prozeduren und UDFs müssen mit den Regeln für Objektbezeichner übereinstimmen.
Bemerkung
Allerdings erlaubt Snowflake keine Erstellung von Funktionen, die den gleichen Namen tragen wie eine systemdefinierte Funktion.
Aufrufen einer Prozedur oder UDF¶
Wenn Sie eine gespeicherte Prozedur oder UDF erstellen, erstellen Sie sie 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 Anweisung verwendet den vollqualifizierten Namen, um eine gespeicherte Prozedur aufzurufen:
CALL mydatabase.myschema.myprocedure();
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. Wenn Sie einen Suchpfad angegeben haben, wird dieser Suchpfad verwendet, um die aufzurufende Funktion oder Prozedur zu bestimmen.
Im Gegensatz dazu haben viele der integrierten systemdefinierten Funktionen von Snowflake keinen Namespace. Diese können von überall aus aufgerufen werden.
Überladen von Prozeduren und Funktionen¶
Snowflake unterstützt das Überladen von Prozeduren und Funktionen. In einem bestimmten Schema können Sie mehrere Prozeduren oder Funktionen definieren, die denselben Namen, aber unterschiedliche Signaturen haben. Die Signaturen müssen sich durch die Anzahl der Argumente, die Typen der Argumente oder beides unterscheiden.
Beispiel für UDFs:
CREATE OR REPLACE FUNCTION myudf (number_argument NUMBER) ...
CREATE OR REPLACE FUNCTION myudf (varchar_argument VARCHAR) ...
CREATE OR REPLACE FUNCTION myudf (number_argument NUMBER, varchar_argument VARCHAR) ...
Beispiel für gespeicherte Prozeduren:
CREATE OR REPLACE PROCEDURE myproc (number_argument NUMBER) ...
CREATE OR REPLACE PROCEDURE myproc (varchar_argument VARCHAR) ...
CREATE OR REPLACE PROCEDURE myproc (number_argument NUMBER, varchar_argument VARCHAR) ...
Wenn mehrere Signaturen die gleiche Anzahl von Argumenten verwenden, aber unterschiedliche Typen von Argumenten haben, können Sie unterschiedliche Namen für die Argumente verwenden, um anzugeben, welche Signatur beim Aufrufen der Funktion oder Prozedur verwendet werden soll.
CREATE OR REPLACE FUNCTION echo_input (numeric_input NUMBER)
RETURNS NUMBER
AS 'numeric_input';
CREATE OR REPLACE FUNCTION echo_input (varchar_input VARCHAR)
RETURNS VARCHAR
AS 'varchar_input';
SELECT echo_input(numeric_input => 10);
SELECT echo_input(varchar_input => 'hello world');
Bemerkung
Für andere Befehle als die, die die Funktion oder Prozedur aufrufen (z. B. für das Ausführen von DESCRIBE FUNCTION, DROP PROCEDURE, GRANT <Berechtigungen> usw.), müssen Sie die Datentypen der Argumente verwenden, um die zu verwendende Signatur zu identifizieren.
Aufrufen von überladenen Prozeduren und Funktionen¶
Wie beim Aufrufen jeder anderen Prozedur oder Funktion können Sie die Argumente über den Namen oder über die Position angeben.
SELECT myudf(text_input => 'hello world');
SELECT myudf('hello world');
Wenn Sie die Argumentnamen weglassen oder wenn Sie denselben Argumentnamen für Argumente unterschiedlichen Typs verwenden, verwendet Snowflake die Anzahl der Argumente und die Typen der Argumente, um die zu verwendende Signatur zu bestimmen. In diesen Fällen kann die automatische Typkonvertierung (Koersion) die ausgewählte Signatur beeinflussen. Weitere Informationen dazu finden Sie unter Warnung vor Verwendung des Argument-Datentyps zum Identifizieren der aufzurufenden Signatur.
Warnung vor Verwendung des Argument-Datentyps zum Identifizieren der aufzurufenden Signatur¶
Wenn Sie sich auf den Datentyp des Arguments (und nicht auf den Namen des Arguments) verlassen, um die Signatur der aufzurufenden Funktion oder Prozedur zu identifizieren, müssen Sie beachten, dass bei einer Kombination aus automatischer Typkonvertierung und Überladung kleinste Fehler der Benutzer leicht zu unerwartete Ergebnissen führen können.
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 VARCHAR)
RETURNS VARCHAR
AS
$$
s || '5'
$$;
Wenn Sie add5 aufrufen und ein numerisches Argument ohne den Namen des Arguments angeben, wird die erste Implementierung aufgerufen. Wenn Sie stattdessen ein Zeichenfolgenargument angeben, wird die zweite Implementierung aufgerufen.
Wenn das Argument weder eine Zahl noch eine Zeichenfolge ist, hängt die verwendete Implementierung von den impliziten Typkonvertierungsregeln von Snowflake ab. Ein Argument mit Datumstyp wird beispielsweise in eine Zeichenfolge umgewandelt, da die Umwandlung von DATE in NUMBER nicht unterstützt wird. Infolgedessen wird die Zeichenfolgen-Implementierung aufgerufen.
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 |
+-----------------------------+
Um mögliche Verwechslungen zu vermeiden, vergeben Sie unterschiedliche Argumentnamen für verschiedene Signaturen, und verwenden Sie die Argumentnamen, wenn Sie die Funktion aufrufen.
In dem obigen Beispiel verwenden die beiden Signaturen unterschiedliche Argumentnamen (n für das NUMBER-Argument und s für das VARCHAR-Argument). Sie können angeben, welche Signatur verwendet werden soll, indem Sie den Namen des Arguments angeben:
SELECT add5(n => 1);
SELECT add5(s => '1');
Wie der Suchpfad bestimmt, welche Funktion oder Prozedur aufgerufen werden soll¶
Wenn Sie einen Suchpfad angegeben haben, wird jedes Schema, das im Suchpfad erscheint, nach einer übereinstimmenden Funktion durchsucht, und zwar in der Reihenfolge, in der das Schema im Suchpfad erscheint. Für jedes durchsuchte Schema versucht Snowflake, eine passende Funktion zu finden, gegebenenfalls unter Verwendung impliziter Typkonvertierungen. Wenn in einem Schema keine Übereinstimmung gefunden wird, wird das nächste Schema berücksichtigt. Betrachten Sie noch einmal die add5-Funktionen, wenn diese in verschiedenen Schemas definiert wären:
USE SCHEMA s1;
CREATE OR REPLACE FUNCTION add5 ( n number)
RETURNS number
AS 'n + 5';
USE SCHEMA s2;
CREATE OR REPLACE FUNCTION add5 ( s string)
RETURNS string
AS 's || ''5''';
Welche Funktion für ein numerisches Argument oder ein Zeichenfolgenargument zu verwenden ist, hängt vom Suchpfad ab:
USE SCHEMA s3;
ALTER SESSION SET SEARCH_PATH='s1,s2';
SELECT add5(5);
+---------+
| ADD5(5) |
+---------+
| 10 |
+---------+
ALTER SESSION SET SEARCH_PATH='s2,s1';
SELECT add5(5);
+---------+
| ADD5(5) |
*---------+
| 55 |
+---------+
Wenn der Suchpfad so eingestellt ist, dass zuerst das Schema s2 durchsucht wird, wird die Funktion in s2 verwendet, auch wenn diese eine implizite Typkonvertierung für das Argument erfordert.