Convenções de nomeação para procedimentos e UDFs¶

Formulário de nome¶

Quando você cria um procedimento armazenado ou UDF, você o cria em um banco de dados e esquema especificados. Procedimentos e UDFs têm um nome totalmente qualificado definido por seu namespace, na forma de db.schema.procedure_or_function_name.

O seguinte ilustra a forma do nome de um procedimento armazenado:

CALL temporary_db_qualified_names_test.temporary_schema_1.stproc_pi();

Quando chamadas sem seu nome totalmente qualificado, os procedimentos e UDFs são resolvidas de acordo com o banco de dados e esquema em uso para a sessão.

Em contraste, as funções integradas e definidas pelo sistema fornecidas pelo Snowflake não têm namespace. Como resultado, você pode chamá-las de qualquer lugar.

Sobrecarga¶

O Snowflake oferece suporte à sobrecarga de nomes de procedimentos e funções. Vários procedimentos ou funções no mesmo esquema podem ter o mesmo nome, desde que suas assinaturas sejam diferentes, seja pelo número de argumentos ou pelos tipos de argumento. Quando você chama um procedimento ou função sobrecarregada, Snowflake verifica os argumentos e chama o procedimento correto.

Tenha cuidado ao utilizar a sobrecarga. A combinação da conversão automática do tipo com a sobrecarga facilita a obtenção de resultados inesperados causados por erros pequenos do usuário. Para obter um exemplo, consulte Exemplos de sobrecarga do nome de procedimento armazenado.

Considere os seguintes exemplos, que criam dois SQL UDFs chamadas 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''';

Importante

Na segunda função ADD5, aspas simples são usadas como escape da cadeia de caracteres literal '5'. Quaisquer aspas simples usadas em uma definição de UDF devem ter aspas simples como escape.

Se add5 é chamada com um argumento numérico, a primeira implementação é escolhida, enquanto um argumento do tipo cadeia de caracteres utiliza a segunda implementação. Se o argumento não for um número nem uma cadeia de caracteres, então a implementação depende das regras implícitas de conversão de tipo do Snowflake. Por exemplo, um argumento do tipo data seria convertido em uma cadeia de caracteres, e a implementação da cadeia de caracteres seria selecionada, porque a conversão de DATE para NUMBER não é aceita.

Por exemplo:

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

Exemplos de sobrecarga de nome de UDF¶

Os próximos exemplos mostram como a combinação da sobrecarga com a conversão automática do tipo pode facilitar a obtenção de resultados inesperados.

1. Crie uma função que tenha um parâmetro FLOAT:

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

2. Chame a função duas vezes. Na primeira vez, passe um FLOAT. Na segunda vez, passe um VARCHAR. O VARCHAR é convertido em um FLOAT, e a saída de cada chamada é idêntica:

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

3. Crie uma função sobrecarregada que usa um parâmetro VARCHAR:

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

4. Use o mesmo CALLs que antes. Observe a diferença na saída entre essas duas CALLs e as duas CALLs anteriores.

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

Exemplos de sobrecarga do nome de procedimento armazenado¶

Os próximos exemplos mostram como a combinação da sobrecarga com a conversão automática do tipo pode facilitar a obtenção de resultados inesperados.

1. Crie dois procedimentos armazenados que tenham os mesmos nomes, mas números diferentes de argumentos.

   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. Chame os dois procedimentos:

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

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

O próximo exemplo de sobrecarga mostra como a combinação da sobrecarga com a conversão automática do tipo pode facilitar a obtenção de resultados inesperados:

1. Crie um procedimento armazenado que tenha um parâmetro FLOAT:

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

2. Chame duas vezes o procedimento armazenado. Na primeira vez, passe um FLOAT. Na segunda vez, passe um VARCHAR. O VARCHAR é convertido em um FLOAT, e a saída de cada chamada é idêntica:

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

3. Crie um procedimento armazenado sobrecarregado que usa um parâmetro VARCHAR:

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

4. Chame o procedimento armazenado exatamente como antes. Observe a diferença na saída entre essas duas chamadas e as duas chamadas anteriores.

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