Amazon Redshift ne prendra plus en charge la création de nouveaux UDFs Python à partir du patch 198. Les fonctions Python définies par l’utilisateur existantes continueront de fonctionner normalement jusqu’au 30 juin 2026. Pour plus d’informations, consultez le [ billet de blog ](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/).
Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Utiliser l'API de métadonnées du pilote Amazon Redshift pour les applications et les outils
Pour les applications et les outils qui se connectent à Amazon Redshift, tels qu'un outil de business intelligence ou un éditeur de requêtes, nous vous recommandons d'utiliser l'API de métadonnées de pilote fournie par les pilotes Amazon [Redshift JDBC 2.x, ODBC](jdbc20-install.md) [2.x](odbc20-install.md) ou [Python](python-redshift-driver.md) pour découvrir les métadonnées relatives aux objets de votre entrepôt de données, notamment les bases de données, les schémas, les tables, les colonnes et les types de données. Vous pouvez également utiliser les commandes Amazon Redshift`SHOW`.
Utilisez l'API de métadonnées du pilote pour bénéficier des avantages suivants :
+ **Specification-compliant**. Les pilotes JDBC et ODBC implémentent des interfaces de métadonnées standard (`DatabaseMetaData`en JDBC et en ODBC). `SQLTables` `SQLColumns` Étant donné que Python DB-API (PEP 249) ne définit pas de spécification d'API de métadonnées, le pilote Amazon Redshift Python suit DatabaseMetaData la spécification JDBC, fournissant des méthodes équivalentes `get_tables()` telles que`get_columns()`, et. `get_schemas()` Ces API suivent des spécifications bien définies, de sorte que votre code d'intégration est portable. Au fur et à mesure qu'Amazon Redshift fait évoluer ses tables système internes, votre application n'a pas besoin de changer.
+ **Performance-optimized**. L'API de métadonnées du pilote est optimisée pour renvoyer les métadonnées de manière efficace. AWS continue d'investir dans les performances des API de métadonnées des pilotes.
+ **Forward-compatible**. Amazon Redshift respecte les spécifications des connecteurs JDBC, ODBC et Python. Lorsque vous codez à l'aide de ces API standard, votre application est protégée contre toute modification de la structure du catalogue du système sous-jacent.
## Exemple : utilisation de JDBC DatabaseMetaData.getTables () pour récupérer les métadonnées d'une table
```
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"});
```
## Exemple : utilisation de Python cursor.get\_columns () pour récupérer les métadonnées des colonnes
```
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', '%')
```
## Exemple : utilisation d'ODBC SQLPrimaryKeys () pour récupérer les métadonnées de la clé primaire
```
// 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);
}
}
```
## Exemple : utilisation d'ODBC SQLtables () pour répertorier les bases de données et les schémas
L'API ODBC ne fournit pas de fonctions distinctes pour répertorier les catalogues ou les schémas. Vous utilisez plutôt des conventions d'appel spéciales de `SQLTables()` pour récupérer ces informations.
**Pour répertorier toutes les bases de données (catalogues)**
Appelez `SQLTables()` avec `CatalogName` réglé sur`SQL_ALL_CATALOGS`. Définissez `SchemaName` et `TableName` pour vider les chaînes. Le jeu de résultats renvoie des valeurs valides uniquement dans la `TABLE_CAT` colonne. Toutes les autres colonnes contiennent des valeurs 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)
```
**Pour répertorier tous les schémas**
Appelez `SQLTables()` avec `SchemaName` réglé sur`SQL_ALL_SCHEMAS`. Définissez `CatalogName` et `TableName` pour vider les chaînes.
```
// 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)
```
**Note**
La spécification ODBC définit uniquement `TABLE_SCHEM` comme valide pour l'énumération des schémas. Amazon Redshift est également renseigné `TABLE_CAT` car il prend en charge la découverte de métadonnées entre bases de données, et chaque schéma est limité à une base de données spécifique.