Chamada de um procedimento armazenado

Você pode chamar um procedimento armazenado de várias maneiras.

Ferramentas para chamar procedimentos

Escolha a ferramenta para chamar o procedimento.

Linguagem

Abordagem

SQL

Execute um comando SQL, por exemplo, usando Snowsight.

Execute o comando SQL CALL para chamar um procedimento.

Java, Python ou Scala com Snowpark

Escreva o código localmente em uma das linguagens compatíveis, fazendo com que a chamada seja executada no Snowflake.

Execute o código do cliente que usa as Snowpark APIs em um dos seguintes idiomas.

Linha de comando

Crie e gerencie entidades Snowflake executando comandos a partir da linha de comando.

Execute comandos do Snowflake CLI:

Python

No cliente, escreva o código que executa operações de gerenciamento no Snowflake.

Execute o código que usa a Snowflake Python API.

RESTful APIs (independente da linguagem)

Faça solicitações de pontos de extremidade RESTful para criar e gerenciar entidades Snowflake.

Faça uma solicitação para criar um procedimento usando a Snowflake REST API

Depois de ter os privilégios para chamar o procedimento armazenado, você pode usar uma instrução CALL para chamar o procedimento armazenado.

Nota

Para criar e chamar um procedimento anônimo, use CALL (com procedimento anônimo). Criar e chamar um procedimento anônimo não exige uma função com privilégios de esquema CREATE PROCEDURE.

Notas de uso

  • Os nomes dos procedimentos não são necessariamente únicos dentro do esquema; os procedimentos armazenados são identificados e resolvidos por seus tipos de argumentos, assim como seus nomes (ou seja, os procedimentos armazenados podem ser sobrecarregados).

  • Fora de um bloco do Script Snowflake, o valor retornado pelo procedimento armazenado não pode ser utilizado, pois a chamada não pode fazer parte de uma expressão.

    Em um bloco do Script Snowflake, você pode especificar INTO :snowflake_scripting_variable para capturar o valor de retorno de um procedimento armazenado em uma variável do Script Snowflake.

  • Os procedimentos armazenados não são atômicos; se uma instrução em um procedimento armazenado falhar, as outras instruções no procedimento armazenado não são necessariamente revertidas. Para obter mais informações sobre procedimentos armazenados e transações, consulte Gerenciamento de transações.

  • Você também pode criar e chamar um procedimento anônimo usando CALL (com procedimento anônimo).

Chamada de um procedimento armazenado com SQL

Se o procedimento armazenado tiver argumentos, você poderá especificar esses argumentos por nome ou por posição.

Por exemplo, o seguinte procedimento armazenado aceita três argumentos:

CREATE OR REPLACE PROCEDURE sp_concatenate_strings(
    first_arg VARCHAR,
    second_arg VARCHAR,
    third_arg VARCHAR)
  RETURNS VARCHAR
  LANGUAGE SQL
  AS
  $$
  BEGIN
    RETURN first_arg || second_arg || third_arg;
  END;
  $$;
Copy

Ao chamar o procedimento, você pode especificar os argumentos por nome:

CALL sp_concatenate_strings(
  first_arg => 'one',
  second_arg => 'two',
  third_arg => 'three');
Copy
+------------------------+
| SP_CONCATENATE_STRINGS |
|------------------------|
| onetwothree            |
+------------------------+

Se você especificar os argumentos por nome, não precisará especificar os argumentos em nenhuma ordem específica:

CALL sp_concatenate_strings(
  third_arg => 'three',
  first_arg => 'one',
  second_arg => 'two');
Copy
+------------------------+
| SP_CONCATENATE_STRINGS |
|------------------------|
| onetwothree            |
+------------------------+

Você também pode especificar os argumentos por posição:

CALL sp_concatenate_strings(
  'one',
  'two',
  'three');
Copy
+------------------------+
| SP_CONCATENATE_STRINGS |
|------------------------|
| onetwothree            |
+------------------------+

Observe o seguinte:

  • Você deve especificar todos os argumentos por nome ou por posição. Você não pode especificar alguns dos argumentos por nome e outros argumentos por posição.

    Ao especificar um argumento por nome, você não pode usar aspas duplas no nome do argumento.

  • Se duas funções ou dois procedimentos tiverem o mesmo nome, mas tipos de argumento diferentes, você poderá usar os nomes dos argumentos para especificar qual função ou procedimento executar, se os nomes dos argumentos forem diferentes. Consulte Sobrecarga de procedimentos e funções.

Especificação dos argumentos opcionais

Se o procedimento armazenado tiver argumentos opcionais, você poderá omitir os argumentos opcionais na chamada. Cada argumento opcional possui um valor padrão que é usado quando o argumento é omitido.

Por exemplo, o procedimento armazenado a seguir possui um argumento obrigatório e dois argumentos opcionais. Cada argumento opcional possui um valor padrão.

CREATE OR REPLACE PROCEDURE build_string_proc(
    word VARCHAR,
    prefix VARCHAR DEFAULT 'pre-',
    suffix VARCHAR DEFAULT '-post'
  )
  RETURNS VARCHAR
  LANGUAGE SQL
  AS
  $$
    BEGIN
      RETURN prefix || word || suffix;
    END;
  $$
  ;
Copy

Você pode omitir qualquer um dos argumentos opcionais na chamada. Quando você omite um argumento, o valor padrão do argumento é usado.

CALL build_string_proc('hello');
Copy
+-------------------+
| BUILD_STRING_PROC |
|-------------------|
| pre-hello-post    |
+-------------------+

CALL build_string_proc('hello', 'before-');
Copy
+-------------------+
| BUILD_STRING_PROC |
|-------------------|
| before-hello-post |
+-------------------+

Se precisar omitir um argumento opcional e especificar outro argumento opcional que apareça após o argumento omitido na assinatura, use argumentos nomeados, em vez de argumentos posicionais.

Por exemplo, suponha que você queira omitir o argumento prefix e especificar o argumento suffix. O argumento suffix aparece após prefix na assinatura, portanto você deve especificar os argumentos por nome:

CALL build_string_proc(word => 'hello', suffix => '-after');
Copy
+-------------------+
| BUILD_STRING_PROC |
|-------------------|
| pre-hello-after   |
+-------------------+
Linguagem: Português