Amazon Redshift unterstützt ab Patch 198 nicht mehr die Erstellung neuer Python-UDFs. Bestehende Python-UDFs werden bis zum 30. Juni 2026 weiterhin funktionieren. Weitere Informationen finden Sie im [Blog-Posting](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/).
Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Verwenden Sie die Amazon Redshift Redshift-Treibermetadaten-API für Anwendungen und Tools
Für Anwendungen und Tools, die eine Verbindung zu Amazon Redshift herstellen, wie z. B. ein Business Intelligence-Tool oder ein Abfrage-Editor, empfehlen wir, die von den Amazon Redshift [JDBC 2.x-, [ODBC 2.x](odbc20-install.md)](jdbc20-install.md) - oder [Python-Treibern](python-redshift-driver.md) bereitgestellte Treibermetadaten-API zu verwenden, um Metadaten zu Ihren Data Warehouse-Objekten zu ermitteln, einschließlich Datenbanken, Schemas, Tabellen, Spalten und Datentypen. Als Alternative können Sie Amazon Redshift `SHOW` Redshift-Befehle verwenden.
Verwenden Sie die Treibermetadaten-API für die folgenden Vorteile:
+ **Specification-compliant**. Die JDBC- und ODBC-Treiber implementieren Standardschnittstellen für Metadaten (`DatabaseMetaData`in JDBC und in ODBC). `SQLTables` `SQLColumns` Da Pythons DB-API (PEP 249) keine Metadaten-API-Spezifikation definiert, folgt der Amazon Redshift Python-Treiber der DatabaseMetaData JDBC-Spezifikation und bietet äquivalente Methoden wie`get_tables()`, und. `get_columns()` `get_schemas()` Diese APIs folgen klar definierten Spezifikationen, sodass Ihr Integrationscode portabel ist. Während Amazon Redshift seine internen Systemtabellen weiterentwickelt, muss Ihre Anwendung nicht geändert werden.
+ **Performance-optimized**. Die Treibermetadaten-API ist für die effiziente Rückgabe von Metadaten optimiert. AWS investiert weiterhin in die Leistung der Treibermetadaten-API.
+ **Forward-compatible**. Amazon Redshift hält sich an die Spezifikationen für JDBC-, ODBC- und Python-Konnektoren. Wenn Sie anhand dieser Standard-APIs programmieren, ist Ihre Anwendung vor Änderungen an der zugrunde liegenden Systemkatalogstruktur geschützt.
## Beispiel: Verwenden von JDBC DatabaseMetaData.getTables () zum Abrufen von Tabellenmetadaten
```
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"});
```
## Beispiel: Verwendung von Python cursor.get\_columns () zum Abrufen von Spaltenmetadaten
```
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', '%')
```
## Beispiel: Verwendung von ODBC SQLPrimaryKeys () zum Abrufen von Primärschlüssel-Metadaten
```
// 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);
}
}
```
## Beispiel: Verwendung von ODBC SQLTables () zum Auflisten von Datenbanken und Schemas
Die ODBC-API bietet keine separaten Funktionen zum Auflisten von Katalogen oder Schemas. Stattdessen verwenden Sie spezielle Aufrufkonventionen von, `SQLTables()` um diese Informationen abzurufen.
**Um alle Datenbanken (Kataloge) aufzulisten**
Rufen Sie `SQLTables()` mit der `CatalogName` Einstellung auf an. `SQL_ALL_CATALOGS` Setzt `SchemaName` und `TableName` auf leere Zeichenketten. Die Ergebnismenge gibt nur gültige Werte in der `TABLE_CAT` Spalte zurück. Alle anderen Spalten enthalten NULLs.
```
// 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)
```
**Um alle Schemas aufzulisten**
Rufen Sie `SQLTables()` mit der `SchemaName` Einstellung auf an. `SQL_ALL_SCHEMAS` Setzt `CatalogName` und `TableName` auf leere Zeichenketten.
```
// 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)
```
**Anmerkung**
Die ODBC-Spezifikation definiert, dass `TABLE_SCHEM` sie nur für die Schemaaufzählung gültig ist. Amazon Redshift füllt Daten auch`TABLE_CAT`, weil es die datenbankübergreifende Erkennung von Metadaten unterstützt und jedes Schema auf eine bestimmte Datenbank beschränkt ist.