Nommage et surcharge de procédures et d’UDFs¶
Lorsque vous créez ou appelez des procédures stockées ou des fonctions définies par l’utilisateur (UDF), vous devez être conscient des conventions de dénomination que Snowflake autorise et applique pour elles.
Vous pouvez également surcharger les procédures stockées et les UDFs, en fournissant différentes signatures pour une procédure ou une fonction donnée.
Note
La longueur du nom d’une fonction définie par l’utilisateur (la longueur combinée de son nom, de son type de retour et des noms de tous ses paramètres) ne doit pas dépasser 10 000 octets. Toute tentative de création d’une fonction dont le nom dépasse cette limite entraînera le message d’erreur suivant :
Function name (including parameter and return type) too long.
Choix d’un nom pour une procédure ou une UDF¶
Les noms des procédures et des UDFs doivent être conformes aux règles applicables aux Identificateurs d’objet.
Note
Snowflake ne permet pas de créer des fonctions avec le même nom que les fonctions définies par le système.
Appel d’une procédure ou d’une UDF¶
Lorsque vous créez une procédure stockée ou une UDF, vous la créez dans une base de données et un schéma spécifiés. Les procédures et les UDFs ont un nom pleinement qualifié défini par leur espace de noms sous la forme db.schema.procedure_or_function_name.
L’instruction suivante utilise le nom complet pour appeler une procédure stockée :
CALL mydatabase.myschema.myprocedure();
Lorsqu’elles sont appelées sans leur nom complet, les procédures et les UDFs sont résolues en fonction de la base de données et du schéma utilisés pour la session. Si vous avez spécifié un chemin de recherche, ce chemin de recherche est utilisé pour déterminer la fonction ou la procédure à appeler.
En revanche, de nombreuses fonctions intégrées et définies par le système fournies par Snowflake n’ont pas d’espace de noms. Par conséquent, vous pouvez les appeler depuis n’importe où.
Surcharge de procédures et de fonctions¶
Snowflake prend en charge la surcharge des procédures et des fonctions. Dans un schéma donné, vous pouvez définir plusieurs procédures ou fonctions qui ont le même nom, mais des signatures différentes. Les signatures doivent différer par le nombre d’arguments, le type des arguments ou les deux.
Par exemple, pour les 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) ...
Pour les procédures stockées :
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) ...
Si plusieurs signatures utilisent le même nombre d’arguments, mais ont des types d’arguments différents, vous pouvez utiliser des noms différents pour les arguments afin d’indiquer la signature à utiliser lorsque vous appelez la fonction ou la procédure.
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');
Note
Pour les commandes autres que celles qui appellent la fonction ou la procédure (par exemple l’exécution de DESCRIBE FUNCTION, DROP PROCEDURE, GRANT <privilèges>, etc.), vous devez utiliser les types de données des arguments pour identifier la signature à utiliser.
Appel de procédures et de fonctions surchargées¶
Comme pour l’appel de toute autre procédure ou fonction, vous pouvez spécifier les arguments par leur nom ou leur position.
SELECT myudf(text_input => 'hello world');
SELECT myudf('hello world');
Si vous omettez les noms des arguments ou si vous utilisez le même nom d’argument pour des arguments de types différents, Snowflake utilise le nombre d’arguments et les types des arguments pour déterminer la signature à utiliser. Dans ces situations, la conversion automatique des types (coercition) peut affecter la signature sélectionnée. Pour plus de détails, reportez-vous à Mise en garde concernant l’utilisation du type de données d’argument pour identifier la signature à appeler.
Mise en garde concernant l’utilisation du type de données d’argument pour identifier la signature à appeler¶
Si vous vous fiez au type de données de l’argument (plutôt qu’au nom de l’argument) pour identifier la signature de la fonction ou de la procédure à appeler, notez que la combinaison de la conversion de type automatique et de la surcharge peut favoriser la situation dans laquelle des erreurs utilisateurs mineures provoqueraient des résultats inattendus.
Prenons les exemples suivants, qui créent deux UDFs SQL nommés add5 :
CREATE OR REPLACE FUNCTION add5 (n NUMBER)
RETURNS NUMBER
AS 'n + 5';
CREATE OR REPLACE FUNCTION add5 (s VARCHAR)
RETURNS VARCHAR
AS
$$
s || '5'
$$;
Si vous appelez add5 et que vous spécifiez un argument numérique sans le nom de l’argument, la première implémentation est appelée. Si vous spécifiez un argument de type chaîne à la place, c’est la seconde implémentation qui est appelée.
Si l’argument n’est ni un nombre ni une chaîne, alors l’implémentation dépend des règles implicites de conversion de types de Snowflake. Par exemple, un argument de type date est converti en chaîne parce que la conversion de DATE en NUMBER n’est pas prise en charge. En conséquence, l’implémentation de la chaîne est appelée.
Par exemple :
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 |
+-----------------------------+
Pour éviter toute confusion, attribuez des noms d’arguments différents pour les différentes signatures et utilisez les noms d’arguments lors de l’appel de la fonction.
Dans l’exemple ci-dessus, les deux signatures utilisent des noms d’arguments différents (n pour l’argument NUMBER et s pour l’argument VARCHAR). Vous pouvez préciser la signature à utiliser en spécifiant le nom de l’argument :
SELECT add5(n => 1);
SELECT add5(s => '1');
Comment le chemin de recherche détermine la fonction ou la procédure à appeler¶
Si vous avez spécifié un chemin de recherche, chaque schéma apparaissant dans le chemin de recherche est recherché pour une fonction correspondante, dans l’ordre où le schéma apparaît dans le chemin de recherche. Pour chaque schéma recherché, Snowflake tente de trouver une fonction correspondante, en utilisant des conversions de type implicites si nécessaire. Si aucune correspondance n’est trouvée dans un schéma, le schéma suivant est pris en considération. Considérez à nouveau les fonctions de add5 , si elles étaient définies dans des schémas différents :
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''';
Le choix de la fonction à utiliser pour un argument numérique ou de type chaîne dépend du chemin de recherche :
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 |
+---------+
Le chemin de recherche étant défini sur le schéma de recherche s2 en premier, la fonction de s2 est utilisée, même si elle exige qu’une conversion de type implicite soit appliquée à l’argument.