O Amazon Redshift não permitirá mais a criação de UDFs do Python a partir do Patch 198. As UDFs do Python existentes continuarão a funcionar normalmente até 30 de junho de 2026. Para ter mais informações, consulte a [publicação de blog ](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/). 

# CALL
<a name="r_CALL_procedure"></a>

Executa um procedimento armazenado. O comando CALL deve incluir o nome do procedimento e os valores do argumento de entrada. É obrigatório chamar um procedimento armazenado usando a instrução CALL.

**nota**  
CALL não pode fazer parte de qualquer consulta regular.

## Sintaxe
<a name="r_CALL_procedure-synopsis"></a>

```
CALL sp_name ( [ argument ] [, ...] )
```

## Parâmetros
<a name="r_CALL_procedure-parameters"></a>

 *sp\$1name*   
O nome do procedimento a ser executado. 

 *argument*   
O valor do argumento de entrada. Esse parâmetro também pode ser um nome de função, por exemplo, `pg_last_query_id()`. Não é possível usar consultas como argumentos para CALL. 

## Observações de uso
<a name="r_CALL_procedure-usage-notes"></a>

Os procedimentos armazenados do Amazon Redshift oferecem suporte a chamadas aninhadas e recursivas, conforme descrito a seguir. Além disso, verifique se o seu suporte ao driver está atualizado, também descrito a seguir.

**Topics**
+ [Chamadas aninhadas](#r_CALL_procedure-nested-calls)
+ [Suporte a drivers](#r_CALL_procedure-driver-support)

### Chamadas aninhadas
<a name="r_CALL_procedure-nested-calls"></a>

Os procedimentos armazenados do Amazon Redshift oferecem suporte a chamadas aninhadas e recursivas. O número máximo de níveis de aninhamento permitido é 16. Chamadas aninhadas podem encapsular lógica de negócios em procedimentos menores, que podem ser compartilhados por vários chamadores. 

Se você chamar um procedimento aninhado que tem parâmetros de saída, o procedimento interno deverá definir argumentos INOUT. Nesse caso, o procedimento interno será enviado em uma variável não constante. Argumentos OUT não são permitidos. Esse comportamento ocorre pois uma variável é necessária para conter a saída da chamada interna.

A relação entre os procedimentos interno e externo é registrada em log na coluna `from_sp_call` de [SVL\$1STORED\$1PROC\$1CALL](r_SVL_STORED_PROC_CALL.md). 

O exemplo a seguir mostra as variáveis enviadas a uma chamada de procedimento aninhado por meio de argumentos INOUT.

```
CREATE OR REPLACE PROCEDURE inner_proc(INOUT a int, b int, INOUT c int) LANGUAGE plpgsql
AS $$
BEGIN
  a := b * a;
  c := b * c;
END;
$$;

CREATE OR REPLACE PROCEDURE outer_proc(multiplier int) LANGUAGE plpgsql
AS $$
DECLARE
  x int := 3;
  y int := 4;
BEGIN
  DROP TABLE IF EXISTS test_tbl;
  CREATE TEMP TABLE test_tbl(a int, b varchar(256));
  CALL inner_proc(x, multiplier, y);
  insert into test_tbl values (x, y::varchar);
END;
$$;

CALL outer_proc(5);

SELECT * from test_tbl;
 a  | b
----+----
 15 | 20
(1 row)
```

### Suporte a drivers
<a name="r_CALL_procedure-driver-support"></a>

Recomendamos atualizar seus drivers de Java Database Connectivity (JDBC) e Open Database Connectivity (ODBC) para a versão mais recente com suporte para procedimentos armazenados do Amazon Redshift. 

Você poderá usar o driver existente se a sua ferramenta de cliente usar operações da API de driver que transmitem a instrução CALL para o servidor. Parâmetros de saída, se houver, são retornados como um conjunto de resultados de uma linha. 

As versões mais recentes dos drivers JDBC e ODBC do Amazon Redshift têm suporte a metadados para descoberta de procedimentos armazenados. Elas também têm suporte a `CallableStatement` para aplicativos Java personalizados. Para obter mais informações, consulte “[Conectar-se a um cluster Amazon Redshift usando ferramentas de cliente SQL](https://docs.aws.amazon.com/redshift/latest/mgmt/connecting-to-cluster.html)” no *Guia de gerenciamento de clusters do Amazon Redshift.* 

Os exemplos a seguir mostram como usar diferentes operações da API do driver de JDBC para chamadas de procedimentos armazenados.

```
void statement_example(Connection conn) throws SQLException {
  statement.execute("CALL sp_statement_example(1)");
}

void prepared_statement_example(Connection conn) throws SQLException {
  String sql = "CALL sp_prepared_statement_example(42, 84)";
  PreparedStatement pstmt = conn.prepareStatement(sql);
  pstmt.execute();
}

void callable_statement_example(Connection conn) throws SQLException {
  CallableStatement cstmt = conn.prepareCall("CALL sp_create_out_in(?,?)");
  cstmt.registerOutParameter(1, java.sql.Types.INTEGER);
  cstmt.setInt(2, 42);
  cstmt.executeQuery();
  Integer out_value = cstmt.getInt(1);
}
```

## Exemplos
<a name="r_CALL_procedure-examples"></a>

O exemplo a seguir chama o nome de procedimento `test_spl`.

```
call test_sp1(3,'book');
INFO:  Table "tmp_tbl" does not exist and will be skipped
INFO:  min_val = 3, f2 = book
```

O exemplo a seguir chama o nome de procedimento `test_spl2`.

```
call test_sp2(2,'2019');

         f2          | column2
---------------------+---------
 2019+2019+2019+2019 | 2
(1 row)
```