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. # Apache-Iceberg-Tabellen abfragen Mit Athena können Sie Lese-, Zeitreise-, Schreib- und DDL-Abfragen für Apache Iceberg-Tabellen durchführen. [Apache Iceberg](https://iceberg.apache.org/) ist ein offenes Tabellenformat für sehr große analytische Datensätze. Iceberg verwaltet große Sammlungen von Dateien als Tabellen und unterstützt moderne analytische Data-Lake-Operationen wie Einfüge-, Aktualisierungs-, Löschen- und Zeitreiseabfragen auf Datensatzebene. Die Iceberg-Spezifikation ermöglicht eine nahtlose Tabellenentwicklung wie Schema- und Partitionsentwicklung, und ihr Design ist für die Verwendung auf Amazon S3 optimiert. Iceberg trägt auch dazu bei, die Datenkorrektheit in gleichzeitigen Schreibszenarien zu gewährleisten. Weitere Informationen zu Apache Iceberg finden Sie unter [http://iceberg.apache.org/](https://iceberg.apache.org/). ## Überlegungen und Einschränkungen Die Athena-Unterstützung für Iceberg-Tabellen unterliegt folgenden Überlegungen und Einschränkungen: + **Unterstützung für Iceberg-Versionen** – Athena unterstützt Apache Iceberg Version 1.4.2. + **Bei Lake Formation registrierte Tabellen** – Athena unterstützt derzeit keine DDL-Operationen für Iceberg-Tabellen, die bei Lake Formation registriert sind. + **Abfragen anhand des Informationsschemas** – Bei der Abfrage des Informationsschemas von Iceberg-Tabellen verwendet Athena S3-Metadaten als Informationsquelle für Spaltenmetadaten. Das bedeutet, dass Spalteninformationen aus den zugrunde liegenden S3-Dateien und nicht aus den Katalogmetadaten abgeleitet werden. Dieses Verhalten unterscheidet sich von anderen Tabellenformaten, bei denen Katalogmetadaten möglicherweise die Hauptquelle für Spalteninformationen sind. + Nur **Tabellen mit AWS Glue Katalog — Nur** Iceberg-Tabellen, die anhand des AWS Glue Katalogs auf der Grundlage von Spezifikationen erstellt wurden, die in der [Open-Source-Glue-Katalogimplementierung](https://iceberg.apache.org/docs/latest/aws/#glue-catalog) definiert wurden, werden von Athena unterstützt. + **Unterstützung für Tabellensperren AWS Glue nur von** — Im Gegensatz zur Open-Source-Implementierung des Glue-Katalogs, die benutzerdefinierte Sperren von Plug-ins unterstützt, unterstützt Athena nur AWS Glue optimistisches Sperren. Die Verwendung von Athena zum Ändern einer Iceberg-Tabelle mit einer anderen Sperren-Implementierung führt zu potenziellen Datenverlust und bricht Transaktionen ab. + **Unterstützte Dateiformate** – Athena-Engine Version 3 unterstützt die folgenden Iceberg-Dateiformate. + Parquet + ORC + Avro + **Eingeschränkte Iceberg-Metadaten** – Lake Formation wertet die Iceberg-Metadatentabellen nicht aus. Daher sind die Iceberg-Metadatentabellen eingeschränkt, wenn in der Basistabelle Zeilen- oder Zellfilter für Lake Formation vorhanden sind oder wenn Sie nicht berechtigt sind, alle Spalten in der Basistabelle anzuzeigen. In solchen Fällen, schlägt die Abfrage der Iceberg-Metadatentabellen `$partitions`, `$files`, `$manifests` und `$snapshots` fehl und es wird eine `AccessDeniedException`-Fehlermeldung angezeigt. Darüber hinaus hat die Metadatenspalte `$path` dieselben Einschränkungen für Lake Formation und schlägt fehl, wenn sie von der Abfrage ausgewählt wird. Alle anderen Metadatentabellen können unabhängig von den Lake-Formation-Filtern abgefragt werden. Weitere Informationen finden Sie unter [Metadatentabellen](https://trino.io/docs/current/connector/iceberg.html#metadata-tables). + **Iceberg-v2-Tabellen** – Athena erstellt und arbeitet nur auf Iceberg-v2-Tabellen. Den Unterschied zwischen v1- und v2-Tabellen finden Sie unter [Formatversionsänderungen](https://iceberg.apache.org/spec/#appendix-e-format-version-changes) in der Apache-Iceberg-Dokumentation. + **Anzeige von Zeittypen ohne Zeitzone** – Die Zeit und der Zeitstempel ohne Zeitzonentypen werden in UTC angezeigt. Wenn die Zeitzone in einem Filterausdruck für eine Zeitspalte nicht angegeben ist, wird UTC verwendet. + **Zeitstempelbezogene Datengenauigkeit** – Obwohl Iceberg Mikrosekunden-Genauigkeit für den Zeitstempel-Datentyp unterstützt, unterstützt Athena nur Millisekunden-Genauigkeit für Zeitstempel sowohl beim Lesen als auch beim Schreiben. Für Daten in zeitbezogenen Spalten, die bei manuellen Verdichtungsvorgängen neu geschrieben werden, behält Athena nur die Millisekundengenauigkeit bei. + **Nicht unterstützte Operationen** – Die folgenden Athena-Operationen werden für Iceberg-Tabellen nicht unterstützt. + [ALTER TABLE SET LOCATION](alter-table-set-location.md) + **Ansichten** – Verwenden Sie `CREATE VIEW` zum Erstellen von Athena-Ansichten, wie unter [Arbeiten mit Ansichten](views.md) beschrieben. Wenn Sie daran interessiert sind, die [Iceberg-Ansichtsspezifikation](https://github.com/apache/iceberg/blob/master/format/view-spec.md) zum Erstellen von Ansichten zu verwenden, wenden Sie sich an [athena-feedback@amazon.com](mailto:athena-feedback@amazon.com). + **TTF-Verwaltungsbefehle werden nicht unterstützt in AWS Lake Formation** — Sie können Lake Formation zwar verwenden, um Lesezugriffsberechtigungen für TransactionTable Formate (TTFs) wie Apache Iceberg, Apache Hudi und Linux Foundation Delta Lake zu verwalten, aber Sie können Lake Formation nicht verwenden, um Berechtigungen für Operationen wie`VACUUM`,`MERGE`, `UPDATE` oder `OPTIMIZE` mit diesen Tabellenformaten zu verwalten. Weitere Informationen zur Integration von Lake Formation mit Athena finden Sie unter [Using AWS Lake Formation with Amazon Athena](https://docs.aws.amazon.com/lake-formation/latest/dg/athena-lf.html) im *AWS Lake Formation Developer* Guide. + **Partitionierung nach verschachtelten Feldern** – Die Partitionierung nach verschachtelten Feldern wird nicht unterstützt. Wenn Sie dies versuchen, wird die Meldung NOT\$1SUPPORTED: Partitioning by nested field is unsupported: angezeigt. *column\$1name* *nested\$1field\$1name*. + **Überspringen von Amazon-Glacier-Objekten wird nicht unterstützt** – Wenn sich Objekte in der Apache–Iceberg-Tabelle in einer Amazon-Glacier-Speicherklasse befinden, hat das Setzen der `read_restored_glacier_objects`-Tabelleneigenschaft auf `false` keine Auswirkung. Angenommen, Sie führen den folgenden Befehl aus: ``` ALTER TABLE table_name SET TBLPROPERTIES ('read_restored_glacier_objects' = 'false') ``` Bei Iceberg- und Delta-Lake-Tabellen erzeugt der Befehl den Fehler Unsupported table property key: read\$1restored\$1glacier\$1objects. Bei Hudi-Tabellen erzeugt der `ALTER TABLE`-Befehl keinen Fehler, aber Amazon-Glacier-Objekte werden immer noch nicht übersprungen. Beim Ausführen von `SELECT`-Abfragen nach dem `ALTER TABLE`-Befehl werden weiterhin alle Objekte zurückgegeben. Wenn Sie möchten, dass Athena ein bestimmtes Feature unterstützt, senden Sie Feedback an [athena-feedback@amazon.com](mailto:athena-feedback@amazon.com). **Topics** + [Überlegungen und Einschränkungen](#querying-iceberg-considerations-and-limitations) + [Iceberg-Tabellen erstellen](querying-iceberg-creating-tables.md) + [Iceberg-Tabellendaten abfragen](querying-iceberg-table-data.md) + [Zeitreisen- und Versionsreiseabfragen durchführen](querying-iceberg-time-travel-and-version-travel-queries.md) + [Iceberg-Tabellendaten aktualisieren](querying-iceberg-updating-iceberg-table-data.md) + [Iceberg-Tabellen verwalten](querying-iceberg-managing-tables.md) + [Iceberg-Tabellenschema weiterentwickeln](querying-iceberg-evolving-table-schema.md) + [Andere DDL-Operationen an Iceberg-Tabellen ausführen](querying-iceberg-additional-operations.md) + [Iceberg-Tabellen optimieren](querying-iceberg-data-optimization.md) + [Materialisierte Ansichten des AWS Glue Datenkatalogs abfragen](querying-iceberg-gdc-mv.md) + [Unterstützte Datentypen für Iceberg-Tabellen in Athena](querying-iceberg-supported-data-types.md) + [Weitere Ressourcen](querying-iceberg-additional-resources.md) # Iceberg-Tabellen erstellen Um eine Iceberg-Tabelle für die Verwendung in Athena zu erstellen, können Sie eine `CREATE TABLE` Anweisung verwenden, wie auf dieser Seite dokumentiert, oder Sie können einen AWS Glue Crawler verwenden. ## CREATE TABLE-Anweisung verwenden Athena erstellt Iceberg-v2-Tabellen. Den Unterschied zwischen v1- und v2-Tabellen finden Sie unter [Formatversionsänderungen](https://iceberg.apache.org/spec/#appendix-e-format-version-changes) in der Apache-Iceberg-Dokumentation. Athena `CREATE TABLE` erstellt eine Iceberg-Tabelle ohne Daten. Sie können eine Tabelle direkt aus externen Systemen wie Apache Spark abfragen, wenn die Tabelle den [Open-Source-Glue-Katalog von Iceberg](https://iceberg.apache.org/docs/latest/aws/#glue-catalog) verwendet. Sie müssen keine externe Tabelle erstellen. **Warnung** Das Ausführen von `CREATE EXTERNAL TABLE` führt zu der Fehlermeldung Externes Schlüsselwort wird für den Tabellentyp ICEBERG nicht unterstützt. Um eine Iceberg-Tabelle aus Athena zu erstellen, legen Sie die `'table_type'`-Tabellen-Eigenschaft in der `'ICEBERG'`-Klausel auf `TBLPROPERTIES`, wie in der folgenden Syntaxzusammenfassung. ``` CREATE TABLE [db_name.]table_name (col_name data_type [COMMENT col_comment] [, ...] ) [PARTITIONED BY (col_name | transform, ... )] LOCATION 's3://amzn-s3-demo-bucket/your-folder/' TBLPROPERTIES ( 'table_type' ='ICEBERG' [, property_name=property_value] ) ``` Informationen zu den Datentypen, die Sie in Iceberg-Tabellen abfragen können, finden Sie unter [Unterstützte Datentypen für Iceberg-Tabellen in Athena](querying-iceberg-supported-data-types.md). ### Partitionen verwenden Um Iceberg-Tabellen mit Partitionen zu erstellen, verwenden Sie die `PARTITIONED BY`-Syntax. Spalten, die für die Partitionierung verwendet werden, müssen zuerst in den Spaltendeklarationen angegeben werden. Innerhalb der `PARTITIONED BY`-Klausel darf der Spaltentyp nicht enthalten sein. Sie können auch die [Partitionstransformationen](https://iceberg.apache.org/spec/#partition-transforms) in der `CREATE TABLE`-Syntax definieren. Um mehrere Spalten für die Partitionierung anzugeben, trennen Sie die Spalten durch das Komma (`,`), wie im folgenden Beispiel. ``` CREATE TABLE iceberg_table (id bigint, data string, category string) PARTITIONED BY (category, bucket(16, id)) LOCATION 's3://amzn-s3-demo-bucket/your-folder/' TBLPROPERTIES ( 'table_type' = 'ICEBERG' ) ``` Die folgende Tabelle zeigt die verfügbaren Partitionstransformationsfunktionen. **** | Funktion | Description | Unterstützte Typen | | --- | --- | --- | | year(ts) | Partition nach Jahr | date, timestamp | | month(ts) | Partition nach Monat | date, timestamp | | day(ts) | Partition nach Tag | date, timestamp | | hour(ts) | Partition nach Stunde | timestamp | | bucket(N, col) | Partitionierung nach Mod-Buckets mit Hash-Werten. N Dies ist das gleiche Konzept wie Hash-Bucketing für Hive-Tabellen. | int, long, decimal, date, timestamp, string, binary | | truncate(L, col) | Partition nach Wert, gekürzt auf L | int, long, decimal, string | Athena unterstützt Icebergs versteckte Partitionierung. Weitere Informationen finden Sie unter [Icebergs versteckte Partitionierung](https://iceberg.apache.org/docs/latest/partitioning/#icebergs-hidden-partitioning) in der Apache-Iceberg-Dokumentation. ### Tabelleneigenschaften angeben In diesem Abschnitt werden Tabelleneigenschaften beschrieben, die als Schlüssel-Wert-Paare in der `TBLPROPERTIES`-Klausel der Erklärung `CREATE TABLE` angegeben werden. Athena erlaubt nur eine vordefinierte Liste von Schlüssel-Wert-Paaren in den Tabelleneigenschaften zum Erstellen oder Ändern von Iceberg-Tabellen. In den folgenden Tabellen finden Sie die Tabelleneigenschaften, die Sie angeben können. Weitere Hinweise zu den Verdichtungsoptionen finden Sie unter [Iceberg-Tabellen optimieren](querying-iceberg-data-optimization.md) in diesem Dokument. Wenn Sie möchten, dass Athena eine bestimmte Open-Source-Tabellen-Konfigurationseigenschaft unterstützt, senden Sie Feedback an [athena-feedback@amazon.com](mailto:athena-feedback@amazon.com). ***Format*** **** | | | | --- |--- | | Beschreibung | Dateidaten-Format | | Zulässige Eigenschaftswerte | Die unterstützten Dateiformat- und Komprimierungskombinationen variieren je nach Athena-Engine-Version. Weitere Informationen finden Sie unter [Komprimierung von Iceberg-Tabellen verwenden](compression-support-iceberg.md). | | Standardwert | parquet | ***write\$1compression*** **** | | | | --- |--- | | Beschreibung | Dateikomprimierungscodec | | Zulässige Eigenschaftswerte | Die unterstützten Dateiformat- und Komprimierungskombinationen variieren je nach Athena-Engine-Version. Weitere Informationen finden Sie unter [Komprimierung von Iceberg-Tabellen verwenden](compression-support-iceberg.md). | | Standardwert | Die standardmäßige Schreibkomprimierung variiert je nach Athena-Engine-Version. Weitere Informationen finden Sie unter [Komprimierung von Iceberg-Tabellen verwenden](compression-support-iceberg.md). | ***optimize\$1rewrite\$1data\$1file\$1threshold*** **** | | | | --- |--- | | Beschreibung | Spezifische Konfiguration zur Datenoptimierung. Wenn es weniger Datendateien gibt, die eine Optimierung erfordern als der angegebene Schwellenwert, werden die Dateien nicht neu geschrieben. Dies ermöglicht die Ansammlung von mehr Datendateien, um Dateien näher an der Zielgröße zu erzeugen und unnötige Berechnungen zur Kosteneinsparung zu überspringen. | | Zulässige Eigenschaftswerte | Eine positive Zahl. Muss kleiner als 50 sein. | | Standardwert | 5 | ***optimize\$1rewrite\$1delete\$1file\$1threshold*** **** | | | | --- |--- | | Beschreibung | Spezifische Konfiguration zur Datenoptimierung. Wenn weniger Löschdateien mit einer Datendatei verknüpft sind als der Schwellenwert, wird die Datendatei nicht neu geschrieben. Dies ermöglicht die Anhäufung von mehr Löschdateien für jede Datendatei zur Kosteneinsparung. | | Zulässige Eigenschaftswerte | Eine positive Zahl. Muss kleiner als 50 sein. | | Standardwert | 2 | ***vacuum\$1min\$1snapshots\$1to\$1keep*** **** | | | | --- |--- | | Beschreibung | Mindestanzahl von Snapshots, die im Hauptzweig einer Tabelle beibehalten werden sollen. Dieser Wert hat Vorrang vor der `vacuum_max_snapshot_age_seconds`-Eigenschaft. Wenn die Mindestanzahl der verbleibenden Snapshots älter als das von `vacuum_max_snapshot_age_seconds` angegebene Alter ist, werden die Snapshots beibehalten und der Wert von `vacuum_max_snapshot_age_seconds` wird ignoriert. | | Zulässige Eigenschaftswerte | Eine positive Zahl. | | Standardwert | 1 | ***vacuum\$1max\$1snapshot\$1age\$1seconds*** **** | | | | --- |--- | | Beschreibung | Höchstalter der Snapshots, die auf dem Hauptzweig beibehalten werden sollen. Dieser Wert wird ignoriert, wenn die verbleibende Mindestanzahl an Snapshots, die von vacuum\$1min\$1snapshots\$1to\$1keep angegeben wurden, älter als das angegebene Alter ist. Diese Eigenschaft des Tabellenverhaltens entspricht der history.expire.max-snapshot-age-ms-Eigenschaft in der Apache-Iceberg-Konfiguration. | | Zulässige Eigenschaftswerte | Eine positive Zahl. | | Standardwert | 432 000 Sekunden (5 Tage) | ***vacuum\$1max\$1metadata\$1files\$1to\$1keep*** **** | | | | --- |--- | | Beschreibung | Die maximale Anzahl von vorherigen Metadatendateien, die im Hauptzweig der Tabelle beibehalten werden sollen. | | Zulässige Eigenschaftswerte | Eine positive Zahl. | | Standardwert | 100 | ***write\$1data\$1path\$1enabled*** **** | | | | --- |--- | | Beschreibung | Wenn auf gesetzttrue, wird die Iceberg-Tabelle mit der Eigenschaft anstelle der write.data.path veralteten Eigenschaft erstellt. write.object-storage.path Verwenden Sie diese Option, um die Kompatibilität mit Iceberg 1.9.0 und höher sicherzustellen, da die veraltete Eigenschaft nicht mehr unterstützt wird. | | Zulässige Eigenschaftswerte | true, false | | Standardwert | false | ### Beispiel einer CREATE-TABLE-Anweisung Im folgenden Beispiel wird eine Iceberg-Tabelle mit drei Spalten erstellt. ``` CREATE TABLE iceberg_table ( id int, data string, category string) PARTITIONED BY (category, bucket(16,id)) LOCATION 's3://amzn-s3-demo-bucket/iceberg-folder' TBLPROPERTIES ( 'table_type'='ICEBERG', 'format'='parquet', 'write_compression'='snappy', 'optimize_rewrite_delete_file_threshold'='10' ) ``` ## CREATE TABLE AS SELECT (CTAS) verwenden Informationen zum Erstellen einer Iceberg-Tabelle mithilfe der `CREATE TABLE AS`-Anweisung finden Sie unter [CREATE TABLE AS](create-table-as.md), wobei dem Abschnitt [CTAS-Tabelleneigenschaften](create-table-as.md#ctas-table-properties) besondere Aufmerksamkeit geschenkt werden sollte. ## Verwenden Sie einen Crawler AWS Glue Sie können einen AWS Glue Crawler verwenden, um Ihre Iceberg-Tabellen automatisch in der zu registrieren. AWS Glue Data Catalog Wenn Sie aus einem anderen Iceberg-Katalog migrieren möchten, können Sie einen AWS Glue Crawler erstellen und planen und die Amazon S3 S3-Pfade angeben, in denen sich die Iceberg-Tabellen befinden. Sie können die maximale Tiefe der Amazon-S3-Pfade angeben, die der AWS Glue -Crawler durchqueren kann. Nachdem Sie einen AWS Glue Crawler geplant haben, extrahiert der Crawler Schemainformationen und aktualisiert sie bei jeder Ausführung AWS Glue Data Catalog mit den Schemaänderungen. Der AWS Glue Crawler unterstützt das Zusammenführen von Schemas über Snapshots hinweg und aktualisiert den aktuellen Speicherort der Metadatendatei in. AWS Glue Data Catalog Weitere Informationen finden Sie unter [Datenkatalog und](https://docs.aws.amazon.com/glue/latest/dg/catalog-and-crawler.html) Crawler in. AWS Glue # Iceberg-Tabellendaten abfragen Um einen Iceberg-Datensatz abzufragen, verwenden Sie eine `SELECT`-Standardanweisung wie die folgende. Abfragen folgen der Apache Iceberg [Format v2-Spezifikation](https://iceberg.apache.org/spec/#format-versioning) und führen merge-on-read sowohl Positions- als auch Gleichheitslöschungen durch. ``` SELECT * FROM [db_name.]table_name [WHERE predicate] ``` Um die Abfragezeiten zu optimieren, werden alle Prädikate dorthin verschoben, wo sich die Daten befinden. Informationen zu Zeitreise und Versionsreiseabfragen finden Sie unter [Zeitreisen- und Versionsreiseabfragen durchführen](querying-iceberg-time-travel-and-version-travel-queries.md). ## Erstellen und Abfragen von Ansichten mit Iceberg-Tabellen Verwenden Sie zum Erstellen und Abfragen von Athena-Ansichten für Iceberg-Tabellen `CREATE VIEW`-Ansichten wie in [Arbeiten mit Ansichten](views.md) beschrieben. Beispiel: ``` CREATE VIEW view1 AS SELECT * FROM iceberg_table ``` ``` SELECT * FROM view1 ``` Wenn Sie daran interessiert sind, die [Iceberg-Ansicht-Spezifikation](https://github.com/apache/iceberg/blob/master/format/view-spec.md) zum Erstellen von Ansichten zu verwenden, wenden Sie sich an [athena-feedback@amazon.com](mailto:athena-feedback@amazon.com). ## Iceberg-Tabellen-Metadaten abfragen In einer `SELECT` Abfrage können Sie anschließend die folgenden Eigenschaften verwenden, um *table\$1name* Iceberg-Tabellenmetadaten abzufragen: + **\$1files** – Zeigt die aktuellen Datendateien einer Tabelle an. + **\$1manifests** – Zeigt die aktuellen Dateimanifeste einer Tabelle an. + **\$1history** – Zeigt den Verlauf einer Tabelle an. + **\$1partitions** – Zeigt die aktuellen Partitionen einer Tabelle an. + **\$1snapshots** – Zeigt die Snapshots einer Tabelle an. + **\$1refs** – Zeigt die Verweise einer Tabelle an. ### Beispiele Die folgende Anweisung listet die Dateien für eine Iceberg-Tabelle auf. ``` SELECT * FROM "dbname"."tablename$files" ``` Die folgende Anweisung listet das Manifest für eine Iceberg-Tabelle auf. ``` SELECT * FROM "dbname"."tablename$manifests" ``` Die folgende Anweisung zeigt die Historie einer Iceberg-Tabelle. ``` SELECT * FROM "dbname"."tablename$history" ``` Im folgenden Beispiel werden die Partitionen für eine Iceberg-Tabelle gezeigt. ``` SELECT * FROM "dbname"."tablename$partitions" ``` Im folgenden Beispiel werden die Snapshots für eine Iceberg-Tabelle gelistet. ``` SELECT * FROM "dbname"."tablename$snapshots" ``` Im folgenden Beispiel werden die Referenzen für eine Iceberg-Tabelle gezeigt. ``` SELECT * FROM "dbname"."tablename$refs" ``` ## Differenzierte Zugriffskontrolle von Lake Formation verwenden Athena-Engine-Version 3 unterstützt die differenzierte Zugriffskontrolle von Lake Formation mit Iceberg-Tabellen, einschließlich der Sicherheitskontrolle auf Spalten- und Zeilenebene. Diese Zugriffskontrolle funktioniert mit Zeitreiseabfragen und mit Tabellen, die eine Schemaentwicklung durchgeführt haben. Weitere Informationen finden Sie unter [Differenzierte Zugriffskontrolle von Lake Formation und Athena-Arbeitsgruppen](lf-athena-limitations.md#lf-athena-limitations-fine-grained-access-control). Wenn Sie Ihre Iceberg-Tabelle außerhalb von Athena erstellt haben, verwenden Sie [Apache Iceberg SDK](https://iceberg.apache.org/releases/) Version 0.13.0 oder höher, damit Ihre Iceberg-Tabellenspalteninformationen im AWS Glue Data Catalog ausgefüllt werden. Wenn Ihre Iceberg-Tabelle keine Spalteninformationen enthält AWS Glue, können Sie die [ALTER TABLE SET TBLPROPERTIES](querying-iceberg-alter-table-set-properties.md) Athena-Anweisung oder das neueste Iceberg-SDK verwenden, um die Tabelle zu korrigieren und die Spalteninformationen in zu aktualisieren. AWS Glue # Zeitreisen- und Versionsreiseabfragen durchführen Jede Apache-Iceberg-Tabelle verwaltet ein versioniertes Manifest der darin enthaltenen Amazon-S3-Objekte. Frühere Versionen des Manifests können für Zeitreise- und Versionsreiseabfragen verwendet werden. Zeitreiseabfragen in Athena fragen Amazon S3 nach historischen Daten aus einem konsistenten Snapshot ab einem bestimmten Datum und einer bestimmten Uhrzeit ab. Versionsreiseabfragen in Athena fragen Amazon S3 nach historischen Daten ab einer angegebenen Snapshot-ID ab. ## Zeitreiseabfragen Um eine Zeitreiseabfrage auszuführen, verwenden Sie `FOR TIMESTAMP AS OF timestamp` nach dem Tabellennamen in der `SELECT`-Anweisung, wie im folgenden Beispiel. ``` SELECT * FROM iceberg_table FOR TIMESTAMP AS OF timestamp ``` Die für Reisen festzulegende Systemzeit ist entweder ein Zeitstempel oder ein Zeitstempel mit einer Zeitzone. Wenn nicht angegeben, betrachtet Athena den Wert als Zeitstempel in UTC-Zeit. Das folgende Beispiel für Zeitreiseabfragen wählt CloudTrail Daten für das angegebene Datum und die angegebene Uhrzeit aus. ``` SELECT * FROM iceberg_table FOR TIMESTAMP AS OF TIMESTAMP '2020-01-01 10:00:00 UTC' ``` ``` SELECT * FROM iceberg_table FOR TIMESTAMP AS OF (current_timestamp - interval '1' day) ``` ## Versionsreiseabfragen Um eine Versionsreiseabfrage durchzuführen (d. h. einen konsistenten Snapshot ab einer angegebenen Version anzuzeigen), verwenden Sie `FOR VERSION AS OF version` nach dem Tabellennamen in der `SELECT`-Anweisung, wie im folgenden Beispiel. ``` SELECT * FROM [db_name.]table_name FOR VERSION AS OF version ``` Der *version* Parameter ist die `bigint` Snapshot-ID, die einer Iceberg-Tabellenversion zugeordnet ist. Die folgende Beispielversionsreiseabfrage wählt Daten für die angegebene Version aus. ``` SELECT * FROM iceberg_table FOR VERSION AS OF 949530903748831860 ``` **Anmerkung** Die `FOR SYSTEM_TIME AS OF`- und `FOR SYSTEM_VERSION AS OF`-Klauseln in Athena-Engine-Version 2 wurden durch die `FOR TIMESTAMP AS OF`- und `FOR VERSION AS OF`-Klauseln in Athena-Engine-Version 3 ersetzt. ### Abrufen der Snapshot-ID Sie können die von Iceberg bereitgestellte [SnapshotUtil](https://iceberg.apache.org/javadoc/1.6.0/org/apache/iceberg/util/SnapshotUtil.html)Java-Klasse verwenden, um die Iceberg-Snapshot-ID abzurufen, wie im folgenden Beispiel gezeigt. ``` import org.apache.iceberg.Table; import org.apache.iceberg.aws.glue.GlueCatalog; import org.apache.iceberg.catalog.TableIdentifier; import org.apache.iceberg.util.SnapshotUtil; import java.text.SimpleDateFormat; import java.util.Date; Catalog catalog = new GlueCatalog(); Map properties = new HashMap(); properties.put("warehouse", "s3://amzn-s3-demo-bucket/my-folder"); catalog.initialize("my_catalog", properties); Date date = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss").parse("2022/01/01 00:00:00"); long millis = date.getTime(); TableIdentifier name = TableIdentifier.of("db", "table"); Table table = catalog.loadTable(name); long oldestSnapshotIdAfter2022 = SnapshotUtil.oldestAncestorAfter(table, millis); ``` ## Zeit- und Versionsreisen kombinieren Sie können Zeitreisen- und Versionsreisesyntax in derselben Abfrage verwenden, um verschiedene Timing- und Versionsbedingungen anzugeben, wie im folgenden Beispiel. ``` SELECT table1.*, table2.* FROM [db_name.]table_name FOR TIMESTAMP AS OF (current_timestamp - interval '1' day) AS table1 FULL JOIN [db_name.]table_name FOR VERSION AS OF 5487432386996890161 AS table2 ON table1.ts = table2.ts WHERE (table1.id IS NULL OR table2.id IS NULL) ``` # Iceberg-Tabellendaten aktualisieren Sie können Iceberg-Tabellendaten direkt auf Athena mit `INSERT`, `UPDATE`, und `DELETE`-Abfragen verwalten. Jede Datenverwaltungstransaktion erzeugt einen neuen Snapshot, der über Zeitreisen abgefragt werden kann. Die `UPDATE`- und `DELETE`-Anweisungen folgen der Spezifikation zum [Löschen von Positionen](https://iceberg.apache.org/spec/#position-delete-files) auf Zeilenebene im Iceberg-Format v2 und erzwingen die Snapshot-Isolation. **Anmerkung** Athena SQL unterstützt den copy-on-write Ansatz derzeit nicht. Die `DELETE FROM` Operationen `UPDATE``MERGE INTO`, und verwenden immer den merge-on-read Ansatz mit Positionslöschungen, unabhängig von den angegebenen Tabelleneigenschaften. Falls Sie Tabelleneigenschaften wie`write.update.mode`,, und/oder `write.delete.mode` zur Verwendung eingerichtet haben`write.merge.mode`, werden Ihre Abfragen nicht fehlschlagen copy-on-write, da Athena sie ignoriert und weiterhin verwendet merge-on-read. Verwenden Sie die folgenden Befehle, um Datenverwaltungsvorgänge für Iceberg-Tabellen durchzuführen. **Topics** + [INSERT INTO](querying-iceberg-insert-into.md) + [DELETE](querying-iceberg-delete.md) + [UPDATE](querying-iceberg-update.md) + [MERGE INTO](querying-iceberg-merge-into.md) # INSERT INTO Fügt Daten in eine Iceberg-Tabelle ein. Athena Iceberg `INSERT INTO` wird nach der gescannten Datenmenge genauso berechnet wie aktuelle `INSERT INTO`-Abfragen für externe Hive-Tabellen. Um Daten in eine Iceberg-Tabelle einzufügen, verwenden Sie die folgende Syntax, wobei entweder oder `VALUES (val1, val2, ...)` sein *query* kann. `SELECT (col1, col2, …) FROM [db_name.]table_name WHERE predicate` Informationen zur SQL-Syntax und semantischen Details finden Sie unter [INSERT INTO](insert-into.md). ``` INSERT INTO [db_name.]table_name [(col1, col2, …)] query ``` Die folgenden Beispiele fügen Werte in die Tabelle `iceberg_table` ein. ``` INSERT INTO iceberg_table VALUES (1,'a','c1') ``` ``` INSERT INTO iceberg_table (col1, col2, ...) VALUES (val1, val2, ...) ``` ``` INSERT INTO iceberg_table SELECT * FROM another_table ``` # DELETE Athena Iceberg `DELETE` schreibt Iceberg-Positionslöschdateien in eine Tabelle. Dies wird als merge-on-readLöschen bezeichnet. Im Gegensatz zu einem copy-on-writeLöschvorgang ist ein merge-on-read Löschvorgang effizienter, da die Dateidaten nicht neu geschrieben werden. Wenn Athena Iceberg-Daten liest, führt sie die Iceberg-Position-Löschdateien mit Datendateien zusammen, um die neueste Ansicht einer Tabelle zu erzeugen. Um diese Positionslöschdateien zu entfernen, können Sie die [Komprimierungs-Aktion REWRITE DATA ausführen](querying-iceberg-data-optimization.md#querying-iceberg-data-optimization-rewrite-data-action). `DELETE`-Vorgänge werden nach der gescannten Datenmenge abgerechnet. Weitere Informationen zur Syntax finden Sie unter [DELETE](delete-statement.md). Im folgenden Beispiel werden Zeilen aus `iceberg_table` gelöscht, die `c3` als Wert für `category` haben. ``` DELETE FROM iceberg_table WHERE category='c3' ``` # UPDATE Athena Iceberg `UPDATE` schreibt Iceberg-Positions-Löschdateien und neu aktualisierte Zeilen als Datendateien in derselben Transaktion. `UPDATE` kann man sich als Kombination von `INSERT INTO` und `DELETE` vorstellen. `UPDATE`-Vorgänge werden nach der gescannten Datenmenge abgerechnet. Weitere Informationen zur Syntax finden Sie unter [UPDATE](update-statement.md). Das folgende Beispiel aktualisiert die angegebenen Werte in der Tabelle `iceberg_table`. ``` UPDATE iceberg_table SET category='c2' WHERE category='c1' ``` # MERGE INTO Aktualisiert, löscht oder fügt bedingt Zeilen in eine Iceberg-Tabelle ein. Eine einzige Anweisung kann Aktionen zum Aktualisieren, Löschen und Einfügen kombinieren. Weitere Informationen zur Syntax finden Sie unter [MERGE INTO](merge-into-statement.md). **Anmerkung** `MERGE INTO` ist transaktionsbasiert und wird nur für Apache-Iceberg-Tabellen in Athena-Engine-Version 3 unterstützt. Das folgende Beispiel löscht alle Kunden aus der Tabelle `t`, die sich in der Quelltabelle `s` befinden. ``` MERGE INTO accounts t USING monthly_accounts_update s ON t.customer = s.customer WHEN MATCHED THEN DELETE ``` Im folgenden Beispiel wird die Zieltabelle `t` mit Informationen aus Quelltabelle `s` aktualisiert. Für Kundenzeilen in Tabelle `t`, die über übereinstimmende Kundenzeilen in Tabelle `s` verfügen, erhöht das Beispiel die Einkäufe in Tabelle t. Wenn Tabelle `t` keine Übereinstimmung mit einer Kundenzeile in der Tabelle `s` hat, fügt das Beispiel die Kundenzeile aus Tabelle `s` in Tabelle `t` ein. ``` MERGE INTO accounts t USING monthly_accounts_update s ON (t.customer = s.customer) WHEN MATCHED THEN UPDATE SET purchases = s.purchases + t.purchases WHEN NOT MATCHED THEN INSERT (customer, purchases, address) VALUES(s.customer, s.purchases, s.address) ``` Im folgenden Beispiel wird die Zieltabelle `t` bedingt mit Informationen aus der Quelltabelle `s` aktualisiert. Das Beispiel löscht alle übereinstimmenden Zielzeilen, deren Quelladresse Centreville ist. Für alle weiteren übereinstimmenden Zeilen fügt das Beispiel die Quellkäufe hinzu und legt die Zieladresse auf die Quelladresse fest. Wenn es in der Zieltabelle keine Übereinstimmung gibt, fügt das Beispiel die Zeile aus der Quelltabelle ein. ``` MERGE INTO accounts t USING monthly_accounts_update s ON (t.customer = s.customer) WHEN MATCHED AND s.address = 'Centreville' THEN DELETE WHEN MATCHED THEN UPDATE SET purchases = s.purchases + t.purchases, address = s.address WHEN NOT MATCHED THEN INSERT (customer, purchases, address) VALUES(s.customer, s.purchases, s.address) ``` # Iceberg-Tabellen verwalten Athena unterstützt die folgenden DDL-Operationen der Tabelle für Iceberg-Tabellen. **Topics** + [ALTER TABLE RENAME](querying-iceberg-alter-table-rename.md) + [ALTER TABLE SET TBLPROPERTIES](querying-iceberg-alter-table-set-properties.md) + [ALTER TABLE UNSET TBLPROPERTIES](querying-iceberg-alter-table-unset-properties.md) + [DESCRIBE](querying-iceberg-describe-table.md) + [DROP TABLE](querying-iceberg-drop-table.md) + [SHOW CREATE TABLE](querying-iceberg-show-create-table.md) + [SHOW TBLPROPERTIES](querying-iceberg-show-table-properties.md) # ALTER TABLE RENAME Umbenennen einer Tabelle. Da die Tabellenmetadaten einer Iceberg-Tabelle in Amazon S3 gespeichert sind, können Sie den Datenbank- und Tabellennamen einer von Iceberg verwalteten Tabelle aktualisieren, ohne die zugrunde liegenden Tabelleninformationen zu beeinträchtigen. ## Syntax ``` ALTER TABLE [db_name.]table_name RENAME TO [new_db_name.]new_table_name ``` ## Beispiel ``` ALTER TABLE my_db.my_table RENAME TO my_db2.my_table2 ``` # ALTER TABLE SET TBLPROPERTIES Fügt Eigenschaften zu einer Iceberg-Tabelle hinzu und legt deren zugewiesene Werte fest. In Übereinstimmung mit [Iceberg-Spezifikationen](https://iceberg.apache.org/#spec/#table-metadata-fields) werden Tabelleneigenschaften in der Metadatendatei der Iceberg-Tabelle gespeichert und nicht in AWS Glue. Athena akzeptiert keine benutzerdefinierten Tabelleneigenschaften. Weitere Informationen finden Sie im [Tabelleneigenschaften angeben](querying-iceberg-creating-tables.md#querying-iceberg-table-properties)-Abschnitt für zulässige Schlüssel-Wert-Paare. Sie können auch `ALTER TABLE SET TBLPROPERTIES` und verwenden`ALTER TABLE UNSET TBLPROPERTIES`, um die Tabelleneigenschaften `write.data.path` und die `write.object-storage.path` Iceberg-Tabelle festzulegen oder zu entfernen. Wenn Sie möchten, dass Athena eine bestimmte Open-Source-Tabellen-Konfigurationseigenschaft unterstützt, senden Sie Feedback an [athena-feedback@amazon.com](mailto:athena-feedback@amazon.com). ## Syntax ``` ALTER TABLE [db_name.]table_name SET TBLPROPERTIES ('property_name' = 'property_value' [ , ... ]) ``` ## Beispiel ``` ALTER TABLE iceberg_table SET TBLPROPERTIES ( 'format'='parquet', 'write_compression'='snappy', 'optimize_rewrite_delete_file_threshold'='10' ) ``` Im folgenden Beispiel wird die `write.data.path` Eigenschaft für eine vorhandene Iceberg-Tabelle festgelegt. ``` ALTER TABLE iceberg_table SET TBLPROPERTIES ( 'write.data.path'='s3://amzn-s3-demo-bucket/your-folder/data' ) ``` # ALTER TABLE UNSET TBLPROPERTIES Lässt bestehende Eigenschaften von einer Iceberg-Tabelle fallen. ## Syntax ``` ALTER TABLE [db_name.]table_name UNSET TBLPROPERTIES ('property_name' [ , ... ]) ``` ## Beispiel ``` ALTER TABLE iceberg_table UNSET TBLPROPERTIES ('write_compression') ``` Im folgenden Beispiel wird die `write.data.path` Eigenschaft aus einer Iceberg-Tabelle entfernt. ``` ALTER TABLE iceberg_table UNSET TBLPROPERTIES ('write.data.path') ``` # DESCRIBE Beschreibt Tabelleninformationen. ## Syntax ``` DESCRIBE [FORMATTED] [db_name.]table_name ``` Wenn die Option `FORMATTED` angegeben ist, zeigt die Ausgabe zusätzliche Informationen wie Tabellenspeicherort und Eigenschaften an. ## Beispiel ``` DESCRIBE iceberg_table ``` # DROP TABLE Lässt einen Iceberg-Tabelle fallen. **Warnung** Da Iceberg-Tabellen in Athena als verwaltete Tabellen gelten, werden durch das Löschen einer Iceberg-Tabelle auch alle Daten in der Tabelle entfernt. ## Syntax ``` DROP TABLE [IF EXISTS] [db_name.]table_name ``` ## Beispiel ``` DROP TABLE iceberg_table ``` # SHOW CREATE TABLE Zeigt eine `CREATE TABLE`-DDL-Anweisung an, mit der die Iceberg-Tabelle in Athena neu erstellt werden kann. Wenn Athena die Tabellenstruktur nicht reproduzieren kann (z. B. weil benutzerdefinierte Tabelleneigenschaften in der Tabelle angegeben sind), wird ein UNSUPPORTED-Fehler ausgegeben. ## Syntax ``` SHOW CREATE TABLE [db_name.]table_name ``` ## Beispiel ``` SHOW CREATE TABLE iceberg_table ``` # SHOW TBLPROPERTIES Zeigt eine oder mehrere Tabelleneigenschaften einer Iceberg-Tabelle an. Es werden nur Athena-unterstützte Tabelleneigenschaften angezeigt. ## Syntax ``` SHOW TBLPROPERTIES [db_name.]table_name [('property_name')] ``` ## Beispiel ``` SHOW TBLPROPERTIES iceberg_table ``` # Iceberg-Tabellenschema weiterentwickeln Iceberg-Schemaaktualisierungen sind reine Metadaten-Änderungen. Bei einer Schemaaktualisierung werden keine Datendateien geändert. Das Iceberg-Format unterstützt die folgenden Änderungen an der Schemaentwicklung: + **Einfügen** – Fügt einer Tabelle oder einer verschachtelten `struct` eine neue Spalte hinzu. + **Entfernen** – Entfernt eine vorhandene Spalte aus einer Tabelle oder einem verschachtelten `struct`. + **Umbenennen** – Benennt eine vorhandene Spalte oder ein vorhandenes Feld in einer verschachtelten `struct`. + **Neuanordnen** – Ändert die Reihenfolge der Spalten. + **Promotionstyp** – Erweitert den Typ einer Spalte, ein `struct`-Feld, eine `map`-Schlüssel, einen `map`-Wert, oder ein `list`-Element. Derzeit werden die folgenden Fälle für Iceberg-Tabellen unterstützt: + Ganzzahl bis große Ganzzahl + FLOAT, DOUBLE + Erhöhung der Genauigkeit eines Dezimaltyps Sie können die DDL-Anweisungen in diesem Abschnitt verwenden, um das Iceberg-Tabellenschema zu ändern. **Topics** + [TABELLE ÄNDERN SPALTEN HINZUFÜGEN](querying-iceberg-alter-table-add-columns.md) + [ALTER TABLE DROP COLUMN](querying-iceberg-alter-table-drop-column.md) + [ALTER TABLE CHANGE COLUMN](querying-iceberg-alter-table-change-column.md) + [SHOW\$1COLUMNS](querying-iceberg-show-columns.md) # TABELLE ÄNDERN SPALTEN HINZUFÜGEN Fügt einer vorhandenen Iceberg-Tabelle eine oder mehrere Spalten hinzu. ## Syntax ``` ALTER TABLE [db_name.]table_name ADD COLUMNS (col_name data_type [,...]) ``` ## Beispiele Im folgenden Beispiel wird eine `comment`-Spalte des Typs `string` einer Iceberg-Tabelle hinzugefügt. ``` ALTER TABLE iceberg_table ADD COLUMNS (comment string) ``` Im folgenden Beispiel wird eine `point`-Spalte des Typs `struct` einer Iceberg-Tabelle hinzugefügt. ``` ALTER TABLE iceberg_table ADD COLUMNS (point struct) ``` Im folgenden Beispiel wird eine `points`-Spalte, die ein Array von Strukturen zu einer Iceberg-Tabelle ist, hinzugefügt. ``` ALTER TABLE iceberg_table ADD COLUMNS (points array>) ``` # ALTER TABLE DROP COLUMN Lässt eine Spalte von einer vorhandenen Iceberg-Tabelle fallen. ## Syntax ``` ALTER TABLE [db_name.]table_name DROP COLUMN col_name ``` ## Beispiel ``` ALTER TABLE iceberg_table DROP COLUMN userid ``` # ALTER TABLE CHANGE COLUMN Ändert den Namen, den Typ, die Reihenfolge oder den Kommentar einer Spalte in einer Iceberg-Tabelle. **Anmerkung** `ALTER TABLE REPLACE COLUMNS` wird nicht unterstützt. Da `REPLACE COLUMNS` alle Spalten entfernt und dann neue hinzufügt, wird es für Iceberg nicht unterstützt. `CHANGE COLUMN` ist die bevorzugte Syntax für die Schemaentwicklung. ## Syntax ``` ALTER TABLE [db_name.]table_name CHANGE [COLUMN] col_old_name col_new_name column_type [COMMENT col_comment] [FIRST|AFTER column_name] ``` ## Beispiel ``` ALTER TABLE iceberg_table CHANGE comment blog_comment string AFTER id ``` # SHOW\$1COLUMNS Zeigt die Spalten in einer Tabelle an. ## Syntax ``` SHOW COLUMNS (FROM|IN) [db_name.]table_name ``` ## Beispiel ``` SHOW COLUMNS FROM iceberg_table ``` # Andere DDL-Operationen an Iceberg-Tabellen ausführen Zusätzlich zu den unter [Iceberg-Tabellenschema weiterentwickeln](querying-iceberg-evolving-table-schema.md) beschriebenen Operationen zur Schemaentwicklung, können Sie in Athena auch die folgenden DDL-Operationen für Apache Iceberg-Tabellen ausführen. ## Operationen auf Datenbankebene Wenn Sie [DROP DATABASE](drop-database.md) mit der Option `CASCADE` verwenden, werden auch alle Iceberg-Tabellendaten entfernt. Die folgenden DDL-Operationen haben keine Auswirkungen auf Iceberg-Tabellen. + [CREATE DATABASE](create-database.md) + [ALTER DATABASE SET DBPROPERTIES](alter-database-set-dbproperties.md) + [SHOW DATABASES](show-databases.md) + [SHOW TABLES](show-tables.md) + [SHOW VIEWS](show-views.md) ## Partition bezogene Operationen Da Iceberg-Tabellen [versteckte Partitionierung](https://iceberg.apache.org/docs/latest/partitioning/#icebergs-hidden-partitioning) verwenden, müssen Sie nicht direkt mit physischen Partitionen arbeiten. Infolgedessen unterstützen Iceberg-Tabellen in Athena die folgenden partitionsbezogenen DDL-Operationen nicht: + [SHOW PARTITIONS](show-partitions.md) + [ALTER TABLE ADD PARTITION](alter-table-add-partition.md) + [ALTER TABLE DROP PARTITION](alter-table-drop-partition.md) + [ALTER TABLE RENAME PARTITION](alter-table-rename-partition.md) Wenn Sie die [Evolution der Iceberg-Partition](https://iceberg.apache.org/docs/latest/evolution/#partition-evolution) in Athena sehen möchten, senden Sie Feedback an [athena-feedback@amazon.com](mailto:athena-feedback@amazon.com). ## Iceberg-Tabellen entladen Iceberg-Tabellen können in Dateien in einem Ordner auf Amazon S3 entladen werden. Weitere Informationen finden Sie unter [UNLOAD](unload.md). ## MSCK REPAIR Da Iceberg-Tabellen Informationen zum Tabellenlayout verfolgen, ist das Ausführen von [MSCK REPAIR TABLE](msck-repair-table.md) wie bei Hive-Tabellen nicht erforderlich und wird nicht unterstützt. # Iceberg-Tabellen optimieren Athena bietet mehrere Optimierungsfunktionen zur Verbesserung der Abfrageleistung auf Apache Iceberg-Tabellen. Wenn sich Daten ansammeln, können Abfragen aufgrund des erhöhten Dateiverarbeitungsaufwands und der Rechenkosten für Löschungen auf Zeilenebene, die in Iceberg-Löschdateien gespeichert sind, weniger effizient werden. Um diesen Herausforderungen zu begegnen, unterstützt Athena Bediener von manueller Verdichtungs- und Vakuumtechnik bei der Optimierung der Tischstruktur. Athena arbeitet auch mit Iceberg-Statistiken, um eine kostenbasierte Abfrageoptimierung und Parquet-Spaltenindizierung für eine präzise Datenbereinigung während der Abfrageausführung zu ermöglichen. Diese Funktionen arbeiten zusammen, um die Ausführungszeit von Abfragen zu verkürzen, das Scannen von Daten zu minimieren und die Kosten zu senken. In diesem Thema wird beschrieben, wie Sie diese Optimierungsfunktionen verwenden können, um Hochleistungsabfragen in Ihren Iceberg-Tabellen aufrechtzuerhalten. ## OPTIMIZE Die `OPTIMIZE table REWRITE DATA`-Verdichtungsaktion schreibt Datendateien basierend auf ihrer Größe und Anzahl der zugehörigen Löschdateien in ein optimierteres Layout um. Einzelheiten zur Syntax und Tabelleneigenschaften finden Sie unter [OPTIMIZE](optimize-statement.md). ### Beispiel Im folgenden Beispiel werden Löschdateien in Datendateien zusammengeführt und Dateien in der Nähe der Zieldateigröße erstellt, bei denen der Wert von `category` `c1` ist. ``` OPTIMIZE iceberg_table REWRITE DATA USING BIN_PACK WHERE category = 'c1' ``` ## VACUUM `VACUUM` führt den [Snapshot-Ablauf](https://iceberg.apache.org/docs/latest/spark-procedures/#expire_snapshots) und das [Entfernen verwaister Dateien](https://iceberg.apache.org/docs/latest/spark-procedures/#remove_orphan_files) durch. Diese Aktionen reduzieren die Größe der Metadaten und entfernen Dateien, die sich nicht im aktuellen Tabellenstatus befinden und zudem älter als die für die Tabelle angegebene Aufbewahrungsfrist sind. Einzelheiten zur Syntax finden Sie unter [VACUUM](vacuum-statement.md). ### Beispiel Im folgenden Beispiel wird eine Tabelleneigenschaft verwendet, um die Tabelle `iceberg_table` so zu konfigurieren, dass die Daten der letzten drei Tage beibehalten werden. Anschließend verwendet es `VACUUM`, um die alten Snapshots ablaufen zu lassen und die verwaisten Dateien aus der Tabelle zu entfernen. ``` ALTER TABLE iceberg_table SET TBLPROPERTIES ( 'vacuum_max_snapshot_age_seconds'='259200' ) VACUUM iceberg_table ``` ## Verwenden Sie Iceberg-Tabellenstatistiken Der kostenbasierte Optimierer von Athena verwendet Iceberg-Statistiken, um optimale Abfragepläne zu erstellen. Wenn Statistiken für Ihre Iceberg-Tabellen generiert wurden, verwendet Athena diese Informationen automatisch, um intelligente Entscheidungen über die Reihenfolge der Verknüpfungen, Filter und das Aggregationsverhalten zu treffen, wodurch häufig die Abfrageleistung verbessert und die Kosten gesenkt werden. Iceberg-Statistiken sind standardmäßig aktiviert, wenn Sie S3-Tabellen verwenden. Bei anderen Iceberg-Tabellen verwendet Athena die Tabelleneigenschaft, `use_iceberg_statistics` um zu bestimmen, ob Statistiken für die kostenbasierte Optimierung genutzt werden sollen. Erste Schritte finden Sie unter [Optimieren der Abfrageleistung mithilfe von Spaltenstatistiken](https://docs.aws.amazon.com//glue/latest/dg/column-statistics.html) im *AWS Glue Benutzerhandbuch* oder verwenden Sie die [Athena-Konsole](https://docs.aws.amazon.com/athena/latest/ug/cost-based-optimizer.html), um On-Demand-Statistiken für Ihre Iceberg-Tabellen zu generieren. ## Verwenden Sie die Parquet-Spaltenindizierung Die Parquet-Spaltenindizierung ermöglicht es Athena, während der Abfrageausführung eine genauere Datenbereinigung durchzuführen, indem zusätzlich zu Statistiken auf Zeilengruppenebene auch min/max Statistiken auf Seitenebene genutzt werden. Auf diese Weise kann Athena unnötige Seiten innerhalb von Zeilengruppen überspringen, wodurch die Menge der gescannten Daten erheblich reduziert und die Abfrageleistung verbessert wird. Es eignet sich am besten für Abfragen mit selektiven Filterprädikaten für sortierte Spalten. Dadurch werden sowohl die Ausführungszeit als auch die Effizienz des Datenscans verbessert und gleichzeitig die Datenmenge reduziert, die Athena aus Amazon S3 lesen muss. Athena verwendet standardmäßig Parquet-Spaltenindizes mit S3-Tabellen, wenn Spaltenindizes in den zugrunde liegenden Parquet-Dateien vorhanden sind. Bei anderen Iceberg-Tabellen bestimmt Athena anhand der `use_iceberg_parquet_column_index` Eigenschaft, ob die Spaltenindizes in der Parquet-Datei verwendet werden sollen. Stellen Sie diese Tabelleneigenschaft mithilfe der AWS Glue Konsole oder der API ein. `UpdateTable` # Materialisierte Ansichten des AWS Glue Datenkatalogs abfragen Mit Athena können Sie materialisierte AWS Glue Datenkatalogansichten abfragen. Materialisierte Ansichten von Glue Data Catalog speichern vorberechnete Ergebnisse von SQL-Abfragen als Apache Iceberg-Tabellen. Wenn Sie materialisierte Ansichten von Glue Data Catalog mit Apache Spark in Amazon EMR oder erstellen AWS Glue, werden die Ansichtsdefinitionen und Metadaten im AWS Glue Datenkatalog gespeichert. Die vorberechneten Ergebnisse werden als Apache Iceberg-Tabellen in Amazon S3 gespeichert. Sie können diese materialisierten Ansichten von Athena mit `SELECT` Standard-SQL-Anweisungen abfragen, genauso wie Sie normale Iceberg-Tabellen abfragen würden. ## Voraussetzungen Bevor Sie materialisierte Ansichten in Athena abfragen, stellen Sie Folgendes sicher: + Die materialisierte Ansicht ist im AWS Glue Datenkatalog vorhanden und wurde mit Apache Spark (Amazon EMR Version 7.12.0 oder höher oder AWS Glue Version 5.1 oder höher) erstellt + Um materialisierte Ansichten in Athena abzufragen, benötigen Sie die folgenden Berechtigungen: AWS Lake Formation + `SELECT`Erlaubnis für die materialisierte Ansicht + `DESCRIBE`Genehmigung für die materialisierte Ansicht + Zugriff auf den zugrunde liegenden Amazon S3 S3-Speicherort, an dem die materialisierten View-Daten gespeichert sind + Die der materialisierten Ansicht zugrunde liegenden Daten werden in Amazon S3 S3-Tabellen-Buckets oder Amazon S3 S3-Allzweck-Buckets gespeichert. + Sie haben Zugriff auf die AWS Glue Data Catalog-Datenbank, die die materialisierte Ansicht enthält + Stellen Sie für materialisierte Ansichten, die in Amazon S3 Tables-Buckets gespeichert sind, sicher, dass Ihre IAM-Rolle über die erforderlichen Berechtigungen für den Zugriff auf den S3 Tables-Katalog verfügt. ## Überlegungen und Einschränkungen + Athena unterstützt die folgenden Operationen für materialisierte Ansichten nicht:`ALTER`,,`CREATE MATERIALIZED VIEW`,`REFRESH MATERIALIZED VIEW`,`DROP`,`INSERT`,`UPDATE`, `MERGE``DELETE`,`OPTIMIZE`. `VACUUM` Verwenden Sie Apache Spark in Amazon EMR oder, um materialisierte Ansichten zu erstellen. AWS Glue Aktualisierungsvorgänge müssen über die AWS Glue Data Catalog API oder Apache Spark ausgeführt werden. Ändern Sie materialisierte Ansichten mit Apache Spark. ## Abfragen materialisierter Ansichten Athena behandelt materialisierte Ansichten wie standardmäßige Iceberg-Tabellen für Lesevorgänge, sodass Sie auf die vorberechneten Daten zugreifen können, ohne dass spezielle Syntax- oder Konfigurationsänderungen erforderlich sind. Verwenden Sie `SELECT` Standardanweisungen, um eine materialisierte Ansicht in Athena abzufragen: ``` SELECT * FROM my_database.sales_summary_mv; ``` Sie können Filter, Aggregationen und Verknüpfungen genauso anwenden, wie Sie es mit normalen Tabellen tun würden: ``` SELECT region, SUM(total_sales) as sales_total FROM my_database.sales_summary_mv WHERE year = 2025 GROUP BY region ORDER BY sales_total DESC; ``` ## Unterstützte Vorgänge Athena unterstützt die folgenden Operationen für materialisierte Ansichten: + `SELECT`Abfragen — Lesen Sie Daten aus materialisierten Ansichten mithilfe von Standard-SQL-Anweisungen `SELECT` + `DESCRIBE`- Sehen Sie sich das Schema und die Metadaten materialisierter Ansichten an + `SHOW TABLES`- Listet materialisierte Ansichten zusammen mit anderen Tabellen in einer Datenbank auf + `JOIN`Operationen — Verbindet materialisierte Ansichten mit anderen Tabellen oder Ansichten + Filterung und Aggregation — Wenden Sie `WHERE` Klauseln und Aggregatfunktionen `GROUP BY` an # Unterstützte Datentypen für Iceberg-Tabellen in Athena Athena kann Iceberg-Tabellen abfragen, die die folgenden Datentypen enthalten: ``` binary boolean date decimal double float int list long map string struct timestamp without time zone ``` Weitere Hinweise zu Iceberg-Tabellentypen finden Sie auf der [Schemas-Seite für Iceberg](https://iceberg.apache.org/docs/latest/schemas/) in der Apache-Dokumentation. Die folgende Tabelle zeigt das Verhältnis zwischen Athena-Datentypen und Datentypen von Iceberg-Tabellen. **** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/athena/latest/ug/querying-iceberg-supported-data-types.html) Weitere Informationen zu Datentypen in Athena finden Sie unter [Datentypen in Amazon Athena](data-types.md). # Weitere Ressourcen Der folgende Artikel ist in der Dokumentation AWS Prescriptive Guidance enthalten. + [Arbeiten mit Apache Iceberg-Tabellen mithilfe von Amazon Athena SQL](https://docs.aws.amazon.com/prescriptive-guidance/latest/apache-iceberg-on-aws/iceberg-athena.html) Ausführliche Artikel zur Verwendung von Athena mit Apache-Iceberg-Tabellen finden Sie in den folgenden Beiträgen im *AWS -Big-Data-Blog*. + [Implementieren Sie einen Serverless CDC-Prozess mit Apache Iceberg mithilfe von Amazon DynamoDB und Amazon Athena](https://aws.amazon.com/blogs/big-data/implement-a-serverless-cdc-process-with-apache-iceberg-using-amazon-dynamodb-and-amazon-athena/) + [Beschleunigen Sie das Datenwissenschaft-Feature-Engineering auf transaktionalen Data Lakes mithilfe von Amazon Athena mit Apache Iceberg](https://aws.amazon.com/blogs/big-data/accelerate-data-science-feature-engineering-on-transactional-data-lakes-using-amazon-athena-with-apache-iceberg/) + [Erstellen Sie einen Apache Iceberg Data Lake mit Amazon Athena, Amazon EMR und AWS Glue](https://aws.amazon.com/blogs/big-data/build-an-apache-iceberg-data-lake-using-amazon-athena-amazon-emr-and-aws-glue/) + [Führen Sie Upserts in einem Data Lake mit Amazon Athena und Apache Iceberg durch](https://aws.amazon.com/blogs/big-data/perform-upserts-in-a-data-lake-using-amazon-athena-and-apache-iceberg/) + [Erstellen Sie einen transaktionalen Data Lake mit Apache Iceberg und kontoübergreifende Datenfreigaben mit Amazon Athena AWS GlueAWS Lake Formation](https://aws.amazon.com/blogs/big-data/build-a-transactional-data-lake-using-apache-iceberg-aws-glue-and-cross-account-data-shares-using-aws-lake-formation-and-amazon-athena/) + [Verwenden Sie Apache Iceberg in einem Data Lake, um die inkrementelle Datenverarbeitung zu unterstützen](https://aws.amazon.com/blogs/big-data/use-apache-iceberg-in-a-data-lake-to-support-incremental-data-processing/) + [Erstellen Sie einen Data Lake für Apache Iceberg in Echtzeit, der an die DSGVO angepasst ist](https://aws.amazon.com/blogs/big-data/build-a-real-time-gdpr-aligned-apache-iceberg-data-lake/) + [Automatisieren Sie die Replikation relationaler Quellen in einen transaktionalen Data Lake mit Apache Iceberg und AWS Glue](https://aws.amazon.com/blogs/big-data/automate-replication-of-relational-sources-into-a-transactional-data-lake-with-apache-iceberg-and-aws-glue/) + [Interagieren Sie mit Apache Iceberg-Tabellen mithilfe von Amazon Athena und kontoübergreifenden, fein abgestuften Berechtigungen mithilfe von AWS Lake Formation](https://aws.amazon.com/blogs/big-data/interact-with-apache-iceberg-tables-using-amazon-athena-and-cross-account-fine-grained-permissions-using-aws-lake-formation/) + [Erstellen Sie mit Apache Iceberg, Amazon EMR Serverless und Amazon Athena Serverless einen Serverless-Transaktions-Data-Lake](https://aws.amazon.com/blogs/big-data/build-a-serverless-transactional-data-lake-with-apache-iceberg-amazon-emr-serverless-and-amazon-athena/)