O Amazon Redshift deixará de oferecer suporte ao uso de UDFs em Python após 30 de junho de 2026. Começaremos a aplicar essa alteração em fases. Consulte mais informações sobre os detalhes do fim da vida útil do Python e as opções de migração na [publicação do blog](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/) publicada em 30 de junho de 2025.
# Usar a API de metadados do driver do Amazon Redshift para aplicativos e ferramentas
Para aplicativos e ferramentas que se conectam ao Amazon Redshift, como uma ferramenta de inteligência de negócios ou um editor de consultas, recomendamos que você use a API de metadados do driver fornecida pelos drivers [JDBC 2.x](jdbc20-install.md), [ODBC 2.x](odbc20-install.md) ou [Python](python-redshift-driver.md) do Amazon Redshift para descobrir metadados sobre objetos do seu data warehouse, incluindo bancos de dados, esquemas, tabelas, colunas e tipos de dados. Se preferir, você também pode usar os comandos `SHOW` do Amazon Redshift.
Use a API de metadados do driver para obter os seguintes benefícios:
+ **Compatibilidade com a especificação**. Os drivers JDBC e ODBC implementam interfaces de metadados padrão (`DatabaseMetaData` no JDBC, `SQLTables` e `SQLColumns` no ODBC). Como a DB-API do Python (PEP 249) não define uma especificação de API de metadados, o driver Python do Amazon Redshift segue a especificação JDBC DatabaseMetaData, fornecendo métodos equivalentes, como `get_tables()`, `get_columns()` e `get_schemas()`. Essas APIs seguem especificações bem definidas, de modo que seu código de integração é portátil. Conforme as tabelas de sistema internas do Amazon Redshift evoluem, seu aplicativo não precisa mudar.
+ **Desempenho otimizado**. A API de metadados do driver é otimizada para retornar metadados com eficiência. A AWS continua investindo no desempenho da API de metadados do driver.
+ **Compatibilidade com versões futuras**. O Amazon Redshift segue as especificações dos conectores JDBC, ODBC e Python. Quando você codifica com base nessas APIs padrão, seu aplicativo é protegido contra alterações na estrutura subjacente do catálogo do sistema.
## Exemplo: usar o comando JDBC DatabaseMetaData.getTables() para recuperar metadados da tabela
```
DatabaseMetaData dbmd = connection.getMetaData();
// getTables(catalog, schemaPattern, tableNamePattern, types)
// catalog: "test" — filters to the database named "test"
// schemaPattern: "test_pattern" — filters schemas matching this pattern (supports SQL wildcards % and _)
// tableNamePattern: null — no filter, returns all table names
// types: {"TABLE", "EXTERNAL TABLE"} — only return regular tables and external tables
ResultSet rs = dbmd.getTables("test", "test_pattern", null, new String[] {"TABLE", "EXTERNAL TABLE"});
```
## Exemplo: usar o comando Python cursor.get\_columns() para recuperar metadados da coluna
```
cursor: redshift_connector.Cursor = conn.cursor()
# get_columns(catalog, schema_pattern, table_name_pattern, column_name_pattern)
# catalog: 'test' — filters to the database named "test"
# schema_pattern: 'test_pattern' — filters schemas matching this pattern (supports SQL wildcards % and _)
# table_name_pattern: 'testabc' — filters to the table named "testabc"
# column_name_pattern: '%' — wildcard, returns all columns in the matching table
result: tuple = cursor.get_columns('test', 'test_pattern', 'testabc', '%')
```
## Exemplo: usar o comando ODBC SQLPrimaryKeys() para recuperar metadados de chave primária
```
// SQLPrimaryKeys(hstmt, catalog, catalog_len, schema, schema_len, table, table_len)
// catalog: "test" — filters to the database named "test"
// schema: "test_schema" — filters to the schema named "test_schema"
// table: "test_table" — retrieves primary key columns for this table
// Note: Unlike getTables/getColumns, SQLPrimaryKeys does NOT support wildcard patterns.
retcode = SQLPrimaryKeys(hstmt, (SQLCHAR *)"test", SQL_NTS, (SQLCHAR *)"test_schema", SQL_NTS, (SQLCHAR *)"test_table", SQL_NTS);
while (SQL_SUCCEEDED(retcode = SQLFetch(hstmt))) {
for (i = 1; i <= columns; i++) {
retcode = SQLGetData(hstmt, i, SQL_C_CHAR, buf, sizeof(buf), &indicator);
}
}
```
## Exemplo: usar o comando ODBC SQLTables() para listar bancos de dados e esquemas
A API ODBC não fornece funções separadas para listar catálogos ou esquemas. Em vez disso, você usa convenções de chamada especiais de `SQLTables()` para recuperar essas informações.
**Para listar todos os bancos de dados (catálogos)**
Chame `SQLTables()` com `CatalogName` definido como `SQL_ALL_CATALOGS`. Defina `SchemaName` e `TableName` como strings vazias. O conjunto de resultados retorna valores válidos somente na coluna `TABLE_CAT`. Todas as outras colunas contêm valores NULL.
```
// List all catalogs (databases) available on the data source.
retcode = SQLTables(hstmt,
(SQLCHAR *)SQL_ALL_CATALOGS, SQL_NTS, // CatalogName = "%" (SQL_ALL_CATALOGS)
(SQLCHAR *)"", 0, // SchemaName = "" (empty string)
(SQLCHAR *)"", 0, // TableName = "" (empty string)
NULL, 0); // TableType = NULL (not filtered)
```
**Para listar todos os esquemas**
Chame `SQLTables()` com `SchemaName` definido como `SQL_ALL_SCHEMAS`. Defina `CatalogName` e `TableName` como strings vazias.
```
// List all schemas available on the data source.
retcode = SQLTables(hstmt,
(SQLCHAR *)"", 0, // CatalogName = "" (empty string)
(SQLCHAR *)SQL_ALL_SCHEMAS, SQL_NTS, // SchemaName = "%" (SQL_ALL_SCHEMAS)
(SQLCHAR *)"", 0, // TableName = "" (empty string)
NULL, 0); // TableType = NULL (not filtered)
```
**nota**
A especificação ODBC define somente `TABLE_SCHEM` como válido para enumeração de esquemas. O Amazon Redshift também preenche `TABLE_CAT` porque oferece suporte à descoberta de metadados entre bancos de dados, e cada esquema tem como escopo um banco de dados específico.