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. # Erstellen einer Tabelle aus Abfrageergebnissen (CTAS) Eine `CREATE TABLE AS SELECT`-(CTAS)-Abfrage erstellt eine neue Tabelle in Athena aus den Ergebnissen einer `SELECT`-Anweisung aus einer anderen Abfrage. Athena speichert Datendateien, die von einer CTAS-Anweisung erstellt wurden, in einem angegebenen Speicherort in Amazon S3. Weitere Informationen zur Syntax finden Sie unter [CREATE TABLE AS](create-table-as.md). `CREATE TABLE AS` kombiniert eine `CREATE TABLE`-DDL-Anweisung mit einer `SELECT`-DML-Anweisung und enthält daher technisch gesehen sowohl DDL als auch DML. Beachten Sie jedoch, dass CTAS-Abfragen in Athena aus Gründen der Service Quotas als DML behandelt werden. Informationen zu Service Quotas für Athena finden Sie unter [Service Quotas](service-limits.md). Verwenden Sie CTAS-Abfragen, um: + Tabellen aus Abfrageergebnissen in einem Schritt zu erstellen, ohne wiederholt Rohdatensets abzufragen. Dies vereinfacht die Arbeit mit Rohdatensets. + Transformieren Sie Abfrageergebnisse und migrieren Sie Tabellen in andere Tabellenformate wie Apache Iceberg. Dies verbessert die Abfrageleistung und reduziert die Abfragekosten in Athena. Weitere Informationen finden Sie unter [Iceberg-Tabellen erstellen](querying-iceberg-creating-tables.md). + Transformieren Sie Abfrageergebnisse in Speicherformate wie Parquet und ORC. Dies verbessert die Abfrageleistung und reduziert die Abfragekosten in Athena. Weitere Informationen finden Sie unter [Spaltenbasierte Speicherformate verwenden](columnar-storage.md). + Kopien von vorhandenen Tabellen zu erstellen, die nur die Daten enthalten, die Sie benötigen. **Topics** + [Überlegungen und Einschränkungen für CTAS-Abfragen](ctas-considerations-limitations.md) + [CTAS-Abfragen erstellen](ctas-console.md) + [CTAS-Beispiele](ctas-examples.md) + [Verwenden von CTAS und INSERT INTO für ETL](ctas-insert-into-etl.md) + [Das Limit von 100 Partitionen umgehen](ctas-insert-into.md) # Überlegungen und Einschränkungen für CTAS-Abfragen In den folgenden Abschnitten werden Überlegungen und Einschränkungen beschrieben, die Sie bei der Verwendung von `CREATE TABLE AS SELECT` (CTAS)-Abfragen in Athena berücksichtigen sollten. ## Lernen Sie die CTAS-Abfragesyntax kennen Die CTAS-Abfragesyntax unterscheidet sich von der Syntax `CREATE [EXTERNAL] TABLE` für das Erstellen von Tabellen. Siehe [CREATE TABLE AS](create-table-as.md). ## Der Unterschied zwischen Ansichten und CTAS-Abfragen CTAS-Abfragen schreiben neue Daten in einen bestimmten Speicherort in Amazon S3. Ansichten schreiben keine Daten. ## Einen Speicherort für Ihre CTAS-Abfrageergebnisse angeben Wenn Ihre Arbeitsgruppe [die clientseitige Einstellung überschreibt](workgroups-settings-override.md), die für den Speicherort der Abfrageergebnisse gilt, erstellt Athena die Tabelle am Speicherort `s3://amzn-s3-demo-bucket/tables//`. Den für die Arbeitsgruppe angegebenen Speicherort für Abfrageergebnisse können Sie in den [Arbeitsgruppendetails](viewing-details-workgroups.md) anzeigen. Wenn Ihre Arbeitsgruppe den Speicherort für Abfrageergebnisse nicht überschreibt, können Sie die Syntax `WITH (external_location ='s3://amzn-s3-demo-bucket/')` in der CTAS-Abfrage verwenden, um den Speicherort für CTAS-Abfrageergebnisse anzugeben. **Anmerkung** Die Eigenschaft `external_location` muss einen Speicherort angeben, der leer ist. Eine CTAS-Abfrage überprüft, ob der Pfadspeicherort (Präfix) im Bucket leer ist und überschreibt niemals die Daten, wenn der Speicherort bereits Daten enthält. Um denselben Speicherort erneut zu verwenden, löschen Sie die Daten im Schlüsselpräfixspeicherort im Bucket. Wenn Sie die Syntax `external_location` auslassen und die Arbeitsgruppeneinstellung nicht verwenden, verwendet Athena die [clientseitige Einstellung](query-results-specify-location-console.md) für den Abfrageergebnisspeicherort und erstellt die Tabelle am Speicherort `s3://amzn-s3-demo-bucket////tables//`. ## Suchen verwaister Dateien Wenn eine `CTAS`- oder `INSERT INTO`-Anweisung fehlschlägt, ist es möglich, dass verwaiste Datendateien für fehlgeschlagene oder abgebrochene Abfragen am Zieldatenspeicherort verbleiben. Da Athena in einigen Fällen keine Daten aus dem Ziel-Bucket für Ihre Abfrage löscht, können die Teildaten möglicherweise in nachfolgenden Abfragen enthalten sein. Zur Suche nach verwaisten Dateien zwecks Überprüfung oder Löschung können Sie die Daten-Manifest-Datei verwenden, die Athena zur Verfügung stellt, um die Liste der zu schreibenden Dateien zu verfolgen. In einigen seltenen Fällen, in denen eine Athena-Abfrage plötzlich fehlschlug, ist die Manifestdatei möglicherweise nicht vorhanden. Sie können den Ziel-S3-Speicherort manuell überprüfen, um die verwaisten Dateien zu finden. Weitere Informationen finden Sie unter [Identifizieren von Abfrageausgabedateien](querying-finding-output-files.md#querying-identifying-output-files) und [DataManifestLocation](https://docs.aws.amazon.com/athena/latest/APIReference/API_QueryExecutionStatistics.html#athena-Type-QueryExecutionStatistics-DataManifestLocation). Wir empfehlen dringend, Apache Iceberg zu verwenden, um atomare Transaktionen von Tabellen durchzuführen. Weitere Informationen finden Sie unter [Apache-Iceberg-Tabellen abfragen](querying-iceberg.md). ## Beachten Sie, dass ORDER BY-Klauseln ignoriert werden In einer CTAS-Abfrage ignoriert Athena `ORDER BY`-Klauseln im `SELECT`-Teil der Abfrage. Gemäß der SQL-Spezifikation (ISO 9075 Teil 2) ist die Reihenfolge der Zeilen einer durch einen Abfrageausdruck angegebenen Tabelle nur für den Abfrageausdruck garantiert, der die `ORDER BY`-Klausel unmittelbar enthält. Tabellen in SQL sind ohnehin von Natur aus ungeordnet, und die Implementierung der `ORDER BY` in der Unterabfrage-Klauseln würde sowohl zu einer schlechten Leistung der Abfrage als auch zu keiner geordneten Ausgabe führen. Daher gibt es bei Athena-CTAS-Abfragen keine Garantie dafür, dass die in der `ORDER BY`-Klausel angegebene Reihenfolge beim Schreiben der Daten beibehalten wird. ## Ein Format zum Speichern Ihrer Abfrageergebnisse auswählen Sie können CTAS-Ergebnisse in `PARQUET`, `ORC`, `AVRO`, `JSON` und `TEXTFILE` speichern. Mehrzeichen-Trennzeichen werden für das CTAS-`TEXTFILE`-Format nicht unterstützt. Wenn Sie kein Datenspeicherformat angeben, werden die CTAS-Abfrageergebnisse standardmäßig in Parquet gespeichert. Bei CTAS-Abfragen ist die Angabe von a nicht erforderlich SerDe , um Formattransformationen zu interpretieren. Siehe [Example: Writing query results to a different format](ctas-examples.md#ctas-example-format). ## Komprimierungsformate berücksichtigen `GZIP`-Komprimierung wird für CTAS-Abfrageergebnisse in JSON- und TEXTFILE-Formaten verwendet. Für Parquet können Sie `GZIP` oder `SNAPPY` verwenden, der Standardwert ist `GZIP`. Für ORC können Sie `LZ4`, `SNAPPY`, `ZLIB`oder `ZSTD` verwenden, der Standardwert ist `ZLIB`. Beispiele für CTAS, die die Komprimierung angeben, finden Sie unter [Example: Specifying data storage and compression formats](ctas-examples.md#ctas-example-compression). Weitere Informationen zur Komprimierung in Athena finden Sie unter [Komprimierung in Athena verwenden](compression-formats.md). ## Partitionieren und gruppieren Sie Ihre Ergebnisse Sie können die Ergebnisdaten einer CTAS-Abfrage partitionieren und in Buckets speichern. Um Eigenschaften der Zieltabelle anzugeben, fügen Sie am Ende der `WITH`-Klausel Partitionierungs- und Bucketing-Prädikate ein. Weitere Informationen erhalten Sie unter [Partitionierung und Bucketing verwenden](ctas-partitioning-and-bucketing.md) und [Example: Creating bucketed and partitioned tables](ctas-examples.md#ctas-example-bucketed). Wenn Sie CTAS verwenden, um eine partitionierte Tabelle zu erstellen, hat Athena ein Schreiblimit von 100 Partitionen. Hinweise zum Umgehen der Begrenzung auf 100 Partitionen finden Sie unter [Verwenden von CTAS und INSERT INTO zum Umgehen des Limits von 100 Partitionen](ctas-insert-into.md). ## Ihre Ergebnisse verschlüsseln Sie können CTAS-Abfrageergebnisse in Amazon S3 verschlüsseln, so wie Sie auch andere Abfrageergebnisse in Athena verschlüsseln. Weitere Informationen finden Sie unter [Verschlüsseln Sie die in Amazon S3 gespeicherten Athena-Abfrageergebnisse](encrypting-query-results-stored-in-s3.md). ## Die erwartete Bucket-Eigentümereinstellung gilt nicht für CTAS Für CTAS-Anweisungen gilt die erwartete Bucket-Eigentümereinstellung nicht für den Speicherort der Zieltabelle in Amazon S3. Die erwartete Bucket-Eigentümereinstellung gilt nur für den Amazon-S3-Ausgabespeicherort, den Sie für Athena-Abfrageergebnisse angeben. Weitere Informationen finden Sie unter [Angeben eines Speicherorts des Abfrageergebnisses mithilfe der Athena-Konsole](query-results-specify-location-console.md). ## Spaltendatentypen werden beibehalten Spaltendatentypen für eine CTAS-Abfrage sind dieselben wie für die ursprüngliche Abfrage angegeben. # CTAS-Abfragen in der Athena-Konsole erstellen In der Athena-Konsole können Sie eine CTAS-Abfrage aus einer anderen Abfrage erstellen. **So erstellen Sie eine CTAS-Abfrage aus einer anderen Abfrage** 1. Führen Sie die Abfrage im Abfrage-Editor der Athena-Konsole aus. 1. Wählen Sie unten im Abfrage-Editor die Option **Create** (Erstellen) aus und wählen Sie dann **Table from query** (Tabelle aus Abfrage) aus. 1. Füllen Sie im Formular **Create table as select** (Tabelle als Auswahl erstellen) die Felder wie folgt aus: 1. Geben Sie im Feld **Table name** (Tabellenname) den Namen für Ihre neue Tabelle an. Verwenden Sie nur Kleinbuchstaben und Unterstriche, wie z. B. `my_select_query_parquet`. 1. Verwenden Sie für **Database configuration** (Datenbankkonfiguration) die Optionen, um eine vorhandene Datenbank auszuwählen oder eine Datenbank zu erstellen. 1. (Optional) Führen Sie in **Result configuration** (Ergebniskonfiguration) für **Location of CTAS query results** (Speicherort der CTAS-Abfrageergebnisse) einen der folgenden Schritte aus, wenn die Einstellung für den Speicherort Ihrer Arbeitsgruppen-Abfrageergebnisse diese Option nicht überschreibt: + Geben Sie den Pfad zu einem vorhandenen S3-Speicherort in das Suchfeld ein oder wählen Sie **Browse S3** (S3 durchsuchen) aus, um einen Speicherort aus einer Liste auszuwählen. + Wählen Sie **View** (Anzeigen), um die Seite **Buckets** der Amazon-S3-Konsole zu öffnen. Hier finden Sie weitere Informationen zu Ihren vorhandenen Buckets und können einen Bucket mit Ihren eigenen Einstellungen auswählen oder erstellen. Sie sollten einen leeren Speicherort in Amazon S3 angeben, an dem die Daten ausgegeben werden. Wenn an dem von Ihnen angegebenen Speicherort bereits Daten vorhanden sind, schlägt die Abfrage mit einem Fehler fehl. Wenn die Speicherorteinstellung Ihrer Arbeitsgruppen-Abfrageergebnisse diese Standorteinstellung überschreibt, erstellt Athena Ihre Tabelle am Speicherort `s3://amzn-s3-demo-bucket/tables/query_id/` 1. Geben Sie unter **Data format** (Datenformat) das Format an, in dem Ihre Daten vorliegen. + **Tabellentyp** – Der Standardtabellentyp in Athena ist Apache Hive. + **Dateiformat** – Wählen Sie zwischen Optionen wie CSV, TSV, JSON, Parquet oder ORC. Weitere Informationen über die Formate Parquet und ORC finden Sie unter [Spaltenbasierte Speicherformate verwenden](columnar-storage.md). + **Schreibkomprimierung** – (Optional) Wählen Sie ein Komprimierungsformat. Athena unterstützt eine Vielzahl von Komprimierungsformate zum Lesen und Schreiben von Daten, einschließlich des Lesens aus einer Tabelle, die mehrere Komprimierungsformate verwendet. Zum Beispiel kann Athena die Daten in einer Tabelle erfolgreich lesen, die das Parquet-Dateiformat verwendet, wenn einige Parquet-Dateien mit Snappy komprimiert werden und andere Parquet-Dateien mit GZIP komprimiert werden. Das gleiche Prinzip gilt für ORC-, Textfile- und JSON-Speicherformate. Weitere Informationen finden Sie unter [Komprimierung in Athena verwenden](compression-formats.md). + **Partitionen** – (Optional) Wählen Sie die Spalten aus, die Sie partitionieren möchten. Die Partitionierung Ihrer Daten schränkt die Menge der von jeder Abfrage gescannten Daten ein, wodurch die Leistung verbessert und die Kosten gesenkt werden. Sie können Ihre Daten nach einem beliebigen Schlüssel partitionieren. Weitere Informationen finden Sie unter [Ihre Daten partitionieren](partitions.md). + **Buckets** – (Optional) Wählen Sie die Spalten aus, die Sie auslagern möchten. Bucketing ist eine Technik, bei der Daten auf der Grundlage bestimmter Spalten in einer einzigen Partition gruppiert werden. Diese Spalten werden als *Bucket-Schlüssel* bezeichnet. Durch die Gruppierung zusammengehöriger Daten in einem einzigen Bucket (eine Datei innerhalb einer Partition) reduzieren Sie die Menge der von Athena gescannten Daten erheblich und verbessern so die Abfrageleistung und senken die Kosten. Weitere Informationen finden Sie unter [Partitionierung und Bucketing verwenden](ctas-partitioning-and-bucketing.md). 1. Überprüfen Sie für **Preview table query** (Vorschau der Tabellenabfrage) Ihre Abfrage. Weitere Informationen zur Abfragesyntax finden Sie unter [CREATE TABLE AS](create-table-as.md). 1. Wählen Sie **Create table** (Tabelle erstellen) aus. Die Athena-Konsole verfügt über eine SQL-Vorlage, mit der Sie ebenfalls eine CTAS-Abfrage erstellen können. **Erstellen Sie eine CTAS-Abfrage mithilfe einer SQL-Vorlage wie folgt** Verwenden Sie die `CREATE TABLE AS SELECT`-Vorlage zum Erstellen einer CTAS-Abfrage im Abfrage-Editor. 1. Wählen Sie in der Athena-Konsole neben **Tables and views** (Tabellen und Ansichten) **Create table** (Tabelle erstellen) und dann **CREATE TABLE AS SELECT** (TABELLE ERSTELLEN WIE AUSGEWÄHLT) aus. Dies befüllt den Abfrage-Editor mit einer CTAS-Abfrage mit Platzhalterwerten. 1. Bearbeiten Sie im Abfrageeditor die Abfrage nach Bedarf. Weitere Informationen zur Abfragesyntax finden Sie unter [CREATE TABLE AS](create-table-as.md). 1. Klicken Sie auf **Ausführen**. Beispiele finden Sie unter [Beispiele für CTAS-Abfragen](ctas-examples.md). # Beispiele für CTAS-Abfragen Verwenden Sie die folgenden Beispiele zum Erstellen von CTAS-Abfragen. Weitere Information zur CTAS-Syntax finden Sie unter [CREATE TABLE AS](create-table-as.md). In diesem Abschnitt: + [Example: Duplicating a table by selecting all columns](#ctas-example-dupe-table) + [Example: Selecting specific columns from one or more tables](#ctas-example-specify-columns) + [Example: Creating an empty copy of an existing table](#ctas-example-empty-table) + [Example: Specifying data storage and compression formats](#ctas-example-compression) + [Example: Writing query results to a different format](#ctas-example-format) + [Example: Creating unpartitioned tables](#ctas-example-unpartitioned) + [Example: Creating partitioned tables](#ctas-example-partitioned) + [Example: Creating bucketed and partitioned tables](#ctas-example-bucketed) + [Example: Creating an Iceberg table with Parquet data](#ctas-example-iceberg-parquet) + [Example: Creating an Iceberg table with Avro data](#ctas-example-iceberg-avro) + [Example: Creating an S3 table using CTAS](#ctas-example-s3-table) **Example -Beispiel: Duplizieren einer Tabelle durch Auswahl aller Spalten** Das folgende Beispiel erstellt eine Tabelle durch Kopieren aller Spalten aus einer Tabelle: ``` CREATE TABLE new_table AS SELECT * FROM old_table; ``` In der folgenden Variante des gleichen Beispiels enthält Ihre `SELECT`-Anweisung auch eine `WHERE`-Klausel. In diesem Fall wählt die Abfrage nur die Zeilen aus der Tabelle aus, die die `WHERE`-Klausel erfüllen: ``` CREATE TABLE new_table AS SELECT * FROM old_table WHERE condition; ``` **Example -Beispiel: Auswählen bestimmter Spalten aus einer oder mehreren Tabellen** Das folgende Beispiel erstellt eine neue Abfrage, die auf einer Reihe von Spalten aus einer anderen Tabelle ausgeführt wird: ``` CREATE TABLE new_table AS SELECT column_1, column_2, ... column_n FROM old_table; ``` Diese Variation des gleichen Beispiels erstellt eine neue Tabelle aus bestimmten Spalten aus mehreren Tabellen: ``` CREATE TABLE new_table AS SELECT column_1, column_2, ... column_n FROM old_table_1, old_table_2, ... old_table_n; ``` **Example -Beispiel: Erstellen einer leeren Kopie einer vorhandenen Tabelle** Das folgende Beispiel verwendet `WITH NO DATA`, um eine neue Tabelle zu erstellen, die leer ist und das gleiche Schema wie die ursprüngliche Tabelle aufweist: ``` CREATE TABLE new_table AS SELECT * FROM old_table WITH NO DATA; ``` **Example -Beispiel: Angeben von Datenspeicherungs- und Komprimierungsformaten** Mit CTAS können Sie eine Quelltabelle in einem Speicherformat verwenden, um eine weitere Tabelle in einem anderen Speicherformat zu erstellen. Verwenden Sie die `format`-Eigenschaft, um `ORC` `PARQUET` ,`AVRO`, `JSON` oder `TEXTFILE` als Speicherformat für die neue Tabelle anzugeben. Verwenden Sie für die Speicherformate `PARQUET`, `ORC`, `TEXTFILE`, und `JSON` die `write_compression`-Eigenschaft, um das Komprimierungsformat für die Daten der neuen Tabelle anzugeben. Informationen zu den Komprimierungsformaten, die jedes Dateiformat unterstützt, finden Sie unter [Komprimierung in Athena verwenden](compression-formats.md). Das folgende Beispiel gibt an, dass die Daten in der Tabelle `new_table` im Parquet-Format gespeichert werden und die Snappy-Komprimierung verwenden. Die Standardkomprimierung für Parquet ist `GZIP`. ``` CREATE TABLE new_table WITH ( format = 'Parquet', write_compression = 'SNAPPY') AS SELECT * FROM old_table; ``` Das folgende Beispiel gibt an, dass die Daten in der Tabelle `new_table` im ORC-Format gespeichert werden und die Snappy-Komprimierung verwenden. Die Standardkomprimierung für ORC ist ZLIB. ``` CREATE TABLE new_table WITH (format = 'ORC', write_compression = 'SNAPPY') AS SELECT * FROM old_table ; ``` Das folgende Beispiel gibt an, dass die Daten in der Tabelle `new_table` im Textfile-Format gespeichert werden und die Snappy-Komprimierung verwenden. Die Standardkomprimierung sowohl für das Textfile- als auch für das JSON-Format ist GZIP. ``` CREATE TABLE new_table WITH (format = 'TEXTFILE', write_compression = 'SNAPPY') AS SELECT * FROM old_table ; ``` **Example -Beispiel: Schreiben von Abfrageergebnissen in ein anderes Format** Die folgende CTAS-Abfrage wählt alle Datensätze aus `old_table` aus, die in CSV oder einem anderen Format gespeichert werden können, und erstellt eine neue Tabelle, wobei die zugrunde liegenden Daten im ORC-Format in Amazon S3 gespeichert sind: ``` CREATE TABLE my_orc_ctas_table WITH ( external_location = 's3://amzn-s3-demo-bucket/my_orc_stas_table/', format = 'ORC') AS SELECT * FROM old_table; ``` **Example -Beispiel: Erstellen von nicht partitionierten Tabellen** Die folgenden Beispiele erstellen Tabellen, die nicht partitioniert werden. Die Tabellendaten werden in verschiedenen Formaten gespeichert. Einige dieser Beispiele geben den externen Speicherort an. Das folgende Beispiel erstellt eine CTAS-Abfrage, die die Ergebnisse als Textdatei speichert: ``` CREATE TABLE ctas_csv_unpartitioned WITH ( format = 'TEXTFILE', external_location = 's3://amzn-s3-demo-bucket/ctas_csv_unpartitioned/') AS SELECT key1, name1, address1, comment1 FROM table1; ``` Im folgenden Beispiel werden die Ergebnisse in Parquet gespeichert und der standardmäßige Ergebnisspeicherort wird verwendet: ``` CREATE TABLE ctas_parquet_unpartitioned WITH (format = 'PARQUET') AS SELECT key1, name1, comment1 FROM table1; ``` In der folgenden Abfrage wird die Tabelle in JSON gespeichert und bestimmte Spalten aus den Ergebnissen der ursprünglichen Tabelle ausgewählt: ``` CREATE TABLE ctas_json_unpartitioned WITH ( format = 'JSON', external_location = 's3://amzn-s3-demo-bucket/ctas_json_unpartitioned/') AS SELECT key1, name1, address1, comment1 FROM table1; ``` Im folgenden Beispiel lautet das Format ORC: ``` CREATE TABLE ctas_orc_unpartitioned WITH ( format = 'ORC') AS SELECT key1, name1, comment1 FROM table1; ``` Im folgenden Beispiel lautet das Format Avro: ``` CREATE TABLE ctas_avro_unpartitioned WITH ( format = 'AVRO', external_location = 's3://amzn-s3-demo-bucket/ctas_avro_unpartitioned/') AS SELECT key1, name1, comment1 FROM table1; ``` **Example -Beispiel: Erstellen partitionierter Tabellen** Die folgenden Beispiele zeigen `CREATE TABLE AS SELECT`-Abfragen für partitionierte Tabellen in verschiedenen Datenspeicherformaten unter Verwendung von `partitioned_by` und anderen Eigenschaften in der `WITH`-Klausel. Weitere Informationen zur Syntax finden Sie unter [CTAS-Tabelleneigenschaften](create-table-as.md#ctas-table-properties). Weitere Informationen zur Auswahl der Spalten für die Partitionierung finden Sie unter [Partitionierung und Bucketing verwenden](ctas-partitioning-and-bucketing.md). Auflisten von Partitionsspalten am Ende der Liste der Spalten in der `SELECT`-Anweisung. Sie können in mehrere Spalten partitionieren und über bis zu 100 eindeutige Partitions- und Bucket-Kombinationen verfügen. Sie können beispielsweise 100 Partitionen haben, wenn keine Buckets angegeben sind. ``` CREATE TABLE ctas_csv_partitioned WITH ( format = 'TEXTFILE', external_location = 's3://amzn-s3-demo-bucket/ctas_csv_partitioned/', partitioned_by = ARRAY['key1']) AS SELECT name1, address1, comment1, key1 FROM tables1; ``` ``` CREATE TABLE ctas_json_partitioned WITH ( format = 'JSON', external_location = 's3://amzn-s3-demo-bucket/ctas_json_partitioned/', partitioned_by = ARRAY['key1']) AS select name1, address1, comment1, key1 FROM table1; ``` **Example -Beispiel: Erstellen von Tabellen mit Bucketing und Partitionierung** Das folgende Beispiel zeigt eine `CREATE TABLE AS SELECT`-Abfrage, die sowohl die Partitionierung als auch das Bucketing zum Speichern von Abfrageergebnissen in Amazon S3 verwendet. Die Tabellenergebnisse werden partitioniert und nach verschiedenen Spalten gruppiert. Athena unterstützt maximal 100 eindeutige Kombinationen aus Bucket und Partition. Wenn Sie beispielsweise eine Tabelle mit fünf Buckets erstellen, werden 20 Partitionen mit je fünf Buckets unterstützt. Weitere Informationen zur Syntax finden Sie unter [CTAS-Tabelleneigenschaften](create-table-as.md#ctas-table-properties). Weitere Informationen zur Auswahl der Spalten für das Bucketing finden Sie unter [Partitionierung und Bucketing verwenden](ctas-partitioning-and-bucketing.md). ``` CREATE TABLE ctas_avro_bucketed WITH ( format = 'AVRO', external_location = 's3://amzn-s3-demo-bucket/ctas_avro_bucketed/', partitioned_by = ARRAY['nationkey'], bucketed_by = ARRAY['mktsegment'], bucket_count = 3) AS SELECT key1, name1, address1, phone1, acctbal, mktsegment, comment1, nationkey FROM table1; ``` **Example -Beispiel: Erstellen einer Iceberg-Tabelle mit Parquet-Daten** Im folgenden Beispiel wird eine Iceberg-Tabelle mit Parquet-Datendateien erstellt. Die Dateien werden mithilfe der `dt`-Spalte in `table1` nach Monaten partitioniert. Das Beispiel aktualisiert die Aufbewahrungseigenschaften für die Tabelle, sodass standardmäßig 10 Snapshots in jeder Verzweigung in der Tabelle aufbewahrt werden. Snapshots innerhalb der letzten 7 Tage werden ebenfalls aufbewahrt. Weitere Informationen zu Iceberg-Tabelleneigenschaften in Athena finden in [Tabelleneigenschaften angeben](querying-iceberg-creating-tables.md#querying-iceberg-table-properties). ``` CREATE TABLE ctas_iceberg_parquet WITH (table_type = 'ICEBERG', format = 'PARQUET', location = 's3://amzn-s3-demo-bucket/ctas_iceberg_parquet/', is_external = false, partitioning = ARRAY['month(dt)'], vacuum_min_snapshots_to_keep = 10, vacuum_max_snapshot_age_seconds = 604800 ) AS SELECT key1, name1, dt FROM table1; ``` **Example -Beispiel: Erstellen einer Iceberg-Tabelle mit Avro-Daten** Im folgenden Beispiel wird eine Iceberg-Tabelle mit Avro-Datendateien mit Partitionierung durch `key1` erstellt. ``` CREATE TABLE ctas_iceberg_avro WITH ( format = 'AVRO', location = 's3://amzn-s3-demo-bucket/ctas_iceberg_avro/', is_external = false, table_type = 'ICEBERG', partitioning = ARRAY['key1']) AS SELECT key1, name1, date FROM table1; ``` **Example Beispiel: Erstellen einer S3-Tabelle mit CTAS** Im folgenden Beispiel wird mithilfe von CTAS eine neue S3-Tabelle erstellt. Beachten Sie, dass die location-Eigenschaft weggelassen wird und `table_type` standardmäßig auf `ICEBERG` gesetzt ist: ``` CREATE TABLE "s3tablescatalog/amzn-s3-demo-bucket"."namespace"."s3-table-name" WITH ( format = 'PARQUET' ) AS SELECT * FROM source_table; ``` Sie können alle anderen Eigenschaften von Iceberg-Tabellen, wie Partitionierung und Bucketing, mit derselben Syntax wie normale Iceberg-Tabellen angeben. # Verwenden von CTAS und INSERT INTO für ETL und Datenanalyse Sie können Create-Table-as-Select-([CTAS](ctas.md))- und [INSERT-INTO-Anweisungen](insert-into.md) in Athena verwenden, um ETL-Daten für die Datenverarbeitung in Amazon S3 zu extrahieren, transformieren und laden. In diesem Thema wird erläutert, wie Sie diese Anweisungen zum Partitionieren und Konvertieren eines Datasets in das spaltenförmige Datenformat verwenden, um es für die Datenanalyse zu optimieren. CTAS-Anweisungen verwenden standardmäßige [SELECT](select.md)-Abfragen um neue Tabellen zu erstellen. Sie können eine CTAS-Anweisung verwenden, um eine Teilmenge Ihrer Daten für die Analyse zu erstellen. In einer CTAS-Anweisung können Sie die Daten partitionieren, komprimieren und die Daten in ein Spaltenformat wie Apache Parquet oder Apache ORC konvertieren. Wenn Sie die CTAS-Abfrage ausführen, werden die von ihr erstellten Tabellen und Partitionen automatisch dem [AWS Glue Data Catalog](https://aws.amazon.com/glue) hinzugefügt. Dadurch sind die neu erstellten Tabellen und Partitionen sofort für nachfolgende Abfragen verfügbar. INSERT INTO-Anweisungen fügen neue Zeilen basierend auf einer SELECT-Abfrageanweisung, die in einer Quelltabelle ausgeführt wird, in eine Zieltabelle ein. Sie können INSERT INTO-Anweisungen verwenden, um Quelltabellendaten im CSV-Format mit allen Transformationen, die von CTAS unterstützt werden, in Zieltabellendaten zu transformieren und zu laden. ## -Übersicht Verwenden Sie in Athena eine CTAS-Anweisung, um eine erste Batch-Konvertierung der Daten durchzuführen. Verwenden Sie dann mehrere INSERT INTO-Anweisungen, um inkrementelle Aktualisierungen der von der CTAS-Anweisung erstellten Tabelle vorzunehmen. **Schritte** + [Schritt 1: Erstellen einer Tabelle basierend auf dem ursprünglichen Datensatz](#ctas-insert-into-etl-step-1-create-a-table-based-on-the-original-dataset) + [Schritt 2: Verwenden von CTAS zum Partitionieren, Konvertieren und Komprimieren der Daten](#ctas-insert-into-etl-step-2-use-ctas-to-partition-convert-and-compress-the-data) + [Schritt 3: Verwenden von INSERT INTO zum Hinzufügen von Daten](#ctas-insert-into-etl-step-3-use-insert-into-to-add-data) + [Schritt 4: Messen von Leistungs- und Kostendifferenzen](#ctas-insert-into-etl-step-4-measure-performance-and-cost-differences) ## Schritt 1: Erstellen einer Tabelle basierend auf dem ursprünglichen Datensatz Das Beispiel in diesem Thema verwendet eine in Amazon S3 lesbare Teilmenge des öffentlich verfügbaren [NOAA Global Historical Climatology Network Daily (GHCN-d)](https://registry.opendata.aws/noaa-ghcn/)-Datensatzes. Die Daten für Amazon S3 haben die folgenden Eigenschaften. ``` Location: s3://aws-bigdata-blog/artifacts/athena-ctas-insert-into-blog/ Total objects: 41727 Size of CSV dataset: 11.3 GB Region: us-east-1 ``` Die Originaldaten werden ohne Partitionen in Amazon S3 gespeichert. Die Daten befinden sich im CSV-Format in Dateien wie den folgenden. ``` 2019-10-31 13:06:57 413.1 KiB artifacts/athena-ctas-insert-into-blog/2010.csv0000 2019-10-31 13:06:57 412.0 KiB artifacts/athena-ctas-insert-into-blog/2010.csv0001 2019-10-31 13:06:57 34.4 KiB artifacts/athena-ctas-insert-into-blog/2010.csv0002 2019-10-31 13:06:57 412.2 KiB artifacts/athena-ctas-insert-into-blog/2010.csv0100 2019-10-31 13:06:57 412.7 KiB artifacts/athena-ctas-insert-into-blog/2010.csv0101 ``` Die Dateigrößen in diesem Beispiel sind relativ klein. Durch die Zusammenführung in größere Dateien können Sie die Gesamtzahl der Dateien reduzieren und so eine bessere Abfrageausführung ermöglichen. Sie können CTAS- und INSERT INTO-Anweisungen verwenden, um die Abfrageleistung zu verbessern. **So erstellen Sie eine Datenbank und eine Tabelle basierend auf dem Beispiel-Dataset** 1. Wählen Sie in der Athena-Konsole die **USA Ost (Nord-Virginia)** AWS-Region. Stellen Sie sicher, dass Sie alle Abfragen in diesem Lernprogramm in `us-east-1` ausführen. 1. Führen Sie im Athena-Abfrage-Editor den Befehl [CREATE DATABASE](create-database.md) aus, um eine Datenbank zu erstellen. ``` CREATE DATABASE blogdb ``` 1. Führen Sie die folgende Anweisung aus, um [eine Tabelle zu erstellen](create-table.md). ``` CREATE EXTERNAL TABLE `blogdb`.`original_csv` ( `id` string, `date` string, `element` string, `datavalue` bigint, `mflag` string, `qflag` string, `sflag` string, `obstime` bigint) ROW FORMAT DELIMITED FIELDS TERMINATED BY ',' STORED AS INPUTFORMAT 'org.apache.hadoop.mapred.TextInputFormat' OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat' LOCATION 's3://aws-bigdata-blog/artifacts/athena-ctas-insert-into-blog/' ``` ## Schritt 2: Verwenden von CTAS zum Partitionieren, Konvertieren und Komprimieren der Daten Nachdem Sie eine Tabelle erstellt haben, können Sie die Daten mit einer einzelnen [CTAS](ctas.md)-Anweisung in das Parquet-Format mit Snappy-Komprimierung konvertieren und die Daten nach Jahr partitionieren. Die Tabelle, die Sie in Schritt 1 erstellt haben, enthält ein `date`-Feld, in dem das Datum als `YYYYMMDD` formatiert ist (z. B. `20100104`). Da die neue Tabelle nach `year` partitioniert wird, verwendet die Beispielanweisung im folgenden Verfahren die Presto-Funktion `substr("date",1,4)`, um den `year`-Wert aus dem Feld `date` zu extrahieren. **So konvertieren Sie die Daten in das Parquet-Format mit Snappy Komprimierung, partitioniert nach Jahr** + Führen Sie die folgende CTAS-Anweisung aus und *your-bucket* ersetzen Sie sie durch Ihren Amazon S3 S3-Bucket-Standort. ``` CREATE table new_parquet WITH (format='PARQUET', parquet_compression='SNAPPY', partitioned_by=array['year'], external_location = 's3://amzn-s3-demo-bucket/optimized-data/') AS SELECT id, date, element, datavalue, mflag, qflag, sflag, obstime, substr("date",1,4) AS year FROM original_csv WHERE cast(substr("date",1,4) AS bigint) >= 2015 AND cast(substr("date",1,4) AS bigint) <= 2019 ``` **Anmerkung** In diesem Beispiel enthält die Tabelle, die Sie erstellen, nur die Daten von 2015 bis 2019. In Schritt 3 fügen Sie dieser Tabelle neue Daten hinzu, indem Sie den Befehl INSERT INTO verwenden. Gehen Sie nach Abschluss der Abfrage folgendermaßen vor, um die Ausgabe an dem Amazon-S3-Speicherort zu überprüfen, den Sie in der CTAS-Anweisung angegeben haben. **So zeigen Sie die Partitionen und Parquet -Dateien an, die von der CTAS-Anweisung erstellt wurden** 1. Führen Sie den folgenden AWS CLI Befehl aus, um die erstellten Partitionen anzuzeigen. Achten Sie darauf, den letzten Schrägstrich (/) einzuschließen. ``` aws s3 ls s3://amzn-s3-demo-bucket/optimized-data/ ``` Die Ausgabe zeigt die Partitionen. ``` PRE year=2015/ PRE year=2016/ PRE year=2017/ PRE year=2018/ PRE year=2019/ ``` 1. Führen Sie den folgenden Befehl aus, um die Parquet-Dateien anzuzeigen. Beachten Sie, dass die Option `|` *head -5*, die die Ausgabe auf die ersten fünf Ergebnisse beschränkt, unter Windows nicht verfügbar ist. ``` aws s3 ls s3://amzn-s3-demo-bucket/optimized-data/ --recursive --human-readable | head -5 ``` Die Ausgabe sieht in etwa folgendermaßen aus. ``` 2019-10-31 14:51:05 7.3 MiB optimized-data/year=2015/20191031_215021_00001_3f42d_1be48df2-3154-438b-b61d-8fb23809679d 2019-10-31 14:51:05 7.0 MiB optimized-data/year=2015/20191031_215021_00001_3f42d_2a57f4e2-ffa0-4be3-9c3f-28b16d86ed5a 2019-10-31 14:51:05 9.9 MiB optimized-data/year=2015/20191031_215021_00001_3f42d_34381db1-00ca-4092-bd65-ab04e06dc799 2019-10-31 14:51:05 7.5 MiB optimized-data/year=2015/20191031_215021_00001_3f42d_354a2bc1-345f-4996-9073-096cb863308d 2019-10-31 14:51:05 6.9 MiB optimized-data/year=2015/20191031_215021_00001_3f42d_42da4cfd-6e21-40a1-8152-0b902da385a1 ``` ## Schritt 3: Verwenden von INSERT INTO zum Hinzufügen von Daten In Schritt 2 haben Sie CTAS verwendet, um eine Tabelle mit Partitionen für die Jahre 2015 bis 2019 zu erstellen. Der ursprüngliche Datensatz enthält jedoch auch Daten für die Jahre 2010 bis 2014. Nun fügen Sie diese Daten mit einer [INSERT INTO](insert-into.md)-Anweisung hinzu. **So fügen Sie der Tabelle Daten mit einer oder mehreren INSERT INTO-Anweisungen hinzu** 1. Führen Sie den folgenden INSERT INTO-Befehl aus und geben Sie die Jahre vor 2015 in der WHERE-Klausel an. ``` INSERT INTO new_parquet SELECT id, date, element, datavalue, mflag, qflag, sflag, obstime, substr("date",1,4) AS year FROM original_csv WHERE cast(substr("date",1,4) AS bigint) < 2015 ``` 1. Führen Sie den `aws s3 ls`-Befehl mit der folgenden Syntax erneut aus. ``` aws s3 ls s3://amzn-s3-demo-bucket/optimized-data/ ``` Die Ausgabe zeigt die neuen Partitionen. ``` PRE year=2010/ PRE year=2011/ PRE year=2012/ PRE year=2013/ PRE year=2014/ PRE year=2015/ PRE year=2016/ PRE year=2017/ PRE year=2018/ PRE year=2019/ ``` 1. Führen Sie den folgenden Befehl aus, um die Verringerung der Größe des Datasets anzuzeigen, die durch Komprimierung und Säulenspeicherung im Parquet-Format erzielt wurde. ``` aws s3 ls s3://amzn-s3-demo-bucket/optimized-data/ --recursive --human-readable --summarize ``` Die folgenden Ergebnisse zeigen, dass die Größe des Datensatzes nach Parquet mit Snappy-Komprimierung 1,2 GB beträgt. ``` ... 2020-01-22 18:12:02 2.8 MiB optimized-data/year=2019/20200122_181132_00003_nja5r_f0182e6c-38f4-4245-afa2-9f5bfa8d6d8f 2020-01-22 18:11:59 3.7 MiB optimized-data/year=2019/20200122_181132_00003_nja5r_fd9906b7-06cf-4055-a05b-f050e139946e Total Objects: 300 Total Size: 1.2 GiB ``` 1. Wenn der ursprünglichen Tabelle mehr CSV-Daten hinzugefügt werden, können Sie diese Daten mit INSERT INTO-Anweisungen zur Parquet-Tabelle hinzufügen. Wenn Sie beispielsweise neue Daten für das Jahr 2020 haben, können Sie die folgende INSERT INTO-Anweisung ausführen. Die Anweisung fügt die Daten und die entsprechende Partition zur Tabelle `new_parquet` hinzu. ``` INSERT INTO new_parquet SELECT id, date, element, datavalue, mflag, qflag, sflag, obstime, substr("date",1,4) AS year FROM original_csv WHERE cast(substr("date",1,4) AS bigint) = 2020 ``` **Anmerkung** Die Anweisung INSERT INTO unterstützt das Schreiben von maximal 100 Partitionen in die Zieltabelle. Um jedoch mehr als 100 Partitionen hinzuzufügen, können Sie mehrere INSERT INTO-Anweisungen ausführen. Weitere Informationen finden Sie unter [Verwenden von CTAS und INSERT INTO zum Umgehen des Limits von 100 Partitionen](ctas-insert-into.md). ## Schritt 4: Messen von Leistungs- und Kostendifferenzen Nachdem Sie die Daten transformiert haben, können Sie die Leistungssteigerungen und Kosteneinsparungen messen, indem Sie dieselben Abfragen in den neuen und alten Tabellen ausführen und die Ergebnisse vergleichen. **Anmerkung** Informationen zu Athena-Kosten pro Abfrage finden Sie unter [Preise für Amazon Athena](https://aws.amazon.com/athena/pricing). **So messen Sie Leistungssteigerungen und Kostenunterschiede** 1. Führen Sie die folgende Abfrage für die ursprüngliche Tabelle aus. Die Abfrage ermittelt die Anzahl der eindeutigen Werte IDs für jeden Wert des Jahres. ``` SELECT substr("date",1,4) as year, COUNT(DISTINCT id) FROM original_csv GROUP BY 1 ORDER BY 1 DESC ``` 1. Beachten Sie, wie lange Abfrage ausgeführt wurde und die Menge der gescannten Daten. 1. Führen Sie dieselbe Abfrage für die neue Tabelle aus und achten Sie dabei auf die Abfrageausführungszeit und die Menge der gescannten Daten. ``` SELECT year, COUNT(DISTINCT id) FROM new_parquet GROUP BY 1 ORDER BY 1 DESC ``` 1. Vergleichen Sie die Ergebnisse und berechnen Sie die Leistungs- und Kostendifferenz. Die folgenden Beispielergebnisse zeigen, dass die Testabfrage für die neue Tabelle schneller und billiger war als die Abfrage für die alte Tabelle. **** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/athena/latest/ug/ctas-insert-into-etl.html) 1. Führen Sie die folgende Beispielabfrage für die ursprüngliche Tabelle aus. Die Abfrage berechnet die durchschnittliche Höchsttemperatur (Celsius), durchschnittliche Mindesttemperatur (Celsius) und durchschnittliche Niederschlagsmenge (mm) für die Erde im Jahr 2018. ``` SELECT element, round(avg(CAST(datavalue AS real)/10),2) AS value FROM original_csv WHERE element IN ('TMIN', 'TMAX', 'PRCP') AND substr("date",1,4) = '2018' GROUP BY 1 ``` 1. Beachten Sie, wie lange Abfrage ausgeführt wurde und die Menge der gescannten Daten. 1. Führen Sie dieselbe Abfrage für die neue Tabelle aus und achten Sie dabei auf die Abfrageausführungszeit und die Menge der gescannten Daten. ``` SELECT element, round(avg(CAST(datavalue AS real)/10),2) AS value FROM new_parquet WHERE element IN ('TMIN', 'TMAX', 'PRCP') and year = '2018' GROUP BY 1 ``` 1. Vergleichen Sie die Ergebnisse und berechnen Sie die Leistungs- und Kostendifferenz. Die folgenden Beispielergebnisse zeigen, dass die Testabfrage für die neue Tabelle schneller und billiger war als die Abfrage für die alte Tabelle. **** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/athena/latest/ug/ctas-insert-into-etl.html) ## Zusammenfassung In diesem Thema wurde gezeigt, wie ETL-Operationen mit CTAS- und INSERT INTO-Anweisungen in Athena ausgeführt werden. Sie haben den ersten Satz von Transformationen mit einer CTAS-Anweisung durchgeführt, die Daten in das Parquet-Format mit Snappy-Komprimierung konvertiert hat. Die CTAS-Anweisung konvertiert auch das Dataset von nicht partitionierten in partitionierte Daten. Dies reduzierte seine Größe und senkte die Kosten für die Ausführung der Abfragen. Wenn neue Daten verfügbar sind, können Sie sie mit einer INSERT INTO-Anweisung in die Tabelle transformieren und laden, die Sie mit der CTAS-Anweisung erstellt haben. # Verwenden von CTAS und INSERT INTO zum Umgehen des Limits von 100 Partitionen Athena hat ein Limit von 100 Partitionen pro `CREATE TABLE AS SELECT` ([CTAS](ctas.md))-Abfrage. Ebenso können Sie einer Zieltabelle mit einer [INSERT INTO](https://docs.aws.amazon.com/athena/latest/ug/insert-into.html)-Anweisung maximal 100 Partitionen hinzufügen. Wenn Sie diese Einschränkung überschreiten, wird möglicherweise die Fehlermeldung HIVE\$1TOO\$1MANY\$1OPEN\$1PARTITIONS: Exceeded limit of 100 open writers for partitions/buckets angezeigt. Um diese Einschränkung zu umgehen, können Sie eine CTAS-Anweisung und eine Reihe von `INSERT INTO`-Anweisungen verwenden, die jeweils bis zu 100 Partitionen erstellen oder einfügen. Das Beispiel in diesem Thema verwendet eine Datenbank mit dem Namen `tpch100`, deren Daten sich im Amazon-S3-Bucket-Speicherort „s3://amzn-s3-demo-bucket/“ befinden. **So erstellen Sie mithilfe von CTAS und INSERT INTO eine Tabelle mit mehr als 100 Partitionen** 1. Erstellen Sie mit einer `CREATE EXTERNAL TABLE`-Anweisung eine Tabelle, die für das gewünschte Feld partitioniert ist. Die folgende Beispielanweisung partitioniert die Daten durch die Spalte `l_shipdate`. Der Tisch hat 2525 Partitionen. ``` CREATE EXTERNAL TABLE `tpch100.lineitem_parq_partitioned`( `l_orderkey` int, `l_partkey` int, `l_suppkey` int, `l_linenumber` int, `l_quantity` double, `l_extendedprice` double, `l_discount` double, `l_tax` double, `l_returnflag` string, `l_linestatus` string, `l_commitdate` string, `l_receiptdate` string, `l_shipinstruct` string, `l_comment` string) PARTITIONED BY ( `l_shipdate` string) ROW FORMAT SERDE 'org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe' STORED AS INPUTFORMAT 'org.apache.hadoop.hive.ql.io.parquet.MapredParquetInputFormat' OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.parquet.MapredParquetOutputFormat' LOCATION 's3://amzn-s3-demo-bucket/lineitem/' ``` 1. Führen Sie einen `SHOW PARTITIONS `-Befehl wie den folgenden aus, um die Partitionen aufzulisten. ``` SHOW PARTITIONS lineitem_parq_partitioned ``` Es folgen teilweise Beispielergebnisse. ``` /* l_shipdate=1992-01-02 l_shipdate=1992-01-03 l_shipdate=1992-01-04 l_shipdate=1992-01-05 l_shipdate=1992-01-06 ... l_shipdate=1998-11-24 l_shipdate=1998-11-25 l_shipdate=1998-11-26 l_shipdate=1998-11-27 l_shipdate=1998-11-28 l_shipdate=1998-11-29 l_shipdate=1998-11-30 l_shipdate=1998-12-01 */ ``` 1. Führen Sie eine CTAS-Abfrage aus, um eine partitionierte Tabelle zu erstellen. Im folgenden Beispiel wird eine Tabelle mit dem Namen erstellt `my_lineitem_parq_partitioned` und die `WHERE `-Klausel verwendet, um `DATE` auf früher als `1992-02-01` zu beschränken. Da das Beispiel-Dataset mit Januar 1992 beginnt, werden nur Partitionen für Januar 1992 erstellt. ``` CREATE table my_lineitem_parq_partitioned WITH (partitioned_by = ARRAY['l_shipdate']) AS SELECT l_orderkey, l_partkey, l_suppkey, l_linenumber, l_quantity, l_extendedprice, l_discount, l_tax, l_returnflag, l_linestatus, l_commitdate, l_receiptdate, l_shipinstruct, l_comment, l_shipdate FROM tpch100.lineitem_parq_partitioned WHERE cast(l_shipdate as timestamp) < DATE ('1992-02-01'); ``` 1. Führen Sie den Befehl `SHOW PARTITIONS` aus, um zu überprüfen, ob die Tabelle die gewünschten Partitionen enthält. ``` SHOW PARTITIONS my_lineitem_parq_partitioned; ``` Die Partitionen im Beispiel stammen vom Januar 1992. ``` /* l_shipdate=1992-01-02 l_shipdate=1992-01-03 l_shipdate=1992-01-04 l_shipdate=1992-01-05 l_shipdate=1992-01-06 l_shipdate=1992-01-07 l_shipdate=1992-01-08 l_shipdate=1992-01-09 l_shipdate=1992-01-10 l_shipdate=1992-01-11 l_shipdate=1992-01-12 l_shipdate=1992-01-13 l_shipdate=1992-01-14 l_shipdate=1992-01-15 l_shipdate=1992-01-16 l_shipdate=1992-01-17 l_shipdate=1992-01-18 l_shipdate=1992-01-19 l_shipdate=1992-01-20 l_shipdate=1992-01-21 l_shipdate=1992-01-22 l_shipdate=1992-01-23 l_shipdate=1992-01-24 l_shipdate=1992-01-25 l_shipdate=1992-01-26 l_shipdate=1992-01-27 l_shipdate=1992-01-28 l_shipdate=1992-01-29 l_shipdate=1992-01-30 l_shipdate=1992-01-31 */ ``` 1. Verwenden Sie eine `INSERT INTO`-Anweisung, um Partitionen zur Tabelle hinzuzufügen. Im folgenden Beispiel werden Partitionen für die Datumsangaben des Monats Februar 1992 hinzugefügt. ``` INSERT INTO my_lineitem_parq_partitioned SELECT l_orderkey, l_partkey, l_suppkey, l_linenumber, l_quantity, l_extendedprice, l_discount, l_tax, l_returnflag, l_linestatus, l_commitdate, l_receiptdate, l_shipinstruct, l_comment, l_shipdate FROM tpch100.lineitem_parq_partitioned WHERE cast(l_shipdate as timestamp) >= DATE ('1992-02-01') AND cast(l_shipdate as timestamp) < DATE ('1992-03-01'); ``` 1. Führen Sie `SHOW PARTITIONS` erneut aus. ``` SHOW PARTITIONS my_lineitem_parq_partitioned; ``` Die Beispieltabelle enthält nun Partitionen vom Januar und Februar 1992. ``` /* l_shipdate=1992-01-02 l_shipdate=1992-01-03 l_shipdate=1992-01-04 l_shipdate=1992-01-05 l_shipdate=1992-01-06 ... l_shipdate=1992-02-20 l_shipdate=1992-02-21 l_shipdate=1992-02-22 l_shipdate=1992-02-23 l_shipdate=1992-02-24 l_shipdate=1992-02-25 l_shipdate=1992-02-26 l_shipdate=1992-02-27 l_shipdate=1992-02-28 l_shipdate=1992-02-29 */ ``` 1. Verwenden Sie weiterhin `INSERT INTO`-Anweisungen, die nicht mehr als 100 Partitionen lesen und hinzufügen. Fahren Sie fort, bis Sie die Anzahl der benötigten Partitionen erreicht haben. **Wichtig** Achten Sie beim Festlegen der `WHERE`-Bedingung darauf, dass sich die Abfragen nicht überschneiden. Andernfalls haben einige Partitionen möglicherweise doppelte Daten.