Chamada de um procedimento armazenado¶

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 VARCHAR,
    second VARCHAR,
    third VARCHAR)
  RETURNS VARCHAR
  LANGUAGE SQL
  AS
  $$
  BEGIN
    RETURN first || second || third;
  END;
  $$;

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

CALL sp_concatenate_strings(
  first => 'one',
  second => 'two',
  third => 'three');

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

CALL sp_concatenate_strings(
  third => 'three',
  first => 'one',
  second => 'two');

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

CALL sp_concatenate_strings(
  'one',
  'two',
  'three');

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

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

+-------------------+
| BUILD_STRING_PROC |
|-------------------|
| pre-hello-post    |
+-------------------+

CALL build_string_proc('hello', 'before-');

+-------------------+
| 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');

+-------------------+
| BUILD_STRING_PROC |
|-------------------|
| pre-hello-after   |
+-------------------+

Exemplos¶

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

call stproc1(5.14::FLOAT);

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

CALL stproc1(2 * 5.14::FLOAT);

Um argumento pode ser uma subconsulta:

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

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

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

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