Como nomear e sobrecarregar 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.
Você também pode sobrecarregar procedimentos armazenados e UDFs, fornecendo assinaturas diferentes para um determinado procedimento ou função.
Como escolher um nome para um procedimento ou UDF¶
Os nomes dos procedimentos e UDFs devem estar em conformidade com as regras de Identificadores de objetos.
Nota
O Snowflake não permite criar funções com o mesmo nome de funções definidas pelo sistema.
Como chamar um procedimento ou UDF¶
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.
A instrução a seguir usa o nome totalmente qualificado para chamar um procedimento armazenado:
CALL mydatabase.myschema.myprocedure();
Quando chamado sem seu nome totalmente qualificado, procedimentos e UDFs são resolvidos de acordo com o banco de dados e esquema em uso para a sessão. Se você tiver especificado um caminho de pesquisa, esse caminho de pesquisa será usado para determinar a função ou procedimento para chamar.
Por outro lado, muitas das funções integradas definidas pelo sistema fornecidas pelo Snowflake não possuem namespace. Como resultado, você pode chamá-las de qualquer lugar.
Sobrecarga de procedimentos e funções¶
O Snowflake oferece suporte à sobrecarga de procedimentos e funções. Em um determinado esquema, você pode definir vários procedimentos ou funções com o mesmo nome, mas assinaturas diferentes. As assinaturas devem diferir pelo número de argumentos, pelos tipos de argumentos ou por ambos.
Por exemplo, para 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) ...
Para procedimentos armazenados:
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) ...
Se várias assinaturas usarem o mesmo número de argumentos, mas tiverem diferentes tipos de argumentos, você poderá usar nomes diferentes para os argumentos para indicar qual assinatura usar ao chamar a função ou procedimento.
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');
Nota
Para comandos diferentes daqueles que chamam a função ou procedimento (por exemplo, executar DESCRIBE FUNCTION, DROP PROCEDURE, GRANT <privilégios> etc.), você deve usar os tipos de dados dos argumentos para identificar a assinatura a ser usada.
Como chamar as funções e procedimentos sobrecarregados¶
Como é o caso de chamar qualquer outro procedimento ou função, você pode especificar os argumentos por nome ou por posição.
SELECT myudf(text_input => 'hello world');
SELECT myudf('hello world');
Se você omitir os nomes dos argumentos ou usar o mesmo nome de argumento para argumentos de tipos diferentes, o Snowflake usará o número de argumentos e os tipos de argumentos para determinar a assinatura a ser usada. Nesses casos, a conversão automática de tipo (coerção) pode afetar a assinatura selecionada. Para obter mais detalhes, consulte Nota sobre como confiar no tipo de dados do argumento para identificar a assinatura a ser chamada.
Nota sobre como confiar no tipo de dados do argumento para identificar a assinatura a ser chamada¶
Se você estiver contando com o tipo de dados do argumento (em vez do nome do argumento) para identificar a assinatura da função ou procedimento a ser chamado, observe que a combinação de conversão automática de tipo e sobrecarga facilita que pequenos erros do usuário causem erros inesperados resultados.
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 VARCHAR)
RETURNS VARCHAR
AS
$$
s || '5'
$$;
Se você chamar add5 e especificar um argumento numérico sem o nome do argumento, a primeira implementação será chamada. Se você especificar um argumento do tipo cadeia de caracteres, a segunda implementação será chamada.
Se o argumento não for um número nem uma cadeia de caracteres, a implementação dependerá das regras implícitas de conversão de tipo do Snowflake. Por exemplo, um argumento do tipo data é convertido em uma cadeia de caracteres porque a conversão de DATE para NUMBER não é suportada. Como resultado, a implementação da cadeia de caracteres é chamada.
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 |
+-----------------------------+
Para evitar possíveis confusões, atribua nomes de argumentos diferentes para assinaturas diferentes e use os nomes dos argumentos ao chamar a função.
No exemplo acima, as duas assinaturas usam nomes de argumentos diferentes (n para o argumento NUMBER e s para o argumento VARCHAR). Você pode especificar qual assinatura deve ser usada especificando o nome do argumento:
SELECT add5(n => 1);
SELECT add5(s => '1');
Como o caminho de pesquisa determina qual função ou procedimento chamar¶
Se você tiver especificado um caminho de pesquisa, cada esquema que aparece no caminho de pesquisa será pesquisado em busca de uma função correspondente, na ordem em que o esquema aparece no caminho de pesquisa. Para cada esquema pesquisado, o Snowflake tenta encontrar uma função correspondente, usando conversões de tipo implícitas, se necessário. Se nenhuma correspondência for encontrada em um esquema, o próximo esquema será considerado. Considere novamente as funções add5, se fossem definidas em esquemas diferentes:
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''';
A escolha de qual função usar para um argumento numérico ou cadeia de caracteres dependeria do caminho de pesquisa:
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 |
+---------+
Com o caminho de pesquisa definido como esquema de pesquisa s2 primeiro, a função em s2 é usado, mesmo que exija que uma conversão de tipo implícita seja aplicada ao argumento.