Conventions de dénomination pour les procédures et les 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.

Les noms des procédures et des UDFs doivent être conformes aux règles applicables aux Identificateurs d’objet.

Forme de nom

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 complet défini par leur espace de noms, sous la forme db.schema.procedure_or_function_name

L’exemple suivant illustre la forme du nom d’une procédure stockée :

CALL temporary_db_qualified_names_test.temporary_schema_1.stproc_pi();
Copy

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.

En revanche, les 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

Snowflake prend en charge la surcharge des noms de procédures et de fonctions. Plusieurs procédures ou fonctions dans le même schéma peuvent porter le même nom, tant que leurs signatures diffèrent, soit par le nombre d’arguments soit par leur type. Lorsque vous appelez une procédure ou une fonction surchargée, Snowflake vérifie les arguments et appelle la bonne.

Note

Snowflake ne permet pas de créer des fonctions avec le même nom que les fonctions définies par le système.

Soyez prudent lorsque vous utilisez la surcharge. 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. Pour un exemple, voir Exemples de surcharge de noms de procédures stockées.

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 string)
  RETURNS string
  AS 's || ''5''';
Copy

Important

Dans la deuxième fonction ADD5, les guillemets simples sont utilisés pour effectuer un échappement du littéral de chaîne '5'. Les guillemets simples utilisés dans une définition UDF doivent être échappés par des guillemets simples.

Si add5 est appelé avec un argument numérique, alors la première implémentation est choisie, tandis qu’un argument de type chaîne utilise la seconde implémentation. 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 serait converti en une chaîne, et l’implémentation de la chaîne serait sélectionnée, puisque la conversion de DATE à NUMBER n’est pas prise en charge.

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                 |
+-----------------------------+
Copy

Prudence

Pour les UDFs écrites dans des langages autres que SQL, les règles peuvent différer.

UDF Exemples de surcharge de noms

L’exemple suivant montre comment la combinaison de la surcharge et de la conversion de type automatique peut favoriser l’obtention de résultats inattendus.

  1. Créez une fonction qui prend un paramètre FLOAT :

    CREATE FUNCTION add_pi(PARAM_1 FLOAT)
        RETURNS FLOAT
        LANGUAGE SQL
        AS $$
            PARAM_1 + 3.1415926::FLOAT
        $$;
    
    Copy
  2. Appelez la fonction deux fois. La première fois, transmettez un FLOAT. La deuxième fois, transmettez un VARCHAR. Le VARCHAR est converti en un FLOAT et la sortie de chaque appel est identique :

    SELECT add_pi(1.0), add_pi('1.0');
    +-------------+---------------+
    | ADD_PI(1.0) | ADD_PI('1.0') |
    |-------------+---------------|
    |   4.1415926 |     4.1415926 |
    +-------------+---------------+
    
    Copy
  3. Créez une fonction surchargée qui prend un paramètre VARCHAR :

    CREATE FUNCTION add_pi(PARAM_1 VARCHAR)
        RETURNS VARCHAR
        LANGUAGE SQL
        AS $$
            PARAM_1 || ' + 3.1415926'
        $$;
    
    Copy
  4. Utilisez les mêmes CALLs que précédemment. Notez la différence de sortie entre ces deux CALLs et les deux CALLs précédents.

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

Exemples de surcharge de noms de procédures stockées

L’exemple suivant montre comment la combinaison de la surcharge et de la conversion de type automatique peut favoriser l’obtention de résultats inattendus.

  1. Créez deux procédures stockées portant les mêmes noms, mais avec un nombre d’arguments différent.

    create or replace procedure stproc1(FLOAT_PARAM1 FLOAT)
        returns string
        language javascript
        strict
        as
        $$
        return FLOAT_PARAM1;
        $$
        ;
    
    Copy
    create or replace procedure stproc1(FLOAT_PARAM1 FLOAT, FLOAT_PARAM2 FLOAT)
        returns string
        language javascript
        strict
        as
        $$
        return FLOAT_PARAM1 * FLOAT_PARAM2;
        $$
        ;
    
    Copy
  2. Appelez les deux procédures :

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

Note

Vous devez également spécifier les types de données des arguments pour certaines autres opérations sur les procédures stockées. Par exemple, GRANT et REVOKE nécessitent les types d’arguments, ainsi que le nom de la procédure stockée.

L’exemple suivant de surcharge montre comment la combinaison de la surcharge et de la conversion de type automatique peut favoriser l’obtention de résultats inattendus :

  1. Créez une procédure stockée qui prend un paramètre FLOAT :

    CREATE PROCEDURE add_pi(PARAM_1 FLOAT)
        RETURNS FLOAT
        LANGUAGE JAVASCRIPT
        AS $$
            return PARAM_1 + 3.1415926;
        $$;
    
    Copy
  2. Appelez la procédure stockée deux fois. La première fois, transmettez un FLOAT. La deuxième fois, transmettez un VARCHAR. Le VARCHAR est converti en un FLOAT et la sortie de chaque appel est identique :

    CALL add_pi(1.0);
    +-----------+
    |    ADD_PI |
    |-----------|
    | 4.1415926 |
    +-----------+
    CALL add_pi('1.0');
    +-----------+
    |    ADD_PI |
    |-----------|
    | 4.1415926 |
    +-----------+
    
    Copy
  3. Créez une procédure stockée surchargée qui prend un paramètre VARCHAR :

    CREATE PROCEDURE add_pi(PARAM_1 VARCHAR)
        RETURNS VARCHAR
        LANGUAGE JAVASCRIPT
        AS $$
            return PARAM_1 + '3.1415926';
        $$;
    
    Copy
  4. Appelez la procédure stockée exactement comme précédemment. Notez la différence de sortie entre ces deux appels et les deux précédents.

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