Chamada de um procedimento armazenado

Você pode chamar um procedimento armazenado usando o comando SQL CALL.

Para que um usuário possa chamar um procedimento armazenado, a função do usuário deve ter o privilégio USAGE para o procedimento armazenado.

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.

Especificação dos argumentos

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

Exemplos

Para executar um procedimento armazenado, use uma instrução CALL. Por exemplo:

call stproc1(5.14::FLOAT);
Copy

Cada argumento para um procedimento armazenado pode ser uma expressão geral:

CALL stproc1(2 * 5.14::FLOAT);
Copy

Um argumento pode ser uma subconsulta:

CALL stproc1(SELECT COUNT(*) FROM stproc_test_table1);
Copy

Você pode chamar apenas um procedimento armazenado por instrução CALL. Por exemplo, a seguinte instrução apresenta falha:

call proc1(1), proc2(2);                          -- Not allowed
Copy

Além disso, não se pode usar um procedimento armazenado CALL como parte de uma expressão. Por exemplo, todas as instruções a seguir apresentam falha:

call proc1(1) + proc1(2);                         -- Not allowed
call proc1(1) + 1;                                -- Not allowed
call proc1(proc2(x));                             -- Not allowed
select * from (call proc1(1));                    -- Not allowed
Copy

Entretanto, dentro de um procedimento armazenado, o procedimento armazenado pode chamar outro procedimento armazenado ou chamar a si mesmo recursivamente.

Cuidado

As chamadas aninhadas podem exceder a profundidade máxima permitida da pilha, portanto, tenha cuidado ao aninhar chamadas, especialmente ao usar recursão.