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

Quando você criar ou chamar procedimentos armazenados ou funções definidas pelo usuário (UDF), você precisará estar ciente das convenções de nomenclatura que o Snowflake permite e aplica para eles.

Os nomes dos procedimentos e UDFs devem estar em conformidade com as regras de Identificadores de objetos.

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();
Copy

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.

Nota

O Snowflake não permite criar funções com o mesmo nome de funções definidas pelo sistema.

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''';
Copy

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

Cuidado

Para UDFs escritas em outras linguagens que não SQL, as regras podem ser diferentes.

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
    $$;
    Copy

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

  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'
    $$;
    Copy

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

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

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

Nota

Você também deve especificar os tipos de dados dos argumentos para algumas outras operações em procedimentos armazenados. Por exemplo, GRANT e REVOKE exigem os tipos de argumento, assim como o nome do procedimento armazenado.

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;
    $$;
    Copy

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

  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';
    $$;
    Copy

  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 |
+--------------+
    Copy
Linguagem: Português