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.
# SQL-Referenz für Athena
Amazon Athena unterstützt eine Teilmenge von Data-Definition-Language-(DDL)- und Data-Manipulation-Language-(DML)-Anweisungen, -Funktionen, -Operatoren und -Datentypen. Mit einigen Ausnahmen basiert Athena DDL auf [HiveQL DDL](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+DDL) und Athena DML auf [Trino](https://trino.io/docs/current/language.html). Weitere Informationen über Athena-Engine-Versionen finden Sie unter [Athena-Engine-Versionierung](engine-versions.md).
**Topics**
+ [Datentypen in Athena](data-types.md)
+ [DML-Abfragen, -Funktionen und -Operatoren](dml-queries-functions-operators.md)
+ [DDL-Anweisungen](ddl-reference.md)
+ [Überlegungen und Einschränkungen](other-notable-limitations.md)
# Datentypen in Amazon Athena
Wenn Sie `CREATE TABLE` ausführen, geben Sie Spaltennamen und den Datentyp an, den jede Spalte enthalten kann. Die Tabellen, die Sie erstellen, werden in AWS Glue Data Catalog gespeichert.
Um die Interoperabilität mit anderen Abfrage-Engines zu erleichtern, verwendet Athena [Apache Hive](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+Types)-Datentypnamen für DDL-Anweisungen wie `CREATE TABLE`. Für DML-Abfragen wie `SELECT`, `CTAS` und `INSERT INTO` verwendet Athena [Trino](https://trino.io/docs/current/language/types.html)-Datentypnamen. Die folgende Tabelle zeigt die Datentypen, die in Athena unterstützt werden. Wenn sich DDL- und DML-Typen in Bezug auf Namen, Verfügbarkeit oder Syntax unterscheiden, werden sie in separaten Spalten angezeigt.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/athena/latest/ug/data-types.html)
**Topics**
+ [Beispiele für Daten-Typen](data-types-examples.md)
+ [Überlegungen zu Datentypen](data-types-considerations.md)
+ [Mit Zeitstempeldaten arbeiten](data-types-timestamps.md)
# Beispiele für Daten-Typen
Die folgende Tabelle zeigt Beispiel-Literale für DML-Datentypen.
****
| Datentyp | Beispiele |
| --- | --- |
| BOOLEAN | `true` `false ` |
| TINYINT | `TINYINT '123'` |
| SMALLINT | `SMALLINT '123'` |
| INT, INTEGER | `123456790` |
| BIGINT | `BIGINT '1234567890'` `2147483648` |
| REAL | `'123456.78'` |
| DOUBLE | `1.234` |
| DEZIMAL (precision,scale) | `DECIMAL '123.456'` |
| CHAR, CHAR (length) | `CHAR 'hello world'`, `CHAR 'hello ''world''!'` |
| VARCHAR, VARCHAR () length | `VARCHAR 'hello world'`, `VARCHAR 'hello ''world''!'` |
| VARBINARY | `X'00 01 02'` |
| ZEIT, ZEIT () precision | `TIME '10:11:12'`, `TIME '10:11:12.345'` |
| TIME WITH TIME ZONE | `TIME '10:11:12.345 -06:00'` |
| DATE | `DATE '2024-03-25'` |
| TIMESTAMP, TIMESTAMP OHNE ZEITZONE, TIMESTAMP (*precision*), TIMESTAMP () OHNE ZEITZONE *precision* | `TIMESTAMP '2024-03-25 11:12:13'`, `TIMESTAMP '2024-03-25 11:12:13.456'` |
| TIMESTAMP MIT ZEITZONE, TIMESTAMP () MIT ZEITZONE precision | `TIMESTAMP '2024-03-25 11:12:13.456 Europe/Berlin'` |
| INTERVAL YEAR TO MONTH | `INTERVAL '3' MONTH` |
| INTERVAL DAY TO SECOND | `INTERVAL '2' DAY` |
| ARRAY [] element\$1type | `ARRAY['one', 'two', 'three']` |
| KARTE (key\$1type,value\$1type) | `MAP(ARRAY['one', 'two', 'three'], ARRAY[1, 2, 3])` Beachten Sie, dass Karten aus einem Array von Schlüsseln und einem Array von Werten erstellt werden. Im folgenden Beispiel wird eine Tabelle erstellt, die Zeichenfolgen Ganzzahlen zuordnet. CREATE TABLE map_table(col1 map) LOCATION '...';
INSERT INTO map_table values(MAP(ARRAY['foo', 'bar'], ARRAY[1, 2]));
|
| ZEILE (field\$1name\$11field\$1type\$11, field\$1name\$12field\$1type\$12,...) | `ROW('one', 'two', 'three')` Beachten Sie, dass auf diese Weise erstellte Zeilen keine Spaltennamen haben. Um Spaltennamen hinzuzufügen, können Sie `CAST` verwenden, wie im folgenden Beispiel: CAST(ROW(1, 2, 3) AS ROW(one INT, two INT, three INT))
|
| JSON | `JSON '{"one":1, "two": 2, "three": 3}'` |
| UUID | `UUID '12345678-90ab-cdef-1234-567890abcdef'` |
| IPADDRESS | `IPADDRESS '10.0.0.1'` `IPADDRESS '2001:db8::1'` |
# Überlegungen zu Datentypen
## Größenbeschränkungen
Beachten Sie bei Datentypen, für die keine Größenbeschränkung angegeben ist, dass es für alle Daten in einer einzelnen Zeile eine praktische Grenze von 32 MB gibt. Weitere Informationen finden Sie unter [Row or column size limitation](other-notable-limitations.md#sql-limitations-rowsize) in [Überlegungen und Einschränkungen für SQL-Abfragen in Amazon Athena](other-notable-limitations.md).
## CHAR und VARCHAR
Ein `CHAR(n)`- Wert hat immer eine Anzahl von `n`-Zeichen. Wenn Sie beispielsweise 'abc' in `CHAR(7)` umwandeln, werden 4 abschließende Leerzeichen hinzugefügt.
Vergleiche von `CHAR`-Werten beinhalten führende und nachfolgende Leerzeichen.
Wenn für `CHAR` oder `VARCHAR` eine Länge angegeben wird, werden Zeichenfolgen beim Lesen auf die angegebene Länge gekürzt. Wenn die zugrunde liegende Datenzeichenfolge länger ist, bleibt die zugrunde liegende Datenzeichenfolge unverändert.
Um ein einfaches Anführungszeichen in einem `CHAR` oder `VARCHAR` zu umgehen, verwenden Sie ein zusätzliches einfaches Anführungszeichen.
Um einen Datentyp, der keine Zeichenfolge ist, in einer DML-Abfrage in eine Zeichenfolge umzuwandeln, müssen Sie in den `VARCHAR`-Datentyp umwandeln.
Wenn Sie die `substr`-Funktion verwenden möchten, um eine Teilzeichenfolge der angegebenen Länge aus einem `CHAR`-Datentyp zurückzugeben, müssen Sie den `CHAR`-Wert zuerst in einen `VARCHAR` umwandeln. Im folgenden Beispiel verwendet `col1` den `CHAR`-Datentyp.
```
substr(CAST(col1 AS VARCHAR), 1, 4)
```
## DECIMAL
Um Dezimalwerte als Literale in `SELECT`-Anfragen anzugeben, z. B. bei der Auswahl von Zeilen mit einem bestimmten Dezimalwert, können Sie den `DECIMAL`-Typ angeben und den Dezimalwert als Literal in einfachen Anführungszeichen in Ihrer Abfrage auflisten, wie in den folgenden Beispielen gezeigt.
```
SELECT * FROM my_table
WHERE decimal_value = DECIMAL '0.12'
```
```
SELECT DECIMAL '44.6' + DECIMAL '77.2'
```
# Mit Zeitstempeldaten arbeiten
In diesem Abschnitt werden einige Überlegungen zur Arbeit mit Zeitstempeldaten in Athena beschrieben.
**Anmerkung**
Die Behandlung von Zeitstempeln hat sich zwischen der früheren Engine-Version und der Athena-Engine-Version 3 etwas geändert. Informationen zu Fehlern im Zusammenhang mit Zeitstempeln, die in Athena-Engine-Version 3 auftreten können, sowie Lösungsvorschläge finden Sie unter [Änderungen des Zeitstempels](engine-versions-reference-0003.md#engine-versions-reference-0003-timestamp-changes) in der [Athena-Engine-Version 3](engine-versions-reference-0003.md)-Referenz.
## Format für das Schreiben von Zeitstempeldaten in Amazon-S3-Objekte
Das Format, in dem Zeitstempeldaten in Amazon S3 S3-Objekte geschrieben werden sollen, hängt sowohl vom Spaltendatentyp als auch von der verwendeten [SerDeBibliothek](https://docs.aws.amazon.com/athena/latest/ug/supported-serdes.html) ab.
+ Wenn Sie eine Tabellenspalte vom Typ `DATE` haben, erwartet Athena, dass es sich bei der entsprechenden Spalte oder Eigenschaft der Daten um eine Zeichenfolge im ISO-Format `YYYY-MM-DD` oder um einen integrierten Datumstyp wie bei Parquet oder ORC handelt.
+ Wenn Sie eine Tabellenspalte vom Typ `TIME` haben, erwartet Athena, dass es sich bei der entsprechenden Spalte oder Eigenschaft der Daten um eine Zeichenfolge im ISO-Format `HH:MM:SS` oder um einen integrierten Zeittyp wie bei Parquet oder ORC handelt.
+ Wenn Sie eine Tabellenspalte des Typs `TIMESTAMP` haben, erwartet Athena, dass die entsprechende Spalte oder Eigenschaft der Daten eine Zeichenkette im Format `YYYY-MM-DD HH:MM:SS.SSS` ist (beachten Sie das Leerzeichen zwischen Datum und Uhrzeit), oder ein eingebauter Zeittyp wie die für Parquet, ORC oder Ion. Beachten Sie, dass Athena das Verhalten für ungültige Zeitstempel (z. B. `0000-00-00 08:00:00.000`) nicht garantiert.
**Anmerkung**
CSVSerOpen-De-Zeitstempel sind eine Ausnahme und müssen als UNIX-Epochen mit Millisekundenauflösung codiert werden.
## Sicherstellen, dass zeitlich aufgeteilte Daten mit dem Zeitstempelfeld in einem Datensatz übereinstimmen
Der Hersteller der Daten muss sicherstellen, dass die Partitionswerte mit den Daten innerhalb der Partition übereinstimmen. Wenn Ihre Daten beispielsweise eine `timestamp` Eigenschaft haben und Sie Firehose verwenden, um die Daten in Amazon S3 zu laden, müssen Sie [dynamische Partitionierung](https://docs.aws.amazon.com/firehose/latest/dev/dynamic-partitioning.html) verwenden, da die Standardpartitionierung von Firehose wall-clock-based
## String als Datentyp für Partitionsschlüssel verwenden
Aus Leistungsgründen ist es vorzuziehen, `STRING` als Datentyp für Partitionsschlüssel zu verwenden. Obwohl Athena Partitionswerte im Format `YYYY-MM-DD` als Datum erkennt, wenn Sie den `DATE`-Typ verwenden, kann dies zu einer schlechten Leistung führen. Aus diesem Grund empfehlen wir, stattdessen den `STRING`-Datentyp für Partitionsschlüssel zu verwenden.
## Wie Sie Abfragen für Zeitstempelfelder schreiben, die ebenfalls zeitpartitioniert sind
Wie Sie Abfragen für Zeitstempelfelder schreiben, die zeitpartitioniert sind, hängt vom Tabellentyp ab, den Sie abfragen möchten.
### Hive-Tabellen
Bei den Hive-Tabellen, die in Athena am häufigsten verwendet werden, hat die Abfrage-Engine keine Kenntnis von den Beziehungen zwischen Spalten und Partitionsschlüsseln. Aus diesem Grund müssen Sie Ihren Abfragen immer Prädikate sowohl für die Spalte als auch für den Partitionsschlüssel hinzufügen.
Nehmen wir beispielsweise an, Sie haben eine `event_time`-Spalte und einen `event_date`-Partitionsschlüssel und möchten Ereignisse zwischen 23:00 und 03:00 Uhr abfragen. In diesem Fall müssen Sie Prädikate in Ihre Abfrage sowohl für die Spalte als auch für den Partitionsschlüssel aufnehmen, wie im folgenden Beispiel.
```
WHERE event_time BETWEEN start_time AND end_time
AND event_date BETWEEN start_time_date AND end_time_date
```
### Iceberg-Tabellen
Bei Iceberg-Tabellen können Sie berechnete Partitionswerte verwenden, was Ihre Abfragen vereinfacht. Nehmen wir beispielsweise an, Ihre Iceberg-Tabelle wurde mit einer `PARTITIONED BY`-Klausel wie der folgenden erstellt:
```
PARTITIONED BY (event_date month(event_time))
```
In diesem Fall löscht die Abfrage-Engine automatisch Partitionen auf der Grundlage der Werte der `event_time`-Prädikate. Aus diesem Grund muss Ihre Abfrage nur ein Prädikat für `event_time` angeben, wie im folgenden Beispiel.
```
WHERE event_time BETWEEN start_time AND end_time
```
Weitere Informationen finden Sie unter [Iceberg-Tabellen erstellen](querying-iceberg-creating-tables.md).
Wenn Sie die versteckte Partitionierung von Iceberg für eine Zeitstempelspalte verwenden, erstellt Iceberg möglicherweise eine Partition auf einer konstruierten Tabellenspalte, die von einer Zeitstempelspalte abgeleitet und für eine effektivere Partitionierung in ein Datum umgewandelt wurde. Beispielsweise könnte es `event_date` aus der Zeitstempel-Spalte `event_time` erstellen und automatisch nach `event_date` partitionieren. In diesem Fall ist der **Partitions**-Typ ein **Datum**.
Um eine optimale Abfrageleistung bei der Verwendung der Partition zu erzielen, filtern Sie nach ganzen Tagesbereichen, um den Prädikat-Pushdown zu aktivieren. Beispielsweise würde die folgende Abfrage nicht nach unten verschoben werden, da der Bereich nicht in eine einzelne Datumspartition konvertiert werden kann, obwohl er innerhalb eines einzigen Tages liegt:
```
WHERE event_time >= TIMESTAMP '2024-04-18 00:00:00' AND event_time < TIMESTAMP '2024-04-18 12:00:00'
```
Verwenden Sie stattdessen einen vollen Tagesbereich, um die Prädikat-Pushdown zu ermöglichen und die Abfrageleistung zu verbessern, wie im folgenden Beispiel gezeigt.
```
WHERE event_time >= TIMESTAMP '2024-04-18 00:00:00' AND event_time < TIMESTAMP '2024-04-19 00:00:00'
```
Sie können auch die `BETWEEN start_time AND end_time`-Syntax verwenden oder mehrtägige Bereiche verwenden, solange die Zeitstempelabschnitte `00:00:00` sind.
Weitere Informationen finden Sie im [Trino Blogbeitrag](https://trino.io/blog/2023/04/11/date-predicates.html).
# DML-Abfragen, -Funktionen und -Operatoren
Die Athena-DML-Abfrage-Engine unterstützt im Allgemeinen die Trino- und Presto-Syntax und fügt eigene Verbesserungen hinzu. Nicht alle Trino- oder Presto-Features werden von Athena unterstützt. Weitere Informationen finden Sie in den Themen für spezifische Anweisungen in diesem Abschnitt und [Überlegungen und Einschränkungen](other-notable-limitations.md). Informationen zu Funktionen finden Sie unter [Funktionen in Amazon Athena](functions.md). Weitere Informationen über Athena-Engine-Versionen finden Sie unter [Athena-Engine-Versionierung](engine-versions.md).
Informationen zu DDL-Anweisungen finden Sie unter [DDL-Anweisungen](ddl-reference.md). Eine Liste der nicht unterstützten DDL-Anweisungen finden Sie unter [Nicht unterstützte DDLs](unsupported-ddl.md).
**Topics**
+ [SELECT](select.md)
+ [INSERT INTO](insert-into.md)
+ [VALUES](values-statement.md)
+ [DELETE](delete-statement.md)
+ [UPDATE](update-statement.md)
+ [MERGE INTO](merge-into-statement.md)
+ [OPTIMIZE](optimize-statement.md)
+ [VACUUM](vacuum-statement.md)
+ [EXPLAIN und EXPLAIN ANALYZE](athena-explain-statement.md)
+ [PREPARE](sql-prepare.md)
+ [UNLOAD](unload.md)
+ [Funktionen](functions.md)
+ [Unterstützte Zeitzonen verwenden](athena-supported-time-zones.md)
# SELECT
Ruft Datenzeilen aus null oder mehr Tabellen ab.
**Anmerkung**
Dieses Thema enthält zusammenfassende Informationen zur Referenz. Umfassende Informationen über die Verwendung von `SELECT` und der SQL-Sprache gehen über den Rahmen dieser Dokumentation hinaus. Weitere Informationen zur Verwendung von SQL speziell für Athena finden Sie unter [Überlegungen und Einschränkungen für SQL-Abfragen in Amazon Athena](other-notable-limitations.md) und [Ausführen von SQL-Abfragen in Amazon Athena](querying-athena-tables.md). Für ein Beispiel für das Erstellen einer Datenbank, das Erstellen einer Tabelle und das Ausführen einer `SELECT`-Abfrage auf dem Tisch in Athena siehe [Erste Schritte](getting-started.md).
## Syntax
```
[ WITH with_query [, ...] ]
SELECT [ ALL | DISTINCT ] select_expression [, ...]
[ FROM from_item [, ...] ]
[ WHERE condition ]
[ GROUP BY [ ALL | DISTINCT ] grouping_element [, ...] ]
[ HAVING condition ]
[ { UNION | INTERSECT | EXCEPT } [ ALL | DISTINCT ] select ]
[ ORDER BY expression [ ASC | DESC ] [ NULLS FIRST | NULLS LAST] [, ...] ]
[ OFFSET count [ ROW | ROWS ] ]
[ LIMIT [ count | ALL ] ]
```
**Anmerkung**
Reservierte Wörter in SQL SELECT-Anweisungen müssen in doppelte Anführungszeichen eingeschlossen werden. Weitere Informationen finden Sie unter [Reservierte Schlüsselwörter, die in SQL-SELECT-Anweisungen umgegangen werden müssen](reserved-words.md#list-of-reserved-words-sql-select).
## Parameters
**[ WITH with\$1query [, ....] ]**
Mit `WITH` können Sie verschachtelte Abfragen reduzieren oder Unterabfragen vereinfachen.
Die Verwendung der `WITH`-Klausel zur Erstellung rekursiver Abfragen wird ab der Athena-Engine-Version 3 unterstützt. Die maximale Rekursionstiefe beträgt 10.
Die Klausel `WITH` geht der `SELECT`-Liste in einer Abfrage voraus und legt eine oder mehrere Unterabfragen für die Verwendung in der `SELECT`-Abfrage fest.
Jede Unterabfrage definiert eine temporäre Tabelle ähnlich wie eine Ansichtdefinition, die mit der `FROM`-Klausel referenziert werden kann. Die Tabellen werden nur verwendet, wenn die Abfrage ausgeführt wird.
Die Syntax von `with_query` lautet:
```
subquery_table_name [ ( column_name [, ...] ) ] AS (subquery)
```
Wobei Folgendes gilt:
+ `subquery_table_name` ist ein eindeutiger Name für eine temporäre Tabelle, die die Ergebnisse der Unterabfrage mit `WITH`-Klausel definiert. Jede `subquery` muss einen Tabellennamen erhalten, der in der `FROM`-Klausel referenziert werden kann.
+ `column_name [, ...]` ist eine optionale Liste der ausgegebenen Spaltennamen. Die Anzahl der Spaltennamen muss größer als oder gleich der Anzahl der Spalten sein, die von der `subquery` definiert wird.
+ `subquery` ist eine Abfrageanweisung.
**[ ALL \$1 DISTINCT ] select\$1expression**
`select_expression` legt die auszuwählenden Zeilen fest. Ein `select_expression` kann eines der folgenden Formate verwenden:
```
expression [ [ AS ] column_alias ] [, ...]
```
```
row_expression.* [ AS ( column_alias [, ...] ) ]
```
```
relation.*
```
```
*
```
+ Die `expression [ [ AS ] column_alias ]` Syntax gibt eine Ausgabespalte an. Die optionale `[AS] column_alias`-Syntax gibt einen benutzerdefinierten Überschriftennamen an, der für die Spalte in der Ausgabe verwendet werden soll.
+ Für `row_expression.* [ AS ( column_alias [, ...] ) ]`, `row_expression` ist ein beliebiger Ausdruck eines Datentyps `ROW`. Die Felder der Zeile definieren die Ausgabespalten, die im Ergebnis enthalten sein sollen.
+ Für `relation.*`, die Spalten von `relation` sind im Ergebnis enthalten. Diese Syntax erlaubt nicht die Verwendung von Spaltenaliasnamen.
+ Das Sternchen `*` gibt an, dass alle Spalten in die Ergebnismenge aufgenommen werden.
+ In der Ergebnismenge entspricht die Reihenfolge der Spalten der Reihenfolge ihrer Angabe durch den Auswahlausdruck. Gibt ein Auswahlausdruck mehrere Spalten gibt, folgt die Spaltenreihenfolge der Reihenfolge, die in der Quellrelation oder im Zeilentypausdruck verwendet wurde.
+ Sind Spaltenaliase angegeben, überschreiben die Aliase bereits vorhandene Spalten- oder Zeilenfeldnamen. Enthält der Auswahlausdruck keine Spaltennamen, werden anonyme Spaltennamen (`_col0`, `_col1`, `_col2, ...`) mit einem Nullindex in der Ausgabe angezeigt.
+ `ALL` ist die Standardeinstellung. Bei Verwendung von `ALL` wird dies so behandelt, als wäre kein Wert angegeben worden. Alle Zeilen aller Spalten werden einschließlich Duplikaten ausgewählt.
+ Verwenden Sie `DISTINCT`, um nur eindeutige Werte zurückzugeben, wenn eine Spalte Duplikatwerte enthält.
**FROM from\$1item [,...]**
Gibt die Eingabe der Abfrage an, wobei `from_item` eine Ansicht, ein JOIN-Konstrukt oder eine Unterabfrage wie unten beschrieben sein kann.
`from_item` kann eines der Folgenden sein:
+ `table_name [ [ AS ] alias [ (column_alias [, ...]) ] ]`
Hier ist `table_name` der Name der Zieltabelle, aus der Zeilen ausgewählt werden. `alias` ist der Name für die Ausgabe der `SELECT`-Anweisung und `column_alias` definiert die Spalten für den angegebenen `alias`.
**-ODER-**
+ `join_type from_item [ ON join_condition | USING ( join_column [, ...] ) ]`
Hierbei ist `join_type` eines der Folgenden:
+ `[ INNER ] JOIN`
+ `LEFT [ OUTER ] JOIN`
+ `RIGHT [ OUTER ] JOIN`
+ `FULL [ OUTER ] JOIN`
+ `CROSS JOIN`
+ `ON join_condition | USING (join_column [, ...])` Wobei Sie durch Verwenden von `join_condition` die Spaltennamen für JOIN-Schlüssel in mehreren Tabellen angeben können. Für die Verwendung von `join_column` muss `join_column` in beiden Tabellen vorhanden sein.
**[ WHERE condition ]**
Filtert Ergebnisse nach dem von Ihnen angegebenen `condition`, wobei `condition` im Allgemeinen die folgende Syntax hat.
```
column_name operator value [[[AND | OR] column_name operator value] ...]
```
Das *operator* kann einer der Komparatoren sein`=`,,`>`,`<`,`>=`, `<=``<>`,`!=`.
Die folgenden Unterabfrageausdrücke können auch in der `WHERE`-Klausel verwendet werden.
+ `[NOT] BETWEEN integer_A AND integer_B` – Gibt einen Bereich zwischen zwei Ganzzahlen an, wie im folgenden Beispiel. Wenn der Spaltendatentyp `varchar` ist, muss die Spalte zuerst in eine Ganzzahl umgewandelt werden.
```
SELECT DISTINCT processid FROM "webdata"."impressions"
WHERE cast(processid as int) BETWEEN 1500 and 1800
ORDER BY processid
```
+ `[NOT] LIKE value` – Sucht nach dem angegebenen Muster. Verwenden Sie das Prozentzeichen (`%`) als Platzhalterzeichen, wie im folgenden Beispiel.
```
SELECT * FROM "webdata"."impressions"
WHERE referrer LIKE '%.org'
```
+ `[NOT] IN (value[, value[, ...])` – Gibt eine Liste möglicher Werte für eine Spalte an, wie im folgenden Beispiel gezeigt.
```
SELECT * FROM "webdata"."impressions"
WHERE referrer IN ('example.com','example.net','example.org')
```
**[ GROUP BY [ ALL \$1 DISTINCT ] grouping\$1expressions [, ...] ]**
Teilt die Ausgabe der `SELECT`-Anweisung in Zeilen mit passenden Werten.
Über `ALL` und `DISTINCT` wird festgelegt, ob für Duplikate jeweils eine eigene Ausgabezeile angelegt wird. Wenn nichts angegeben ist, wird von `ALL` ausgegangen.
`grouping_expressions` ermöglicht Ihnen, komplexe Gruppierungsoperationen auszuführen. Sie können komplexe Gruppierungsvorgänge verwenden, um Analysen durchzuführen, die eine Aggregation mehrerer Spaltengruppen in einer einzigen Abfrage erfordern.
Das `grouping_expressions`-Element kann eine beliebige Funktion sein, z. B. `SUM`, `AVG` oder `COUNT`, die auf Eingabespalten ausgeführt wird.
Mithilfe von `GROUP BY`-Ausdrücken kann die Ausgabe nach Eingabespaltennamen gruppiert werden, die nicht in der Ausgabe der `SELECT`-Anweisung auftauchen.
Alle Ausgabeausdrücke müssen entweder Aggregatfunktionen oder Spalten sein, die in der `GROUP BY`-Klausel vorhanden sind.
Sie können mit einer einzelnen Abfrage eine Analyse durchführen, für die mehrere Spaltensätze zusammengefasst werden müssen.
Athena unterstützt komplexe Aggregationen mit `GROUPING SETS`, `CUBE` und `ROLLUP`. `GROUP BY GROUPING SETS` gibt mehrere Spaltenlisten an, nach denen gruppiert werden soll. `GROUP BY CUBE` generiert alle möglichen Gruppierungssätze für einen gegebenen Satz von Spalten. `GROUP BY ROLLUP` generiert alle möglichen Zwischensummen für einen gegebenen Satz von Spalten. Komplexe Gruppierungsoperationen unterstützen keine Gruppierung von Ausdrücken, die aus Eingabespalten bestehen. Es sind nur Spaltennamen zulässig.
Oft können Sie mit `UNION ALL` dieselben Ergebnisse erzielen wie mit diesen `GROUP BY`-Operationen. Abfragen, in denen `GROUP BY` verwendet wird, haben jedoch den Vorteil, dass die Daten einmalig ausgelesen werden, wohingegen bei `UNION ALL` die zugrunde liegenden Daten dreimal ausgelesen werden, was zu uneinheitlichen Ergebnissen führen kann, wenn die Datenquelle sich geändert hat.
**[ HAVING condition ]**
Wird in Aggregatfunktionen und der `GROUP BY`-Klausel verwendet. Kontrolliert, welche Gruppen ausgewählt werden und schließt Gruppen aus, die die `condition` nicht erfüllen. Diese Filterung wird nach der Berechnung der Gruppierungs- und Aggregatfunktionen ausgeführt.
**[ \$1 UNION \$1 INTERSECT \$1 EXCEPT \$1 [ ALL \$1 DISTINCT ] union\$1query] ]**
`UNION`, `INTERSECT` und`EXCEPT` kombinieren die Ergebnisse mehrerer `SELECT`-Anweisungen in eine einzelne Abfrage. `ALL` oder `DISTINCT` steuern die Eindeutigkeit der Zeilen, die in der endgültigen Ergebnismenge enthalten sind.
`UNION` kombiniert die Zeilen, die sich aus der ersten Abfrage ergeben, mit den Zeilen, die aus der zweiten Abfrage resultieren. Um Duplikate zu eliminieren, erstellt `UNION` eine Hash-Tabelle, die Speicher verbraucht. Ziehen Sie für eine bessere Leistung die Verwendung von `UNION ALL` in Betracht, wenn Ihre Abfrage die Eliminierung von Duplikaten nicht erfordert. Mehrere `UNION`-Klauseln werden von links nach rechts verarbeitet, sofern Sie keine Klammern verwenden, um die Verarbeitungsreihenfolge explizit festzulegen.
`INTERSECT` gibt nur die Zeilen zurück, die in den Ergebnissen der ersten und der zweiten Abfrage vorhanden sind.
`EXCEPT` gibt die Zeilen aus den Ergebnissen der ersten Abfrage zurück, ausgenommen die Zeilen, die von der zweiten Abfrage gefunden wurden.
`ALL` bewirkt, dass alle Zeilen aufgenommen werden, auch wenn die Zeilen identisch sind.
`DISTINCT` bewirkt, dass nur eindeutige Zeilen in die kombinierte Ergebnismenge aufgenommen werden.
**[ ORDER BY expression [ ASC \$1 DESC ] [ NULLS FIRST \$1 NULLS LAST] [, ...] ]**
Sortiert eine Ergebnisgruppe nach einem oder mehreren Ausgabe-`expression`.
Wenn die Klausel mehrere Ausdrücke enthält, wird die Ergebnisgruppe nach dem ersten `expression` sortiert. Danach wird der zweite `expression` auf die Zeilen mit passenden Werten aus dem ersten Ausdruck angewendet usw.
Jeder `expression` kann Ausgabespalten aus `SELECT` oder eine Ordinalzahl für eine Ausgabespalte nach Position (beginnend mit 1) festlegen.
`ORDER BY` wird im letzten Schritt nach `GROUP BY`- und `HAVING`-Klauseln ausgewertet. Über `ASC` und `DESC` wird festgelegt, ob die Ergebnisse in auf- oder absteigender Reihenfolge sortiert werden. Standardmäßig ist die Sortierreihenfolge aufsteigend (`ASC`). Die Standardnullsortierung ist `NULLS LAST` unabhängig von auf- oder absteigender Sortierreihenfolge.
**[ OFFSET count [ ROW \$1 ROWS ] ]**
Verwenden Sie die `OFFSET`-Klausel, um eine Reihe führender Zeilen aus der Ergebnismenge zu verwerfen. Wenn die `ORDER BY`-Klausel vorhanden ist, wird die `OFFSET`-Klausel über eine sortierte Ergebnismenge ausgewertet und die Menge bleibt sortiert, nachdem die übersprungenen Zeilen verworfen wurden. Wenn die Abfrage keine `ORDER BY`-Klausel hat, ist es willkürlich, welche Zeilen verworfen werden. Wenn die durch `OFFSET` angegebene Anzahl der Größe der Ergebnismenge entspricht oder diese überschreitet, ist das Endergebnis leer.
**LIMIT [ count \$1 ALL ]**
Beschränkt die Anzahl der Zeilen in der Ergebnisgruppe auf `count`. `LIMIT ALL` entspricht dem Weglassen der `LIMIT`-Klausel. Wenn die Abfrage keine `ORDER BY`-Klausel enthält, werden die Ergebnisse zufällig angezeigt.
**TABLESAMPLE [ BERNOULLI \$1 SYSTEM ] (percentage)**
Optionaler Operator zur Auswahl von Zeilen aus einer Tabelle basierend auf einer Stichprobenmethode.
Mit `BERNOULLI` wird jede Zeile mit einer Wahrscheinlichkeit von `percentage` als Teil der Stichprobe ausgewählt. Alle physischen Blöcke der Tabelle werden gescannt und bestimmte Zeilen werden basierend auf einem Vergleich zwischen dem `percentage` der Stichproben und einem zufälligen, zur Laufzeit berechneten Wert übersprungen.
Mit `SYSTEM` wird die Tabelle in logische Datensegmente unterteilt. Aus der Tabelle werden Stichproben mit dieser Granularität entnommen.
Es werden entweder alle Zeilen aus einem bestimmten Segment ausgewählt oder das Segment wird basierend auf einem Vergleich zwischen dem `percentage` der Stichprobe und einem zufälligen, während der Laufzeit berechneten Wert übersprungen. `SYSTEM`-Stichproben sind abhängig vom Connector. Mit dieser Methode kann keine unabhängige Stichprobenwahrscheinlichkeit garantiert werden.
**[ UNNEST (array\$1or\$1map) [WITH ORDINALITY] ]**
Erweitert ein Array oder eine Zuordnung in eine Beziehung. Arrays werden in eine einzelne Spalte erweitert. Zuordnungen werden in zwei Spalten (*Schlüssel* und *Wert*) erweitert.
Sie können `UNNEST` mit mehreren Argumenten verwenden, die in mehrere Spalten mit so vielen Zeilen wie das höchste Kardinalitätsargument erweitert werden.
Andere Spalten werden mit Nullen aufgefüllt.
Die `WITH ORDINALITY`-Klausel fügt eine Ordinalitätsspalte am Ende hinzu.
`UNNEST` wird normalerweise mit einem `JOIN` verwendet und kann auf Spalten von Beziehungen links des `JOIN` verweisen.
## Abrufen der Dateispeicherorte für Quelldaten in Amazon S3
Um den Speicherort der Amazon-S3-Datei für die Daten in einer Tabellenzeile anzuzeigen, können Sie `"$path"` in einer `SELECT`-Abfrage verwenden, wie im folgenden Beispiel:
```
SELECT "$path" FROM "my_database"."my_table" WHERE year=2019;
```
Dies gibt ein Ergebnis wie das folgende zurück:
```
s3://amzn-s3-demo-bucket/datasets_mytable/year=2019/data_file1.json
```
Um eine sortierte, eindeutige Liste der S3-Dateinamenspfade für die Daten in einer Tabelle zurückzugeben, können Sie wie im folgenden Beispiel `SELECT DISTINCT` und `ORDER BY` verwenden.
```
SELECT DISTINCT "$path" AS data_source_file
FROM sampledb.elb_logs
ORDER By data_source_file ASC
```
Um nur die Dateinamen ohne Pfad zurückzugeben, können Sie `"$path"` wie im folgenden Beispiel als Parameter an eine `regexp_extract`-Funktion übergeben.
```
SELECT DISTINCT regexp_extract("$path", '[^/]+$') AS data_source_file
FROM sampledb.elb_logs
ORDER By data_source_file ASC
```
Um die Daten aus einer bestimmten Datei zurückzugeben, geben Sie die Datei in der `WHERE`-Klausel an, wie im folgenden Beispiel.
```
SELECT *,"$path" FROM my_database.my_table WHERE "$path" = 's3://amzn-s3-demo-bucket/my_table/my_partition/file-01.csv'
```
Weitere Informationen und Beispiele finden Sie im Wissenscenter-Artikel [Wie kann ich die Amazon-S3-Quelldatei für eine Zeile in einer Athena-Tabelle anzeigen?](https://aws.amazon.com/premiumsupport/knowledge-center/find-s3-source-file-athena-table-row/).
**Anmerkung**
In Athena, Hive oder Iceberg werden die versteckten Metadatenspalten `$bucket`, `$file_modified_time`, `$file_size` und `$partition` für Ansichten nicht unterstützt.
## Maskieren von einfachen Anführungszeichen mit Escape
Um ein einzelnes Anführungszeichen mit Escape zu maskieren, stellen Sie ihm ein weiteres einfaches Anführungszeichen voran, wie im folgenden Beispiel. Verwechseln Sie dies nicht mit einem doppelten Anführungszeichen.
```
Select 'O''Reilly'
```
**Ergebnisse**
`O'Reilly`
## Weitere Ressourcen
Weitere Informationen zur Verwendung von `SELECT`-Anweisungen in Athena finden Sie in den folgenden Ressourcen.
| Weitere Informationen darüber | Sehen Sie dies an |
| --- | --- |
| Ausführen von Abfragen in Athena | [Ausführen von SQL-Abfragen in Amazon Athena](querying-athena-tables.md) |
| Mit SELECT eine Tabelle erstellen | [Erstellen einer Tabelle aus Abfrageergebnissen (CTAS)](ctas.md) |
| Einfügen von Daten aus einer SELECT-Abfrage in eine andere Tabelle | [INSERT INTO](insert-into.md) |
| Integrierte Funktionen in SELECT-Anweisungen verwenden | [Funktionen in Amazon Athena](functions.md) |
| Verwenden von benutzerdefinierten Funktionen in SELECT-Anweisungen | [Abfragen mit benutzerdefinierten Funktionen](querying-udf.md) |
| Metadaten des Datenkatalogs abfragen | [Fragen Sie die ab AWS Glue Data Catalog](querying-glue-catalog.md) |
# INSERT INTO
Fügt neue Zeilen in eine Zieltabelle ein, basierend auf einer `SELECT`-Abfrageanweisung, die in einer Quelltabelle ausgeführt wird, oder basierend auf einem Satz von `VALUES`, der als Teil der Anweisung bereitgestellt wird. Wenn die Quelltabelle auf zugrunde liegenden Daten in einem Format wie CSV oder JSON basiert und die Zieltabelle auf einem anderen Format wie Parquet oder ORC basiert, können Sie `INSERT INTO`-Abfragen verwenden, um ausgewählte Daten in das Format der Zieltabelle zu transformieren.
## Überlegungen und Einschränkungen
Beachten Sie Folgendes, wenn Sie `INSERT`-Abfragen mit Athena verwenden.
+ Wenn Sie eine `INSERT`-Abfrage für eine Tabelle mit zugrunde liegenden Daten ausführen, die in Amazon S3 verschlüsselt sind, werden die Ausgabedateien, die die `INSERT`-Abfrage schreibt, standardmäßig nicht verschlüsselt. Wir empfehlen, `INSERT`-Abfrageergebnisse zu verschlüsseln, wenn Sie in Tabellen mit verschlüsselten Daten einfügen.
Weitere Informationen zum Verschlüsseln von Abfrageergebnissen mithilfe der Konsole finden Sie unter [Verschlüsseln Sie die in Amazon S3 gespeicherten Athena-Abfrageergebnisse](encrypting-query-results-stored-in-s3.md). Um die Verschlüsselung mit der AWS CLI oder der Athena-API zu aktivieren, verwenden Sie die `EncryptionConfiguration` Eigenschaften der [StartQueryExecution](https://docs.aws.amazon.com/athena/latest/APIReference/API_StartQueryExecution.html)Aktion, um Amazon S3 S3-Verschlüsselungsoptionen gemäß Ihren Anforderungen festzulegen.
+ Für `INSERT INTO`-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).
+ ACID-konforme `INSERT INTO`-Anweisungen finden Sie im `INSERT INTO`-Abschnitt von [Iceberg-Tabellendaten aktualisieren](querying-iceberg-updating-iceberg-table-data.md).
### Unterstützte Formate und SerDes
Sie können eine `INSERT` Abfrage für Tabellen ausführen, die aus Daten mit den folgenden Formaten und erstellt wurden SerDes.
| Data format (Datenformat) | SerDe |
| --- | --- |
| Avro | org.apache.hadoop.hive.serde2.avro. AvroSerDe |
| Ion | com.amazon.ionhiveserde. IonHiveSerDe |
| JSON | org.apache.hive.hcatalog.data. JsonSerDe |
| ORC | org.apache.hadoop.hive.ql.io.orc. OrcSerde |
| Parquet | org.apache.hadoop.hive.ql.io.parquet.serde. ParquetHiveSerDe |
| Textdatei | org.apache.hadoop.hive.serde2.lazy. LazySimpleSerDe TSV- und benutzerdefinierte, durch Trennzeichen getrennte Dateien werden unterstützt. |
| CSV | org.apache.hadoop.hive.serde2.open CSVSerde Schreibvorgänge werden nur für String-Typen unterstützt. Von Athena aus können Sie nicht in Tabellen schreiben, die Nicht-String-Typen im Glue-Schema enthalten. [Weitere Informationen finden Sie unter CSV. SerDe](csv-serde.md#csv-serde-opencsvserde-considerations-non-string) |
### Bucket-Tabellen werden nicht unterstützt
`INSERT INTO` wird für Bucket-Tabellen nicht unterstützt. Weitere Informationen finden Sie unter [Partitionierung und Bucketing verwenden](ctas-partitioning-and-bucketing.md).
### Verbundabfragen werden nicht unterstützt
`INSERT INTO` wird für Verbundabfragen nicht unterstützt. Ein Versuch, dies zu tun, kann zur Fehlermeldung führen: Dieser Vorgang wird derzeit für externe Kataloge nicht unterstützt. Weitere Informationen zu Verbundabfragen finden Sie unter [Nutzung von Amazon-Athena-Verbundabfrage](federated-queries.md).
### Partitionierung
Beachten Sie die Punkte in diesem Abschnitt, wenn Sie die Partitionierung mit `INSERT INTO`- oder `CREATE TABLE AS SELECT`-Abfragen verwenden.
#### Einschränkungen
Die Anweisung `INSERT INTO` unterstützt das Schreiben von maximal 100 Partitionen in die Zieltabelle. Wenn Sie die `SELECT`-Klausel für eine Tabelle mit mehr als 100 Partitionen ausführen, schlägt die Abfrage fehl, es sei denn, die `SELECT`-Abfrage ist auf 100 Partitionen oder weniger beschränkt.
Hinweise zum Umgehen dieser Einschränkung finden Sie unter [Verwenden von CTAS und INSERT INTO zum Umgehen des Limits von 100 Partitionen](ctas-insert-into.md).
#### Spalten-Reihenfolge
`INSERT INTO`- oder `CREATE TABLE AS SELECT`-Anweisungen erwarten, dass die partitionierte Spalte die letzte Spalte in der Liste der projizierten Spalten in einer `SELECT`-Anweisung ist.
Wenn die Quelltabelle nicht partitioniert ist oder im Vergleich zur Zieltabelle auf verschiedene Spalten partitioniert ist, betrachten Abfragen wie `INSERT INTO destination_table SELECT * FROM source_table` die Werte in der letzten Spalte der Quelltabelle als Werte für eine Partitionsspalte in der Zieltabelle. Beachten Sie dies beim Versuch, eine partitionierte Tabelle aus einer nicht partitionierten Tabelle zu erstellen.
#### Ressourcen
Weitere Informationen zur Verwendung von `INSERT INTO` mit Partitionierung finden Sie in den folgenden Ressourcen.
+ Hinweise zum Einfügen von partitionierten Daten in eine partitionierte Tabelle finden Sie unter [Verwenden von CTAS und INSERT INTO zum Umgehen des Limits von 100 Partitionen](ctas-insert-into.md).
+ Hinweise zum Einfügen von nicht-partitionierten Daten in eine partitionierte Tabelle finden Sie unter [Verwenden von CTAS und INSERT INTO für ETL und Datenanalyse](ctas-insert-into-etl.md).
### In Amazon S3 geschriebene Dateien
Athena schreibt Dateien in die Quelldatenspeicherorte in Amazon S3 als Ergebnis des `INSERT`-Befehls. Jede `INSERT`-Operation erstellt eine neue Datei, anstatt an eine vorhandene Datei anzuhängen. Die Dateispeicherorte hängen von der Struktur der Tabelle und ggf. der `SELECT`-Abfrage ab. Athena generiert für jede `INSERT`-Abfrage eine Daten-Manifest-Datei. Das Manifest verfolgt die Dateien, die die Abfrage geschrieben hat. Es wird im Verzeichnis der Athena-Abfrageergebnisse in Amazon S3 gespeichert. Weitere Informationen finden Sie unter [Identifizieren von Abfrageausgabedateien](querying-finding-output-files.md#querying-identifying-output-files).
### Transaktionsintensive Aktualisierungen vermeiden
Wenn Sie `INSERT INTO` verwenden um Zeilen zu einer Tabelle in Amazon S3 hinzufügen, schreibt Athena keine vorhandenen Dateien neu und nimmt auch keine Änderungen daran vor. Stattdessen schreibt es die Zeilen als eine oder mehrere neue Dateien. Da Tabellen mit [vielen kleinen Dateien zu einer geringeren Abfrageleistung führen](performance-tuning-data-optimization-techniques.md#performance-tuning-avoid-having-too-many-files) und Schreib- und Lesevorgänge wie `PutObject` und `GetObject` zu höheren Kosten von Amazon S3 führen, sollten Sie bei der Verwendung von `INSERT INTO` die folgenden Optionen in Betracht ziehen:
+ Führen Sie `INSERT INTO`-Operationen seltener für größere Stapel von Zeilen aus.
+ Bei großen Datenerfassungsmengen sollten Sie einen Service wie [Amazon Data Firehose](https://docs.aws.amazon.com/firehose/latest/dev/what-is-this-service.html) in Betracht ziehen.
+ Vermeiden Sie gänzlich die Verwendung von `INSERT INTO`. Sammeln Sie stattdessen Zeilen in größeren Dateien und laden Sie sie direkt auf Amazon S3 hoch, wo sie von Athena abgefragt werden können.
### Suchen verwaister Dateien
Wenn eine `CTAS` oder `INSERT INTO`-Anweisung fehlschlägt, können verwaiste Daten an dem Datenspeicherort verbleiben und möglicherweise in nachfolgenden Abfragen gelesen werden. 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. Weitere Informationen erhalten 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).
## INSERT INTO...SELECT
Gibt die Abfrage an, die für eine Tabelle ausgeführt werden soll, `source_table`, die festlegt, welche Zeilen in eine zweite Tabelle eingefügt werden sollen, `destination_table`. Wenn die `SELECT`-Abfrage Spalten in der `source_table` angibt, müssen die Spalten genau mit denen in der `destination_table` übereinstimmen.
Weitere Informationen zu `SELECT`-Abfragen finden Sie unter [SELECT](select.md).
### Syntax
```
INSERT INTO destination_table
SELECT select_query
FROM source_table_or_view
```
### Beispiele
Wählen Sie alle Zeilen in der `vancouver_pageviews`-Tabelle aus und fügen Sie sie in die `canada_pageviews`-Tabelle ein:
```
INSERT INTO canada_pageviews
SELECT *
FROM vancouver_pageviews;
```
Wählen Sie nur die Zeilen in der `vancouver_pageviews`-Tabelle aus, in denen die `date`-Spalte einen Wert zwischen `2019-07-01` und `2019-07-31` hat, und fügen Sie sie dann in `canada_july_pageviews` ein:
```
INSERT INTO canada_july_pageviews
SELECT *
FROM vancouver_pageviews
WHERE date
BETWEEN date '2019-07-01'
AND '2019-07-31';
```
Wählen Sie die Werte in den Spalten `city` und `state` in der `cities_world`-Tabelle nur aus den Zeilen mit dem Wert `usa` in der Spalte `country` aus und fügen Sie sie in die Spalten `city` und `state` in der `cities_usa`-Tabelle ein:
```
INSERT INTO cities_usa (city,state)
SELECT city,state
FROM cities_world
WHERE country='usa'
```
## INSERT INTO...VALUES
Fügt Zeilen in eine vorhandene Tabelle ein, indem Spalten und Werte angegeben werden. Angegebene Spalten und zugehörige Datentypen müssen genau mit den Spalten und Datentypen in der Zieltabelle übereinstimmen.
**Wichtig**
Wir raten davon ab, Zeilen mit `VALUES` einzufügen, da Athena Dateien für jede `INSERT`-Operation generiert. Dies kann dazu führen, dass viele kleine Dateien erstellt werden und die Abfrageleistung der Tabelle beeinträchtigen. Um Dateien zu identifizieren, die eine `INSERT`-Abfrage erstellt, überprüfen Sie die Daten-Manifest-Datei. Weitere Informationen finden Sie unter [Arbeiten mit Abfrageergebnissen und aktuellen Abfragen](querying.md).
### Syntax
```
INSERT INTO destination_table [(col1,col2,...)]
VALUES (col1value,col2value,...)[,
(col1value,col2value,...)][,
...]
```
### Beispiele
In den folgenden Beispielen hat die Tabelle "cities" drei Spalten: `id`, `city`, `state`, `state_motto`. Die `id`-Spalte hat den Typ `INT` und alle anderen Spalten haben den Typ `VARCHAR`.
Fügen Sie eine einzelne Zeile in die `cities`-Tabelle ein, wobei alle Spaltenwerte angegeben sind:
```
INSERT INTO cities
VALUES (1,'Lansing','MI','Si quaeris peninsulam amoenam circumspice')
```
Fügen Sie zwei Zeilen in die `cities`-Tabelle ein:
```
INSERT INTO cities
VALUES (1,'Lansing','MI','Si quaeris peninsulam amoenam circumspice'),
(3,'Boise','ID','Esto perpetua')
```
# VALUES
Erzeugt eine literale Inlinetabelle. Die Tabelle kann anonym sein, oder Sie können die `AS`-Klausel verwenden, um einen Tabellennamen, Spaltennamen oder beides anzugeben.
## Syntax
```
VALUES row [, ...]
```
## Parameters
**Zeile**
Der `row`-Parameter kann ein einzelner Ausdruck oder `( column_expression [, ...] )` sein.
## Beispiele
Gibt eine Tabelle mit einer Spalte und drei Zeilen zurück:
```
VALUES 1, 2, 3
```
Gibt eine Tabelle mit zwei Spalten und drei Zeilen zurück:
```
VALUES
(1, 'a'),
(2, 'b'),
(3, 'c')
```
Gibt eine Tabelle mit den Spalten `id` und`name` zurück:
```
SELECT * FROM (
VALUES
(1, 'a'),
(2, 'b'),
(3, 'c')
) AS t (id, name)
```
Erstellen Sie eine Tabelle namens `customers` mit den Spalten `id` und `name`:
```
CREATE TABLE customers AS
SELECT * FROM (
VALUES
(1, 'a'),
(2, 'b'),
(3, 'c')
) AS t (id, name)
```
## Weitere Informationen finden Sie auch unter
[INSERT INTO...VALUES](insert-into.md#insert-into-values)
# DELETE
Löscht Zeilen in einer Apache-Iceberg-Tabelle. `DELETE` ist transaktionsbasiert und wird nur für Apache-Iceberg-Tabellen unterstützt.
## Syntax
Verwenden Sie die folgende Syntax, um die Zeilen in einer Iceberg-Tabelle zu löschen.
```
DELETE FROM [db_name.]table_name [WHERE predicate]
```
Weitere Informationen und Beispiele finden Sie im `DELETE`-Abschnitt von [Iceberg-Tabellendaten aktualisieren](querying-iceberg-updating-iceberg-table-data.md).
# UPDATE
Aktualisiert Zeilen in einer Apache-Iceberg-Tabelle. `UPDATE` ist transaktionsbasiert und wird nur für Apache-Iceberg-Tabellen unterstützt. Die Anweisung funktioniert nur für bestehende Zeilen und kann nicht zum Einfügen oder Anhängen einer Zeile verwendet werden.
## Syntax
Verwenden Sie die folgende Syntax, um die Zeilen in einer Iceberg-Tabelle zu aktualisieren.
```
UPDATE [db_name.]table_name SET xx=yy[,...] [WHERE predicate]
```
Weitere Informationen und Beispiele finden Sie im `UPDATE`-Abschnitt von [Iceberg-Tabellendaten aktualisieren](querying-iceberg-updating-iceberg-table-data.md).
# MERGE INTO
Aktualisiert, löscht oder fügt Zeilen in eine Apache-Iceberg-Tabelle ein. Eine einzige Anweisung kann Aktionen zum Aktualisieren, Löschen und Einfügen kombinieren.
**Anmerkung**
`MERGE INTO` ist transaktionsbasiert und wird nur für Apache-Iceberg-Tabellen in Athena-Engine-Version 3 unterstützt.
## Syntax
Verwenden Sie die folgende Syntax, um Zeilen in einer Iceberg-Tabelle bedingt zu aktualisieren, zu löschen oder einzufügen.
```
MERGE INTO target_table [ [ AS ] target_alias ]
USING { source_table | query } [ [ AS ] source_alias ]
ON search_condition
when_clause [...]
```
Das *when\$1clause* ist einer der folgenden:
```
WHEN MATCHED [ AND condition ]
THEN DELETE
```
```
WHEN MATCHED [ AND condition ]
THEN UPDATE SET ( column = expression [, ...] )
```
```
WHEN NOT MATCHED [ AND condition ]
THEN INSERT (column_name[, column_name ...]) VALUES (expression, ...)
```
`MERGE` unterstützt eine beliebige Anzahl von `WHEN`-Klauseln mit unterschiedlichen `MATCHED`-Bedingungen. Die Bedingungsklauseln führen die `DELETE`, `UPDATE` oder `INSERT`-Operation in der ersten `WHEN`-Klausel aus, die durch den `MATCHED`-Zustand und die Übereinstimmungsbedingung ausgewählt wurde.
Für jede Quellzeile werden die `WHEN`-Klauseln der Reihe nach verarbeitet. Nur die erste übereinstimmende `WHEN`-Klausel wird ausgeführt. Nachfolgende Klauseln werden ignoriert. Ein Benutzerfehler wird ausgegeben, wenn eine einzelne Zeile der Zieltabelle mit mehr als einer Quellzeile übereinstimmt.
Wenn eine Quellzeile mit keiner `WHEN`-Klausel übereinstimmt und es keine `WHEN NOT MATCHED`-Klausel gibt, wird die Quellzeile ignoriert.
In `WHEN`-Klauseln mit `UPDATE`-Operationen können sich die Spaltenwertausdrücke auf jedes Feld des Ziels oder der Quelle beziehen. Im `NOT MATCHED`-Fall können sich die `INSERT`-Ausdrücke auf ein beliebiges Feld der Quelle beziehen.
**Beispiel**
Im folgenden Beispiel werden Zeilen aus der zweiten Tabelle mit der ersten Tabelle zusammengeführt, wenn die Zeilen in der ersten Tabelle nicht vorhanden sind. Beachten Sie, dass den in der `VALUES`-Klausel aufgeführten Spalten der Alias der Quelltabelle vorangestellt werden muss. Den in der `INSERT`-Klausel aufgeführten Zielspalten darf *kein* solches Präfix vorangestellt werden.
```
MERGE INTO iceberg_table_sample as ice1
USING iceberg2_table_sample as ice2
ON ice1.col1 = ice2.col1
WHEN NOT MATCHED
THEN INSERT (col1)
VALUES (ice2.col1)
```
Weitere `MERGE INTO`-Beispiele finden Sie unter [Iceberg-Tabellendaten aktualisieren](querying-iceberg-updating-iceberg-table-data.md).
# OPTIMIZE
Optimiert Zeilen in einer Apache-Iceberg-Tabelle durch Umschreiben von Datendateien in ein optimiertes Layout basierend auf deren Größe und der Anzahl der zugeordneten Löschdateien.
**Anmerkung**
`OPTIMIZE` ist transaktionsbasiert und wird nur für Apache-Iceberg-Tabellen unterstützt.
## Syntax
Die folgende Syntaxzusammenfassung zeigt, wie das Datenlayout für eine Iceberg-Tabelle optimiert wird.
```
OPTIMIZE [db_name.]table_name REWRITE DATA USING BIN_PACK
[WHERE predicate]
```
**Anmerkung**
In der `WHERE` Klausel sind nur Partitionsspalten zulässig*predicate*. Wenn Sie eine Spalte angeben, die nicht partitioniert ist, schlägt die Abfrage fehl.
Die Verdichtungsaktion wird durch die Datenmenge berechnet, die während des Umschreibungsvorgangs gescannt wurde. Die `REWRITE DATA`-Aktion verwendet Prädikate zur Auswahl für Dateien, die übereinstimmende Zeilen enthalten. Wenn eine Zeile in der Datei mit dem Prädikat übereinstimmt, wird die Datei zur Optimierung ausgewählt. Um also die Anzahl der von der Verdichtungsoperation betroffenen Dateien zu steuern, können Sie eine `WHERE`-Klausel angeben.
## Konfigurieren von Komprimierungs-Eigenschaften
Um die Größe der für die Verdichtung zu wählenden Dateien und die resultierende Dateigröße nach der Verdichtung zu steuern, können Sie Tabelleneigenschaftsparameter verwenden. Sie können den [ALTER TABLE SET TBLPROPERTIES](querying-iceberg-alter-table-set-properties.md)-Befehl verwenden, um die zugehörigen [Tabelleneigenschaften](querying-iceberg-creating-tables.md#querying-iceberg-table-properties) zu konfigurieren.
## Weitere Ressourcen
[Iceberg-Tabellen optimieren](querying-iceberg-data-optimization.md)
# VACUUM
Die `VACUUM`-Anweisung führt Wartung von Apache-Iceberg-Tabellen durch, indem sie das [Ablaufen von Snapshots](https://iceberg.apache.org/docs/latest/spark-procedures/#expire_snapshots) und [Entfernen verwaister Dateien](https://iceberg.apache.org/docs/latest/spark-procedures/#remove_orphan_files) durchführt .
**Anmerkung**
`VACUUM` ist transaktionsbasiert und wird nur für Apache-Iceberg-Tabellen in Athena-Engine-Version 3 unterstützt.
Die `VACUUM`-Anweisung optimiert Iceberg-Tabellen, indem sie den Speicherverbrauch reduziert. Weitere Informationen zur Verwendung von `VACUUM` finden Sie unter [Iceberg-Tabellen optimieren](querying-iceberg-data-optimization.md). Beachten Sie, dass für die damit verbundenen Anfragen an Amazon S3 Gebühren anfallen, da die `VACUUM`-Anweisung API-Aufrufe an Amazon S3 tätigt.
**Warnung**
Wenn Sie einen Snapshot-Ablauf ausführen, können Sie nicht mehr zu abgelaufenen Snapshots reisen.
## Syntax
Verwenden Sie die folgende Syntax, um Datendateien zu entfernen, die für eine Iceberg-Tabelle nicht mehr benötigt werden.
```
VACUUM [database_name.]target_table
```
+ `VACUUM` erwartet, dass sich die Iceberg-Daten in einem Amazon-S3-Ordner und nicht in einem Amazon-S3-Bucket befinden. Wenn sich Ihre Iceberg-Daten beispielsweise auf `s3://amzn-s3-demo-bucket`/ statt auf `s3://amzn-s3-demo-bucket/myicebergfolder/` befinden, schlägt die `VACUUM`-Anweisung mit der Fehlermeldung GENERIC\$1INTERNAL\$1ERROR: Pfad fehlt im Dateisystem: `s3://amzn-s3-demo-bucket` fehl.
+ Damit `VACUUM` Datendateien löschen kann, muss Ihre Rolle zur Abfrageausführung über `s3:DeleteObject`-Berechtigungen für den Bucket verfügen, in dem sich Ihre Iceberg-Tabellen, Metadaten, Snapshots und Datendateien befinden. Wenn die Berechtigung nicht vorhanden ist, ist die `VACUUM`-Abfrage erfolgreich, aber die Dateien werden nicht gelöscht.
+ Um `VACUUM` auf eine Tabelle auszuführen, deren Name mit einem Unterstrich beginnt (z. B. `_mytable`), schließen Sie den Tabellennamen in umgekehrte Anführungszeichen ein, wie im folgenden Beispiel. Wenn Sie dem Tabellennamen einen Datenbanknamen voranstellen, schließen Sie den Datenbanknamen nicht in umgekehrte Anführungszeichen ein. Beachten Sie, dass doppelte Anführungszeichen nicht anstelle von umgekehrte Anführungszeichen funktionieren.
Dieses Verhalten ist spezifisch für `VACUUM`. Die `CREATE` und `INSERT INTO`-Anweisungen erfordern keine umgekehrte Anführungszeichen für Tabellennamen, die mit Unterstrichen beginnen.
```
VACUUM `_mytable`
VACUUM my_database.`_mytable`
```
## Durchgeführte Operationen
`VACUUM` führt die folgenden Operationen aus:
+ Entfernt Snapshots, die älter sind als die durch die `vacuum_max_snapshot_age_seconds`-Tabelleneigenschaft angegebene Zeitdauer. Standardmäßig ist diese Eigenschaft auf 432 000 Sekunden (5 Tage) festgelegt.
+ Entfernt Snapshots, die nicht innerhalb des Aufbewahrungszeitraums liegen und die die in der `vacuum_min_snapshots_to_keep`-Tabelleneigenschaft angegebene Anzahl überschreiten. Der Standardwert ist 1.
Sie können diese Tabelleneigenschaften in Ihrer `CREATE TABLE`-Anweisung angeben. Nachdem die Tabelle erstellt wurde, können Sie diese mit der [ALTER TABLE SET TBLPROPERTIES](querying-iceberg-alter-table-set-properties.md)-Anweisung aktualisieren.
+ Entfernt alle Metadaten und Datendateien, die aufgrund des Entfernens des Snapshots nicht mehr erreichbar sind. Sie können die Anzahl der alten Metadatendateien, die beibehalten werden sollen, konfigurieren, indem Sie die `vacuum_max_metadata_files_to_keep`-Tabelleneigenschaft festlegen. Der Standardwert lautet 100.
+ Entfernt verwaiste Dateien, die älter sind als die in der `vacuum_max_snapshot_age_seconds`-Tabelleneigenschaft angegebene Zeit. Verwaiste Dateien sind Dateien im Datenverzeichnis der Tabelle, die nicht mehr Teil des Tabellenstatus sind.
Weitere Informationen zur Erstellung und Verwaltung von Apache-Iceberg-Tabellen in Athena finden Sie unter [Iceberg-Tabellen erstellen](querying-iceberg-creating-tables.md) und [Iceberg-Tabellen verwalten](querying-iceberg-managing-tables.md).
# Verwenden von EXPLAIN und EXPLAIN ANALYZE in Athena
Die `EXPLAIN`-Anweisung zeigt den logischen oder verteilten Ausführungsplan einer angegebenen SQL-Anweisung oder validiert die SQL-Anweisung. Sie können die Ergebnisse im Textformat oder in einem Datenformat für das Rendern in einem Diagramm ausgeben.
**Anmerkung**
Sie können grafische Darstellungen logischer und verteilter Pläne für Ihre Abfragen in der Athena-Konsole anzeigen, ohne die `EXPLAIN`-Dateisyntax zu verwenden. Weitere Informationen finden Sie unter [Anzeigen von Ausführungsplänen für SQL-Abfragen](query-plans.md).
Die `EXPLAIN ANALYZE`-Anweisung zeigt sowohl den verteilten Ausführungsplan einer angegebenen SQL-Anweisung als auch die Rechenkosten jeder Operation in einer SQL-Abfrage an. Sie können die Ergebnisse im Text- oder JSON-Format ausgeben.
## Überlegungen und Einschränkungen
Die `EXPLAIN`- und `EXPLAIN ANALYZE`-Anweisungen in Athena unterliegen den folgenden Einschränkungen.
+ Da `EXPLAIN`-Abfragen keine Daten scannen, berechnet Athena keine Gebühren. Da `EXPLAIN`-Abfragen jedoch AWS Glue aufrufen, um Tabellen-Metadaten abzurufen, können Gebühren von Glue anfallen, wenn die Anrufe das [kostenlose Kontingent für Glue](https://aws.amazon.com/free/?all-free-tier.sort-by=item.additionalFields.SortRank&all-free-tier.sort-order=asc&awsf.Free%20Tier%20Categories=categories%23analytics&all-free-tier.q=glue&all-free-tier.q_operator=AND) überschreiten.
+ Weil `EXPLAIN ANALYZE`-Abfragen ausgeführt werden, scannen sie Daten und Athena berechnet die gescannte Datenmenge.
+ Die in Lake Formation definierten Zeilen- oder Zellenfilterinformationen und die Abfragestatistikinformationen werden in der Ausgabe von `EXPLAIN` und `EXPLAIN ANALYZE` nicht angezeigt.
## EXPLAIN-Syntax
```
EXPLAIN [ ( option [, ...]) ] statement
```
*option* kann einer der folgenden sein:
```
FORMAT { TEXT | GRAPHVIZ | JSON }
TYPE { LOGICAL | DISTRIBUTED | VALIDATE | IO }
```
Wenn die Option `FORMAT` nicht angegeben ist, wird standardmäßig das `TEXT`-Format ausgegeben. Der `IO`-Typ stellt Informationen zu den Tabellen und Schemas bereit, die die Abfrage liest.
## EXPLAIN-ANALYZE-Syntax
Zusätzlich zu der in `EXPLAIN` enthaltenen Ausgabe enthält die `EXPLAIN ANALYZE`-Ausgabe auch Laufzeitstatistiken für die angegebene Abfrage, z. B. die CPU-Auslastung, die Anzahl der Eingabezeilen und die Anzahl der Ausgabezeilen.
```
EXPLAIN ANALYZE [ ( option [, ...]) ] statement
```
*option* kann einer der folgenden sein:
```
FORMAT { TEXT | JSON }
```
Wenn die Option `FORMAT` nicht angegeben ist, wird standardmäßig das `TEXT`-Format ausgegeben. Weil alle Abfragen für `EXPLAIN ANALYZE` `DISTRIBUTED` sind, ist die Option `TYPE` für `EXPLAIN ANALYZE` nicht verfügbar.
*statement* kann einer der folgenden sein:
```
SELECT
CREATE TABLE AS SELECT
INSERT
UNLOAD
```
## EXPLAIN-Beispiele
Die folgenden Beispiele für `EXPLAIN` entwickeln sich von den einfacheren zu den komplexeren Beispielen.
### Beispiel 1: Verwenden Sie die EXPLAIN-Anweisung, um einen Abfrageplan im Textformat anzuzeigen
Das folgende Beispiel `EXPLAIN` zeigt den Ausführungsplan für eine `SELECT`-Abfrage für Elastic-Load-Balancing-Protokolle. Das Format ist standardmäßig die Textausgabe.
```
EXPLAIN
SELECT
request_timestamp,
elb_name,
request_ip
FROM sampledb.elb_logs;
```
#### Ergebnisse
```
- Output[request_timestamp, elb_name, request_ip] => [[request_timestamp, elb_name, request_ip]]
- RemoteExchange[GATHER] => [[request_timestamp, elb_name, request_ip]]
- TableScan[awsdatacatalog:HiveTableHandle{schemaName=sampledb, tableName=elb_logs,
analyzePartitionValues=Optional.empty}] => [[request_timestamp, elb_name, request_ip]]
LAYOUT: sampledb.elb_logs
request_ip := request_ip:string:2:REGULAR
request_timestamp := request_timestamp:string:0:REGULAR
elb_name := elb_name:string:1:REGULAR
```
### Beispiel 2: Verwenden Sie EXPLAIN um einen Abfrageplan grafisch darstellen
Sie können mit der Athena-Konsole einen Abfrageplan grafisch darstellen. Geben Sie eine `SELECT`-Anweisung wie die folgende im Athena-Abfrage-Editor ein und wählen Sie dann **EXPLAIN** (Erklären) aus.
```
SELECT
c.c_custkey,
o.o_orderkey,
o.o_orderstatus
FROM tpch100.customer c
JOIN tpch100.orders o
ON c.c_custkey = o.o_custkey
```
Die **Explain**-Seite des Athena-Abfrage-Editors wird geöffnet und zeigt Ihnen einen verteilten Plan und einen logischen Plan für die Abfrage. Das folgende Diagramm zeigt den logischen Plan für das Beispiel.
![\[Diagramm des vom Athena-Abfrage-Editor gerenderten Abfrageplans.\]](http://docs.aws.amazon.com/de_de/athena/latest/ug/images/athena-explain-statement-tpch.png)
**Wichtig**
Derzeit sind einige Partitionsfilter im verschachtelten Operator-Baumdiagramm möglicherweise nicht sichtbar, obwohl Athena sie auf Ihre Abfrage anwendet. Um die Wirkung solcher Filter zu überprüfen, führen Sie `EXPLAIN` oder `EXPLAIN ANALYZE` auf Ihre Anfrage aus und sehen Sie sich die Ergebnisse an.
Weitere Informationen zur Verwendung der Abfrageplan-Diagrammfeatures in der Athena-Konsole finden Sie unter [Anzeigen von Ausführungsplänen für SQL-Abfragen](query-plans.md).
### Beispiel 3. Verwenden Sie die EXPLAIN-Anweisung, um das Partition Pruning zu überprüfen
Wenn Sie ein Filterprädikat für einen partitionierten Schlüssel verwenden, um eine partitionierte Tabelle abzufragen, wendet das Abfragemodul das Prädikat auf den partitionierten Schlüssel an, um die Menge der gelesenen Daten zu reduzieren.
Im folgenden Beispiel wird eine `EXPLAIN`-Abfrage verwendet, um die Partitionsbereinigung für eine `SELECT`-Abfrage in einer partitionierten Tabelle zu überprüfen. Zuerst erstellt eine `CREATE TABLE`-Anweisung die `tpch100.orders_partitioned`-Tabelle. Die Tabelle ist nach Spalte `o_orderdate` partitioniert.
```
CREATE TABLE `tpch100.orders_partitioned`(
`o_orderkey` int,
`o_custkey` int,
`o_orderstatus` string,
`o_totalprice` double,
`o_orderpriority` string,
`o_clerk` string,
`o_shippriority` int,
`o_comment` string)
PARTITIONED BY (
`o_orderdate` 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//'
```
Die `tpch100.orders_partitioned`-Tabelle hat mehrere Partitionen auf `o_orderdate`, wie der Befehl `SHOW PARTITIONS` zeigt.
```
SHOW PARTITIONS tpch100.orders_partitioned;
o_orderdate=1994
o_orderdate=2015
o_orderdate=1998
o_orderdate=1995
o_orderdate=1993
o_orderdate=1997
o_orderdate=1992
o_orderdate=1996
```
Die folgende `EXPLAIN`-Abfrage überprüft die Partitionsbereinigung für die angegebene `SELECT`-Anweisung.
```
EXPLAIN
SELECT
o_orderkey,
o_custkey,
o_orderdate
FROM tpch100.orders_partitioned
WHERE o_orderdate = '1995'
```
#### Ergebnisse
```
Query Plan
- Output[o_orderkey, o_custkey, o_orderdate] => [[o_orderkey, o_custkey, o_orderdate]]
- RemoteExchange[GATHER] => [[o_orderkey, o_custkey, o_orderdate]]
- TableScan[awsdatacatalog:HiveTableHandle{schemaName=tpch100, tableName=orders_partitioned,
analyzePartitionValues=Optional.empty}] => [[o_orderkey, o_custkey, o_orderdate]]
LAYOUT: tpch100.orders_partitioned
o_orderdate := o_orderdate:string:-1:PARTITION_KEY
:: [[1995]]
o_custkey := o_custkey:int:1:REGULAR
o_orderkey := o_orderkey:int:0:REGULAR
```
Der fett gedruckte Text im Ergebnis zeigt, dass das Prädikat `o_orderdate = '1995'` auf den `PARTITION_KEY` angewendet wurde.
### Beispiel 4. Verwenden Sie eine EXPLAIN-Abfrage, um die Join-Reihenfolge und den Join-Typ zu überprüfen
Die folgende `EXPLAIN`-Abfrage überprüft die Join-Reihenfolge und den Join-Typ der `SELECT`-Anweisung. Verwenden Sie eine Abfrage wie diese, um die Speicherauslastung der Abfrage zu untersuchen, um die Wahrscheinlichkeit eines `EXCEEDED_LOCAL_MEMORY_LIMIT`-Fehlers zu verringern.
```
EXPLAIN (TYPE DISTRIBUTED)
SELECT
c.c_custkey,
o.o_orderkey,
o.o_orderstatus
FROM tpch100.customer c
JOIN tpch100.orders o
ON c.c_custkey = o.o_custkey
WHERE c.c_custkey = 123
```
#### Ergebnisse
```
Query Plan
Fragment 0 [SINGLE]
Output layout: [c_custkey, o_orderkey, o_orderstatus]
Output partitioning: SINGLE []
Stage Execution Strategy: UNGROUPED_EXECUTION
- Output[c_custkey, o_orderkey, o_orderstatus] => [[c_custkey, o_orderkey, o_orderstatus]]
- RemoteSource[1] => [[c_custkey, o_orderstatus, o_orderkey]]
Fragment 1 [SOURCE]
Output layout: [c_custkey, o_orderstatus, o_orderkey]
Output partitioning: SINGLE []
Stage Execution Strategy: UNGROUPED_EXECUTION
- CrossJoin => [[c_custkey, o_orderstatus, o_orderkey]]
Distribution: REPLICATED
- ScanFilter[table = awsdatacatalog:HiveTableHandle{schemaName=tpch100,
tableName=customer, analyzePartitionValues=Optional.empty}, grouped = false,
filterPredicate = ("c_custkey" = 123)] => [[c_custkey]]
LAYOUT: tpch100.customer
c_custkey := c_custkey:int:0:REGULAR
- LocalExchange[SINGLE] () => [[o_orderstatus, o_orderkey]]
- RemoteSource[2] => [[o_orderstatus, o_orderkey]]
Fragment 2 [SOURCE]
Output layout: [o_orderstatus, o_orderkey]
Output partitioning: BROADCAST []
Stage Execution Strategy: UNGROUPED_EXECUTION
- ScanFilterProject[table = awsdatacatalog:HiveTableHandle{schemaName=tpch100,
tableName=orders, analyzePartitionValues=Optional.empty}, grouped = false,
filterPredicate = ("o_custkey" = 123)] => [[o_orderstatus, o_orderkey]]
LAYOUT: tpch100.orders
o_orderstatus := o_orderstatus:string:2:REGULAR
o_custkey := o_custkey:int:1:REGULAR
o_orderkey := o_orderkey:int:0:REGULAR
```
Die Beispielabfrage wurde für eine bessere Leistung zu einem Cross-Join optimiert. Die Ergebnisse zeigen, dass `tpch100.orders` als `BROADCAST`-Verteilungstyp verteilt wird. Dies impliziert, dass die `tpch100.orders`-Tabelle an alle Knoten verteilt wird, die den Join-Vorgang ausführen. Der `BROADCAST`-Verteilungstyp erfordert, dass alle gefilterten Ergebnisse der `tpch100.orders`-Tabelle in den Speicher jedes Knotens passen, der die Join-Operation ausführt.
Die `tpch100.customer`-Tabelle ist jedoch kleiner als `tpch100.orders`. Da `tpch100.customer` weniger Speicher benötigt, können Sie die Abfrage in `BROADCAST tpch100.customer` statt in `tpch100.orders` umschreiben. Dies verringert die Wahrscheinlichkeit, dass die Abfrage den `EXCEEDED_LOCAL_MEMORY_LIMIT`-Fehler erhält. Diese Strategie setzt folgende Punkte voraus:
+ Das `tpch100.customer.c_custkey` ist in der `tpch100.customer`-Tabelle eindeutig.
+ Es besteht eine one-to-many Mapping-Beziehung zwischen `tpch100.customer` und`tpch100.orders`.
Im folgenden Beispiel wird die neu geschriebene Abfrage dargestellt.
```
SELECT
c.c_custkey,
o.o_orderkey,
o.o_orderstatus
FROM tpch100.orders o
JOIN tpch100.customer c -- the filtered results of tpch100.customer are distributed to all nodes.
ON c.c_custkey = o.o_custkey
WHERE c.c_custkey = 123
```
### Beispiel 5: Verwenden Sie eine EXPLAIN-Abfrage zum Entfernen von Prädikaten, die keine Auswirkungen haben
Sie können eine `EXPLAIN`-Abfrage verwenden, um die Wirksamkeit des Filterns von Prädikaten zu überprüfen. Sie können die Ergebnisse verwenden, um Prädikate zu entfernen, die keine Auswirkung haben, wie im folgenden Beispiel.
```
EXPLAIN
SELECT
c.c_name
FROM tpch100.customer c
WHERE c.c_custkey = CAST(RANDOM() * 1000 AS INT)
AND c.c_custkey BETWEEN 1000 AND 2000
AND c.c_custkey = 1500
```
#### Ergebnisse
```
Query Plan
- Output[c_name] => [[c_name]]
- RemoteExchange[GATHER] => [[c_name]]
- ScanFilterProject[table =
awsdatacatalog:HiveTableHandle{schemaName=tpch100,
tableName=customer, analyzePartitionValues=Optional.empty},
filterPredicate = (("c_custkey" = 1500) AND ("c_custkey" =
CAST(("random"() * 1E3) AS int)))] => [[c_name]]
LAYOUT: tpch100.customer
c_custkey := c_custkey:int:0:REGULAR
c_name := c_name:string:1:REGULAR
```
Das `filterPredicate` in den Ergebnissen zeigt, dass der Optimierer die ursprünglichen drei Prädikate zu zwei Prädikaten zusammengeführt und ihre Anwendungsreihenfolge geändert hat.
```
filterPredicate = (("c_custkey" = 1500) AND ("c_custkey" = CAST(("random"() * 1E3) AS int)))
```
Da die Ergebnisse zeigen, dass das Prädikat `AND c.c_custkey BETWEEN 1000 AND 2000` keine Auswirkung hat, können Sie dieses Prädikat entfernen, ohne die Abfrageergebnisse zu ändern.
Informationen zu den in den Ergebnissen von `EXPLAIN`-Abfragen verwendeten Begriffen finden Sie unter [Die Ergebnisse der Athena-EXPLAIN-Anweisung verstehen](athena-explain-statement-understanding.md).
## EXPLAIN-ANALYZE-Beispiele
In den nachstehenden Beispielen wird ein Beispiel für `EXPLAIN ANALYZE`-Abfragen und Ausgaben gezeigt.
### Beispiel 1. Verwenden Sie EXPLAIN ANALYZE, um einen Abfrageplan und Rechenkosten im Textformat anzuzeigen
Das folgende Beispiel `EXPLAIN ANALYZE` zeigt den Ausführungsplan und die Rechenkosten für eine `SELECT` Abfrage von CloudFront Protokollen. Das Format ist standardmäßig die Textausgabe.
```
EXPLAIN ANALYZE SELECT FROM cloudfront_logs LIMIT 10
```
#### Ergebnisse
```
Fragment 1
CPU: 24.60ms, Input: 10 rows (1.48kB); per task: std.dev.: 0.00, Output: 10 rows (1.48kB)
Output layout: [date, time, location, bytes, requestip, method, host, uri, status, referrer,\
os, browser, browserversion]
Limit[10] => [[date, time, location, bytes, requestip, method, host, uri, status, referrer, os,\
browser, browserversion]]
CPU: 1.00ms (0.03%), Output: 10 rows (1.48kB)
Input avg.: 10.00 rows, Input std.dev.: 0.00%
LocalExchange[SINGLE] () => [[date, time, location, bytes, requestip, method, host, uri, status, referrer, os,\
browser, browserversion]]
CPU: 0.00ns (0.00%), Output: 10 rows (1.48kB)
Input avg.: 0.63 rows, Input std.dev.: 387.30%
RemoteSource[2] => [[date, time, location, bytes, requestip, method, host, uri, status, referrer, os,\
browser, browserversion]]
CPU: 1.00ms (0.03%), Output: 10 rows (1.48kB)
Input avg.: 0.63 rows, Input std.dev.: 387.30%
Fragment 2
CPU: 3.83s, Input: 998 rows (147.21kB); per task: std.dev.: 0.00, Output: 20 rows (2.95kB)
Output layout: [date, time, location, bytes, requestip, method, host, uri, status, referrer, os,\
browser, browserversion]
LimitPartial[10] => [[date, time, location, bytes, requestip, method, host, uri, status, referrer, os,\
browser, browserversion]]
CPU: 5.00ms (0.13%), Output: 20 rows (2.95kB)
Input avg.: 166.33 rows, Input std.dev.: 141.42%
TableScan[awsdatacatalog:HiveTableHandle{schemaName=default, tableName=cloudfront_logs,\
analyzePartitionValues=Optional.empty},
grouped = false] => [[date, time, location, bytes, requestip, method, host, uri, st
CPU: 3.82s (99.82%), Output: 998 rows (147.21kB)
Input avg.: 166.33 rows, Input std.dev.: 141.42%
LAYOUT: default.cloudfront_logs
date := date:date:0:REGULAR
referrer := referrer:string:9:REGULAR
os := os:string:10:REGULAR
method := method:string:5:REGULAR
bytes := bytes:int:3:REGULAR
browser := browser:string:11:REGULAR
host := host:string:6:REGULAR
requestip := requestip:string:4:REGULAR
location := location:string:2:REGULAR
time := time:string:1:REGULAR
uri := uri:string:7:REGULAR
browserversion := browserversion:string:12:REGULAR
status := status:int:8:REGULAR
```
### Beispiel 2. Verwenden Sie EXPLAIN ANALYZE, um einen Abfrageplan im JSON-Format anzuzeigen
Das folgende Beispiel zeigt den Ausführungsplan und die Rechenkosten für eine `SELECT` CloudFront Protokollabfrage. Im Beispiel wird JSON als Ausgabeformat angegeben.
```
EXPLAIN ANALYZE (FORMAT JSON) SELECT * FROM cloudfront_logs LIMIT 10
```
#### Ergebnisse
```
{
"fragments": [{
"id": "1",
"stageStats": {
"totalCpuTime": "3.31ms",
"inputRows": "10 rows",
"inputDataSize": "1514B",
"stdDevInputRows": "0.00",
"outputRows": "10 rows",
"outputDataSize": "1514B"
},
"outputLayout": "date, time, location, bytes, requestip, method, host,\
uri, status, referrer, os, browser, browserversion",
"logicalPlan": {
"1": [{
"name": "Limit",
"identifier": "[10]",
"outputs": ["date", "time", "location", "bytes", "requestip", "method", "host",\
"uri", "status", "referrer", "os", "browser", "browserversion"],
"details": "",
"distributedNodeStats": {
"nodeCpuTime": "0.00ns",
"nodeOutputRows": 10,
"nodeOutputDataSize": "1514B",
"operatorInputRowsStats": [{
"nodeInputRows": 10.0,
"nodeInputRowsStdDev": 0.0
}]
},
"children": [{
"name": "LocalExchange",
"identifier": "[SINGLE] ()",
"outputs": ["date", "time", "location", "bytes", "requestip", "method", "host",\
"uri", "status", "referrer", "os", "browser", "browserversion"],
"details": "",
"distributedNodeStats": {
"nodeCpuTime": "0.00ns",
"nodeOutputRows": 10,
"nodeOutputDataSize": "1514B",
"operatorInputRowsStats": [{
"nodeInputRows": 0.625,
"nodeInputRowsStdDev": 387.2983346207417
}]
},
"children": [{
"name": "RemoteSource",
"identifier": "[2]",
"outputs": ["date", "time", "location", "bytes", "requestip", "method", "host",\
"uri", "status", "referrer", "os", "browser", "browserversion"],
"details": "",
"distributedNodeStats": {
"nodeCpuTime": "0.00ns",
"nodeOutputRows": 10,
"nodeOutputDataSize": "1514B",
"operatorInputRowsStats": [{
"nodeInputRows": 0.625,
"nodeInputRowsStdDev": 387.2983346207417
}]
},
"children": []
}]
}]
}]
}
}, {
"id": "2",
"stageStats": {
"totalCpuTime": "1.62s",
"inputRows": "500 rows",
"inputDataSize": "75564B",
"stdDevInputRows": "0.00",
"outputRows": "10 rows",
"outputDataSize": "1514B"
},
"outputLayout": "date, time, location, bytes, requestip, method, host, uri, status,\
referrer, os, browser, browserversion",
"logicalPlan": {
"1": [{
"name": "LimitPartial",
"identifier": "[10]",
"outputs": ["date", "time", "location", "bytes", "requestip", "method", "host", "uri",\
"status", "referrer", "os", "browser", "browserversion"],
"details": "",
"distributedNodeStats": {
"nodeCpuTime": "0.00ns",
"nodeOutputRows": 10,
"nodeOutputDataSize": "1514B",
"operatorInputRowsStats": [{
"nodeInputRows": 83.33333333333333,
"nodeInputRowsStdDev": 223.60679774997897
}]
},
"children": [{
"name": "TableScan",
"identifier": "[awsdatacatalog:HiveTableHandle{schemaName=default,\
tableName=cloudfront_logs, analyzePartitionValues=Optional.empty},\
grouped = false]",
"outputs": ["date", "time", "location", "bytes", "requestip", "method", "host", "uri",\
"status", "referrer", "os", "browser", "browserversion"],
"details": "LAYOUT: default.cloudfront_logs\ndate := date:date:0:REGULAR\nreferrer :=\
referrer: string:9:REGULAR\nos := os:string:10:REGULAR\nmethod := method:string:5:\
REGULAR\nbytes := bytes:int:3:REGULAR\nbrowser := browser:string:11:REGULAR\nhost :=\
host:string:6:REGULAR\nrequestip := requestip:string:4:REGULAR\nlocation :=\
location:string:2:REGULAR\ntime := time:string:1: REGULAR\nuri := uri:string:7:\
REGULAR\nbrowserversion := browserversion:string:12:REGULAR\nstatus :=\
status:int:8:REGULAR\n",
"distributedNodeStats": {
"nodeCpuTime": "1.62s",
"nodeOutputRows": 500,
"nodeOutputDataSize": "75564B",
"operatorInputRowsStats": [{
"nodeInputRows": 83.33333333333333,
"nodeInputRowsStdDev": 223.60679774997897
}]
},
"children": []
}]
}]
}
}]
}
```
## Weitere Ressourcen
Weitere Informationen finden Sie in den folgenden Ressourcen.
+ [Die Ergebnisse der Athena-EXPLAIN-Anweisung verstehen](athena-explain-statement-understanding.md)
+ [Anzeigen von Ausführungsplänen für SQL-Abfragen](query-plans.md)
+ [Anzeigen von Statistiken und Ausführungsdetails für abgeschlossene Abfragen](query-stats.md)
+ Trino-Dokumentation [https://trino.io/docs/current/sql/explain.html](https://trino.io/docs/current/sql/explain.html)
+ Trino-Dokumentation [https://trino.io/docs/current/sql/explain-analyze.html](https://trino.io/docs/current/sql/explain-analyze.html)
+ [Optimieren Sie die Leistung von Verbundabfragen mit EXPLAIN und EXPLAIN ANALYZE in Amazon Athena](https://aws.amazon.com/blogs/big-data/optimize-federated-query-performance-using-explain-and-explain-analyze-in-amazon-athena/) im *AWS -Big-Data-Blog*.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/7JUyTqglmNU)
# Die Ergebnisse der Athena-EXPLAIN-Anweisung verstehen
Dieses Thema bietet eine kurze Anleitung zu den operativen Begriffen, die in den Athena-`EXPLAIN`-Anweisungsergebnissen verwendet werden.
## EXPLAIN-Anweisungs-Ausgabetypen
`EXPLAIN`-Ausgabetypen können zwei Typen haben:
+ **Logischer Plan** – Zeigt den logischen Plan an, den die SQL-Engine zum Ausführen einer Anweisung verwendet. Die Syntax für diese Option lautet `EXPLAIN` oder `EXPLAIN (TYPE LOGICAL)`.
+ **Verteilter Plan** – Zeigt einen Ausführungsplan in einer verteilten Umgebung an. Die Ausgabe zeigt Fragmente, die Verarbeitungsschritte sind. Jedes Planfragment wird von einem oder mehreren Knoten verarbeitet. Daten können zwischen den Knoten ausgetauscht werden, die die Fragmente verarbeiten. Die Syntax für diese Option lautet `EXPLAIN (TYPE DISTRIBUTED)`
In der Ausgabe für einen verteilten Plan werden Fragmente (Verarbeitungsphasen) durch `Fragment` *number* [*fragment\$1type*] gekennzeichnet, wobei *number* es sich um eine auf Null basierende Ganzzahl handelt, die *fragment\$1type* angibt, wie das Fragment von den Knoten ausgeführt wird. Die Fragmenttypen, die Einblicke in das Layout des Datenaustauschs geben, werden in der folgenden Tabelle beschrieben.
**Fragment-Typen für verteilte Pläne**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/athena/latest/ug/athena-explain-statement-understanding.html)
## Exchange
Die austauschbezogenen Begriffe beschreiben, wie Daten zwischen Worker-Knoten ausgetauscht werden. Übertragungen können entweder lokal oder remote erfolgen.
**LocalExchange [*exchange\$1type*] **
Überträgt Daten lokal innerhalb von Worker-Knoten für verschiedene Phasen einer Abfrage. Der Wert für *exchange\$1type* kann einer der logischen oder verteilten Austauschtypen sein, wie weiter unten in diesem Abschnitt beschrieben.
**RemoteExchange [*exchange\$1type*] **
Überträgt Daten zwischen Worker-Knoten für verschiedene Phasen einer Abfrage. Der Wert für *exchange\$1type* kann einer der logischen oder verteilten Austauschtypen sein, wie weiter unten in diesem Abschnitt beschrieben.
### Logische Austausch-Typen
Die folgenden Austausch-Typen beschreiben Aktionen, die während der Austauschphase eines logischen Plans durchgeführt wurden.
+ **`GATHER`** – Ein einzelner Worker-Knoten sammelt die Ausgabe von allen anderen Worker-Knoten. Beispielsweise sammelt die letzte Stufe einer Auswahlabfrage Ergebnisse von allen Knoten und schreibt die Ergebnisse in Amazon S3.
+ **`REPARTITION`** – Sendet die Zeilendaten an einen bestimmten Worker basierend auf dem Partitionierungsschema, das für den nächsten Operator erforderlich ist.
+ **`REPLICATE`** – Kopiert die Zeilendaten in alle Worker.
### Verteilte Austausch-Typen
Die folgenden Austauschtypen geben das Layout der Daten an, wenn sie zwischen Knoten in einem verteilten Plan ausgetauscht werden.
+ **`HASH`** – Der Austausch verteilt Daten an mehrere Ziele mithilfe einer Hash-Funktion.
+ **`SINGLE`** – Der Austausch verteilt Daten an ein einzelnes Ziel.
## Scanning
Die folgenden Bedingungen beschreiben, wie Daten während einer Abfrage gescannt werden.
**TableScan **
Scannt die Quelldaten einer Tabelle von Amazon S3 oder einem Apache-Hive-Connector und wendet die aus dem Filterprädikat generierte Partitionsbereinigung an.
**ScanFilter **
Scannt die Quelldaten einer Tabelle von Amazon S3 oder einem Hive-Connector und wendet die Partitionsbereinigung an, die aus dem Filterprädikat und aus zusätzlichen Filterprädikaten generiert wurde, die nicht durch die Partitionsbereinigung angewendet wurden.
**ScanFilterProject **
Scannt zunächst die Quelldaten einer Tabelle von Amazon S3 oder einem Hive-Connector und wendet die Partitionsbereinigung an, die aus dem Filterprädikat und aus zusätzlichen Filterprädikaten generiert wurde, die nicht durch die Partitionsbereinigung angewendet wurden. Ändert dann das Speicherlayout der Ausgabedaten in eine neue Projektion, um die Leistung späterer Phasen zu verbessern.
## Join
Verknüpft Daten zwischen zwei Tabellen. Verknüpfungen können nach Verknüpfungstyp und nach Verteilungstyp kategorisiert werden.
### JOIN-Typen
Verknüpfungstypen definieren die Art und Weise, in der der Join-Vorgang ausgeführt wird.
**CrossJoin**— Erzeugt das kartesische Produkt der beiden verbundenen Tabellen.
**InnerJoin**— Wählt Datensätze mit übereinstimmenden Werten in beiden Tabellen aus.
**LeftJoin**— Wählt alle Datensätze aus der linken Tabelle und die passenden Datensätze aus der rechten Tabelle aus. Wenn keine Übereinstimmung auftritt, ist das Ergebnis auf der rechten Seite NULL.
**RightJoin**— Wählt alle Datensätze aus der rechten Tabelle und die passenden Datensätze aus der linken Tabelle aus. Wenn keine Übereinstimmung auftritt, ist das Ergebnis auf der linken Seite NULL.
**FullJoin**— Wählt alle Datensätze aus, bei denen es eine Übereinstimmung in den linken oder rechten Tabellendatensätzen gibt. Die verknüpfte Tabelle enthält alle Datensätze aus beiden Tabellen und füllt fehlende Treffer auf beiden Seiten aus. NULLs
**Anmerkung**
Aus Leistungsgründen kann das Abfragemodul eine Join-Abfrage in einen anderen Join-Typ umschreiben, um dieselben Ergebnisse zu erzielen. Beispielsweise kann eine Inner-Join-Abfrage mit einem Prädikat für eine Tabelle in ein `CrossJoin` umgeschrieben werden. Dadurch wird das Prädikat in die Scanphase der Tabelle verschoben, sodass weniger Daten gescannt werden.
### Join-Verteilungs-Typen
Verteilungstypen definieren, wie Daten zwischen Worker-Knoten ausgetauscht werden, wenn der Join-Vorgang ausgeführt wird.
**Partitioniert** – Sowohl die linke als auch die rechte Tabelle sind über alle Worker-Knoten hinweg hashpartitioniert. Partitionierte Verteilung verbraucht weniger Speicher in jedem Knoten. Partitionierte Verteilung kann viel langsamer sein als replizierte Joins. Partitionierte Joins eignen sich, wenn Sie zwei große Tabellen verbinden.
**Repliziert** – Eine Tabelle wird über alle Worker-Knoten hinweg hashpartitioniert, und die andere Tabelle wird auf alle Worker-Knoten repliziert, um den Join-Vorgang auszuführen. Die replizierte Verteilung kann viel schneller sein als partitionierte Joins, verbraucht jedoch mehr Speicher in jedem Worker-Knoten. Wenn die replizierte Tabelle zu groß ist, kann es im Worker-Knoten zu einem out-of-memory Fehler kommen. Replizierte Joins sind geeignet, wenn eine der verknüpften Tabellen klein ist.
# PREPARE
Erstellt eine SQL-Anweisung mit dem Namen `statement_name`, die zu einem späteren Zeitpunkt ausgeführt werden soll. Die Anweisung kann Parameter enthalten, die durch Fragezeichen dargestellt werden. Um Werte für die Parameter bereitzustellen und die vorbereitete Anweisung auszuführen, verwenden Sie [EXECUTE](sql-execute.md).
## Syntax
```
PREPARE statement_name FROM statement
```
Die folgende Tabelle beschreibt diese Parameter.
****
| Parameter | Description |
| --- | --- |
| statement\$1name | Der Name der zu erstellenden Anweisung. Der Name muss innerhalb der Arbeitsgruppe eindeutig sein. |
| statement | SELECT-, CTAS- oder INSERT INTO-Abfrage. |
**Anmerkung**
Die maximale Anzahl von vorbereiteten Anweisungen in einer Arbeitsgruppe liegt bei 1 000.
## Beispiele
Das folgende Beispiel bereitet eine ausgewählte Abfrage ohne Parameter vor.
```
PREPARE my_select1 FROM
SELECT * FROM nation
```
Das folgende Beispiel bereitet eine ausgewählte Abfrage mit Parametern vor. Die Werte für `productid` und `quantity` werden von der `USING`-Klausel einer `EXECUTE`-Aussage bereitgestellt:
```
PREPARE my_select2 FROM
SELECT order FROM orders WHERE productid = ? and quantity < ?
```
Im folgenden Beispiel wird eine Einfügeabfrage vorbereitet.
```
PREPARE my_insert FROM
INSERT INTO cities_usa (city, state)
SELECT city, state
FROM cities_world
WHERE country = ?
```
## Weitere Ressourcen
[Vorbereitete Anweisungen verwenden](querying-with-prepared-statements-querying.md)
[EXECUTE](sql-execute.md)
[DEALLOCATE PREPARE](sql-deallocate-prepare.md)
[INSERT INTO](insert-into.md)
# EXECUTE
Führt eine vorbereitete Anweisung mit dem Namen `statement_name` aus. Parameterwerte für die Fragezeichen in der vorbereiteten Anweisung sind in der`USING`-Klausel in einer kommagetrennten Liste definiert. Um eine vorbereitete Anweisung zu erstellen, verwenden Sie [PREPARE](sql-prepare.md).
## Syntax
```
EXECUTE statement_name [ USING parameter1[, parameter2, ... ] ]
```
## Beispiele
Das folgende Beispiel bereitet eine Abfrage ohne Parameter vor und führt sie aus.
```
PREPARE my_select1 FROM
SELECT name FROM nation
EXECUTE my_select1
```
Das folgende Beispiel bereitet eine Abfrage mit einem einzigen Parameter vor und führt sie aus.
```
PREPARE my_select2 FROM
SELECT * FROM "my_database"."my_table" WHERE year = ?
EXECUTE my_select2 USING 2012
```
Dies entspricht:
```
SELECT * FROM "my_database"."my_table" WHERE year = 2012
```
Das folgende Beispiel bereitet eine Abfrage mit zwei Parametern vor und führt sie aus.
```
PREPARE my_select3 FROM
SELECT order FROM orders WHERE productid = ? and quantity < ?
EXECUTE my_select3 USING 346078, 12
```
## Weitere Ressourcen
[Vorbereitete Anweisungen verwenden](querying-with-prepared-statements-querying.md)
[PREPARE](sql-prepare.md)
[INSERT INTO](insert-into.md)
# DEALLOCATE PREPARE
Entfernt die vorbereitete Anweisung mit dem angegebenen Namen aus den vorbereiteten Anweisungen in der aktuellen Arbeitsgruppe.
## Syntax
```
DEALLOCATE PREPARE statement_name
```
## Beispiele
Im folgenden Beispiel wird die vorbereitete Anweisung `my_select1` aus der aktuellen Arbeitsgruppe entfernt.
```
DEALLOCATE PREPARE my_select1
```
## Weitere Ressourcen
[Vorbereitete Anweisungen verwenden](querying-with-prepared-statements-querying.md)
[PREPARE](sql-prepare.md)
# UNLOAD
Schreibt Abfrageergebnisse aus einer `SELECT`-Anweisung in das angegebene Datenformat. Zu den unterstützten Formaten für `UNLOAD` gehören Apache Parquet, ORC, Apache Avro und JSON. CSV ist das einzige Ausgabeformat, das vom dem Athena `SELECT`-Befehl unterstützt wird, aber Sie können den `UNLOAD`-Befehl, der eine Vielzahl von Ausgabeformaten unterstützt, verwenden, um Ihre `SELECT`-Abfrage einzuschließen und ihre Ausgabe in eines der Formate die `UNLOAD` unterstützt umzuschreiben.
Obwohl Sie die `CREATE TABLE AS`-(CTAS)-Anweisung verwenden können, um Daten in anderen Formaten als CSV auszugeben, erfordern CTAS-Anweisungen die Erstellung einer Tabelle in Athena. Die `UNLOAD`-Anweisung ist nützlich, wenn Sie die Ergebnisse einer `SELECT`-Abfrage in einem Nicht-CSV-Format ausgeben möchten, aber die zugehörige Tabelle nicht benötigen. Beispielsweise kann eine nachgelagerte Anwendung erfordern, dass die Ergebnisse einer `SELECT`-Abfrage im JSON-Format vorliegen, und Parquet oder ORC können einen Leistungsvorteil gegenüber CSV bieten, wenn Sie die Ergebnisse der `SELECT`-Abfrage für zusätzliche Analysen verwenden möchten.
## Überlegungen und Einschränkungen
Beachten Sie bei der Verwendung der `UNLOAD`-Anweisung in Athena die folgenden Punkte:
+ **Keine globale Reihenfolge von Dateien** – `UNLOAD`-Ergebnisse werden parallel in mehrere Dateien geschrieben. Wenn die `SELECT`-Abfrage in der `UNLOAD`-Anweisung eine Sortierreihenfolge angibt, wird der Inhalt jeder Datei sortiert, aber die Dateien werden nicht relativ zueinander sortiert.
+ **Verwaiste Daten nicht gelöscht** – Im Falle eines Fehlers versucht Athena nicht, verwaiste Daten zu löschen. Dieses Verhalten ist das gleiche wie bei CTAS und `INSERT INTO`-Anweisungen.
+ **Maximale Partitionen** – Die maximale Anzahl von Partitionen, die mit `UNLOAD` verwendet werden können, beträgt 100.
+ **Metadaten- und Manifestdateien**– Athena generiert für jede `UNLOAD`-Abfrage eine Metadatendatei und eine Datenmanifestdatei. Das Manifest verfolgt die Dateien, die die Abfrage geschrieben hat. Beide Dateien werden in Ihrem Athena-Abfrageergebnisspeicherort in Amazon S3 gespeichert. Weitere Informationen finden Sie unter [Identifizieren von Abfrageausgabedateien](querying-finding-output-files.md#querying-identifying-output-files).
+ **Verschlüsselung** – `UNLOAD`-Ausgabedateien werden gemäß der für Amazon S3 verwendeten Verschlüsselungskonfiguration verschlüsselt. Um die Verschlüsselungskonfiguration für die Verschlüsselung Ihres `UNLOAD` Ergebnisses einzurichten, können Sie die [EncryptionConfiguration API](https://docs.aws.amazon.com/athena/latest/APIReference/API_EncryptionConfiguration.html) verwenden.
+ **Vorbereitete Anweisungen** – `UNLOAD`kann mit vorbereiteten Anweisungen verwendet werden. Informationen zu vorbereiteten Anweisungen in Athena finden Sie unter [Parametrisierte Abfragen verwenden](querying-with-prepared-statements.md).
+ **Service Quotas** – `UNLOAD` verwendet DML-Abfragekontingente. Kontigentinformationen finden Sie unter [Service Quotas](service-limits.md).
+ **Erwarteter Bucket-Eigentümer** – Die Einstellung für den erwarteten Bucket-Eigentümer gilt nicht für den Amazon-S3-Speicherort, der in der `UNLOAD`-Abfrage angegeben wurde. 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).
## Syntax
Die `UNLOAD`-Anweisung verwendet die folgende Syntax.
```
UNLOAD (SELECT col_name[, ...] FROM old_table)
TO 's3://amzn-s3-demo-bucket/my_folder/'
WITH ( property_name = 'expression' [, ...] )
```
Außer beim Schreiben auf Partitionen, muss das `TO`-Ziel einen Standort in Amazon S3 angeben, der keine Daten enthält. Bevor die `UNLOAD`-Abfrage in den angegebenen Speicherort schreibt, überprüft sie, ob der Bucket-Speicherort leer ist. Da `UNLOAD` keine Daten an den angegebenen Speicherort schreibt, wenn der Speicherort bereits Daten enthält, überschreibt `UNLOAD` keine vorhandenen Daten. Um einen Bucket-Speicherort als Ziel für `UNLOAD` wiederzuverwenden, löschen Sie die Daten am Bucket-Speicherort und führen Sie die Abfrage dann erneut aus.
Beachten Sie, dass dieses Verhalten anders ist, wenn `UNLOAD` in Partitionen schreibt. Wenn Sie dieselbe `UNLOAD`-Abfrage mehrmals ausführen, die dieselbe `SELECT`-Anweisung, denselben `TO`-Speicherort und dieselben Partitionen hat, entlädt jede `UNLOAD`-Abfrage die Daten an dem angegebenen Speicherort und den angegebenen Partitionen in Amazon S3.
### Parameters
Die möglichen Werte für *property\$1name* sind wie folgt.
** format = '' *file\$1format* **
Erforderlich Gibt das Dateiformat der Ausgabe an. Mögliche Werte für *file\$1format* sind `ORC``PARQUET`,`AVRO`,`JSON`, oder`TEXTFILE`.
** Komprimierung = '*compression\$1format*' **
Optional. Diese Option ist spezifisch für die Formate ORC und Parquet. Für ORC ist der Standardwert `zlib` und für Parquet der Standardwert `gzip`. Informationen über unterstützte Komprimierungsformate finden Sie unter [Unterstützung der Athena-Komprimierung](https://docs.aws.amazon.com/athena/latest/ug/compression-formats.html).
Diese Option gilt nicht für das Format `AVRO`. Athena verwendet `gzip` für `JSON`- und `TEXTFILE`-Formate.
**Kompressionsstufe = *compression\$1level* **
Optional. Die Komprimierungsstufe, die für die ZSTD-Komprimierung verwendet werden soll. Diese Eigenschaft gilt nur für die ZSTD-Komprimierung. Weitere Informationen finden Sie unter [ZSTD-Komprimierungsstufen verwenden](compression-support-zstd-levels.md).
** Feldtrennzeichen = '' *delimiter* **
Optional. Gibt ein Feldtrennzeichen aus einem einzigen Zeichen für Dateien in CSV, TSV und anderen Textformaten an. Das folgende Beispiel verwendet ein Komma als Trennzeichen:
```
WITH (field_delimiter = ',')
```
Derzeit werden mehrzeilige Feldtrennzeichen nicht unterstützt. Wenn Sie kein Feldtrennzeichen angeben, wird das Oktalzeichen `\001` (^A) verwendet.
** partitioniert\$1nach = ARRAY [[,...]] *col\$1name* **
Optional. Eine Array-Liste der Spalten, nach denen die Ausgabe partitioniert ist.
Stellen Sie in Ihrer `SELECT`-Anweisung sicher, dass die Namen der partitionierten Spalten in Ihrer Spaltenliste an letzter Stelle stehen.
## Beispiele
Im folgenden Beispiel wird die Ausgabe einer `SELECT`-Abfrage im JSON-Format an den Amazon-S3-Speicherort `s3://amzn-s3-demo-bucket/unload_test_1/` geschrieben.
```
UNLOAD (SELECT * FROM old_table)
TO 's3://amzn-s3-demo-bucket/unload_test_1/'
WITH (format = 'JSON')
```
Im folgenden Beispiel wird die Ausgabe einer `SELECT`-Abfrage im Parquet-Format mithilfe der Snappy-Komprimierung geschrieben.
```
UNLOAD (SELECT * FROM old_table)
TO 's3://amzn-s3-demo-bucket/'
WITH (format = 'PARQUET',compression = 'SNAPPY')
```
Im folgenden Beispiel werden vier Spalten im Textformat geschrieben, wobei die Ausgabe durch die letzte Spalte partitioniert ist.
```
UNLOAD (SELECT name1, address1, comment1, key1 FROM table1)
TO 's3://amzn-s3-demo-bucket/ partitioned/'
WITH (format = 'TEXTFILE', partitioned_by = ARRAY['key1'])
```
Im folgenden Beispiel werden die Abfrageergebnisse unter Verwendung des Parquet-Dateiformats, der ZSTD-Komprimierung und der ZSTD-Komprimierungsstufe 4 an den angegebenen Speicherort entladen.
```
UNLOAD (SELECT * FROM old_table)
TO 's3://amzn-s3-demo-bucket/'
WITH (format = 'PARQUET', compression = 'ZSTD', compression_level = 4)
```
## Weitere Ressourcen
+ [Vereinfachen Sie Ihre ETL- und ML-Pipelines mithilfe des Amazon Athena UNLOAD-Features](https://aws.amazon.com/blogs/big-data/simplify-your-etl-and-ml-pipelines-using-the-amazon-athena-unload-feature/) im *AWS -Big-Data-Blog*.
# Funktionen in Amazon Athena
Weitere Informationen über Versionen des Athena-Engines finden Sie in [Athena-Engine-Versionierung](engine-versions.md). Eine Liste der Zeitzonen, die mit dem `AT TIME ZONE`-Operator verwendet werden können, finden Sie unter [Unterstützte Zeitzonen verwenden](athena-supported-time-zones.md).
**Topics**
+ [Athena-Engine-Version 3](functions-env3.md)
# Funktionen der Athena-Engine Version 3
Funktionen in Athena-Engine-Version 3 basieren auf Trino. Informationen zu Funktionen, Operatoren und Ausdrücken von Trino finden Sie unter [Funktionen und Operatoren](https://trino.io/docs/current/functions.html) und in den folgenden Unterabschnitten der Trino-Dokumentation.
+ [Aggregate](https://trino.io/docs/current/functions/aggregate.html)
+ [Array](https://trino.io/docs/current/functions/array.html)
+ [Binary](https://trino.io/docs/current/functions/binary.html)
+ [Bitweise](https://trino.io/docs/current/functions/bitwise.html)
+ [Farbe](https://trino.io/docs/current/functions/color.html)
+ [Vergleich](https://trino.io/docs/current/functions/comparison.html)
+ [Bedingt](https://trino.io/docs/current/functions/conditional.html)
+ [Konvertierung](https://trino.io/docs/current/functions/conversion.html)
+ [Datum und Uhrzeit](https://trino.io/docs/current/functions/datetime.html)
+ [Dezimal](https://trino.io/docs/current/functions/decimal.html)
+ [Geodaten](https://trino.io/docs/current/functions/geospatial.html)
+ [HyperLogLog](https://trino.io/docs/current/functions/hyperloglog.html)
+ [IP-Adresse](https://trino.io/docs/current/functions/ipaddress.html)
+ [JSON](https://trino.io/docs/current/functions/json.html)
+ [Lambda](https://trino.io/docs/current/functions/lambda.html)
+ [Logisch](https://trino.io/docs/current/functions/logical.html)
+ [Machine Learning](https://trino.io/docs/current/functions/ml.html)
+ [Zuordnung](https://trino.io/docs/current/functions/map.html)
+ [Math (Mathematik)](https://trino.io/docs/current/functions/math.html)
+ [Quantil-Digest](https://trino.io/docs/current/functions/qdigest.html)
+ [Regulärer Ausdruck](https://trino.io/docs/current/functions/regexp.html)
+ [Sitzung](https://trino.io/docs/current/functions/session.html)
+ [Digest festlegen](https://trino.io/docs/current/functions/setdigest.html)
+ [Zeichenfolge](https://trino.io/docs/current/functions/string.html)
+ [Tabelle](https://trino.io/docs/current/functions/table.html)
+ [Teradata](https://trino.io/docs/current/functions/teradata.html)
+ [T-Digest](https://trino.io/docs/current/functions/tdigest.html)
+ [URL](https://trino.io/docs/current/functions/url.html)
+ [UUID](https://trino.io/docs/current/functions/uuid.html)
+ [Window](https://trino.io/docs/current/functions/window.html)
## invoker\$1principal() function
Die `invoker_principal`-Funktion ist nur in der Athena-Engine Version 3 verfügbar und in Trino nicht zu finden.
Gibt ein `VARCHAR` zurück, das den ARN des Prinzipals (IAM-Rolle oder Identity Center-Identität) enthält, der die Abfrage ausgeführt hat, die die Funktion aufgerufen hat. Wenn der Abfrageaufrufer beispielsweise die Berechtigungen einer IAM-Rolle verwendet, um die Abfrage auszuführen, gibt die Funktion den ARN der IAM-Rolle zurück. Die Rolle, die die Abfrage ausführt, muss die `LakeFormation:GetDataLakePrincipal`-Aktion zulassen.
### Usage
```
SELECT invoker_principal()
```
Die folgende Tabelle zeigt ein Beispielergebnis.
****
| \$1 | \$1col0 |
| --- | --- |
| 1 | arn:aws:iam: ::role/admin 111122223333 |
# Unterstützte Zeitzonen verwenden
Sie können den Operator `AT TIME ZONE` in einer `SELECT timestamp`-Anweisung verwenden, um die Zeitzone für den zurückgegebenen Zeitstempel anzugeben, wie im folgenden Beispiel:
```
SELECT timestamp '2012-10-31 01:00 UTC' AT TIME ZONE 'America/Los_Angeles' AS la_time;
```
**Ergebnisse**
```
la_time
2012-10-30 18:00:00.000 America/Los_Angeles
```
Eine Liste der unterstützten Zeitzonen in Athena finden Sie in der Erweiterung des [Liste der unterstützten Zeitzonen](#athena-supported-time-zones-list) am Ende dieses Themas.
## Funktionen und Beispiele für Zeitzonen
Im Folgenden finden Sie weitere Funktionen und Beispiele für Zeitzonen.
+ **at\$1timezone (*timestamp*,*zone*)** — Gibt den Wert von *timestamp* in der entsprechenden Ortszeit für zurück. *zone*
**Beispiel**
```
SELECT at_timezone(timestamp '2021-08-22 00:00 UTC', 'Canada/Newfoundland')
```
**Ergebnis**
```
2021-08-21 21:30:00.000 Canada/Newfoundland
```
+ **timezone\$1hour (*timestamp*) — Gibt die Stunde** des Zeitzonen-Offsets vom Zeitstempel als a zurück. `bigint`
**Beispiel**
```
SELECT timezone_hour(timestamp '2021-08-22 04:00 UTC' AT TIME ZONE 'Canada/Newfoundland')
```
**Ergebnis**
```
-2
```
+ **timezone\$1minute (*timestamp*) — Gibt die Minute** des Zeitzonen-Offsets von als a zurück. *timestamp* `bigint`
**Beispiel**
```
SELECT timezone_minute(timestamp '2021-08-22 04:00 UTC' AT TIME ZONE 'Canada/Newfoundland')
```
**Ergebnis**
```
-30
```
+ **with\$1timezone (*timestamp*,*zone*)** — Gibt einen Zeitstempel mit einer Zeitzone aus den angegebenen Werten zurück. *timestamp* *zone*
**Beispiel**
```
SELECT with_timezone(timestamp '2021-08-22 04:00', 'Canada/Newfoundland')
```
**Ergebnis**
```
2021-08-22 04:00:00.000 Canada/Newfoundland
```
## Liste der unterstützten Zeitzonen
Die folgende Liste enthält die Zeitzonen, die mit dem `AT TIME ZONE`-Operator in Athena verwendet werden können. Weitere Funktionen und Beispiele für die Zeitzone finden Sie unter [Funktionen und Beispiele für Zeitzonen](#athena-supported-time-zones-functions-examples).
```
Africa/Abidjan
Africa/Accra
Africa/Addis_Ababa
Africa/Algiers
Africa/Asmara
Africa/Asmera
Africa/Bamako
Africa/Bangui
Africa/Banjul
Africa/Bissau
Africa/Blantyre
Africa/Brazzaville
Africa/Bujumbura
Africa/Cairo
Africa/Casablanca
Africa/Ceuta
Africa/Conakry
Africa/Dakar
Africa/Dar_es_Salaam
Africa/Djibouti
Africa/Douala
Africa/El_Aaiun
Africa/Freetown
Africa/Gaborone
Africa/Harare
Africa/Johannesburg
Africa/Juba
Africa/Kampala
Africa/Khartoum
Africa/Kigali
Africa/Kinshasa
Africa/Lagos
Africa/Libreville
Africa/Lome
Africa/Luanda
Africa/Lubumbashi
Africa/Lusaka
Africa/Malabo
Africa/Maputo
Africa/Maseru
Africa/Mbabane
Africa/Mogadishu
Africa/Monrovia
Africa/Nairobi
Africa/Ndjamena
Africa/Niamey
Africa/Nouakchott
Africa/Ouagadougou
Africa/Porto-Novo
Africa/Sao_Tome
Africa/Timbuktu
Africa/Tripoli
Africa/Tunis
Africa/Windhoek
America/Adak
America/Anchorage
America/Anguilla
America/Antigua
America/Araguaina
America/Argentina/Buenos_Aires
America/Argentina/Catamarca
America/Argentina/ComodRivadavia
America/Argentina/Cordoba
America/Argentina/Jujuy
America/Argentina/La_Rioja
America/Argentina/Mendoza
America/Argentina/Rio_Gallegos
America/Argentina/Salta
America/Argentina/San_Juan
America/Argentina/San_Luis
America/Argentina/Tucuman
America/Argentina/Ushuaia
America/Aruba
America/Asuncion
America/Atikokan
America/Atka
America/Bahia
America/Bahia_Banderas
America/Barbados
America/Belem
America/Belize
America/Blanc-Sablon
America/Boa_Vista
America/Bogota
America/Boise
America/Buenos_Aires
America/Cambridge_Bay
America/Campo_Grande
America/Cancun
America/Caracas
America/Catamarca
America/Cayenne
America/Cayman
America/Chicago
America/Chihuahua
America/Coral_Harbour
America/Cordoba
America/Costa_Rica
America/Creston
America/Cuiaba
America/Curacao
America/Danmarkshavn
America/Dawson
America/Dawson_Creek
America/Denver
America/Detroit
America/Dominica
America/Edmonton
America/Eirunepe
America/El_Salvador
America/Ensenada
America/Fort_Nelson
America/Fort_Wayne
America/Fortaleza
America/Glace_Bay
America/Godthab
America/Goose_Bay
America/Grand_Turk
America/Grenada
America/Guadeloupe
America/Guatemala
America/Guayaquil
America/Guyana
America/Halifax
America/Havana
America/Hermosillo
America/Indiana/Indianapolis
America/Indiana/Knox
America/Indiana/Marengo
America/Indiana/Petersburg
America/Indiana/Tell_City
America/Indiana/Vevay
America/Indiana/Vincennes
America/Indiana/Winamac
America/Indianapolis
America/Inuvik
America/Iqaluit
America/Jamaica
America/Jujuy
America/Juneau
America/Kentucky/Louisville
America/Kentucky/Monticello
America/Knox_IN
America/Kralendijk
America/La_Paz
America/Lima
America/Los_Angeles
America/Louisville
America/Lower_Princes
America/Maceio
America/Managua
America/Manaus
America/Marigot
America/Martinique
America/Matamoros
America/Mazatlan
America/Mendoza
America/Menominee
America/Merida
America/Metlakatla
America/Mexico_City
America/Miquelon
America/Moncton
America/Monterrey
America/Montevideo
America/Montreal
America/Montserrat
America/Nassau
America/New_York
America/Nipigon
America/Nome
America/Noronha
America/North_Dakota/Beulah
America/North_Dakota/Center
America/North_Dakota/New_Salem
America/Ojinaga
America/Panama
America/Pangnirtung
America/Paramaribo
America/Phoenix
America/Port-au-Prince
America/Port_of_Spain
America/Porto_Acre
America/Porto_Velho
America/Puerto_Rico
America/Punta_Arenas
America/Rainy_River
America/Rankin_Inlet
America/Recife
America/Regina
America/Resolute
America/Rio_Branco
America/Rosario
America/Santa_Isabel
America/Santarem
America/Santiago
America/Santo_Domingo
America/Sao_Paulo
America/Scoresbysund
America/Shiprock
America/Sitka
America/St_Barthelemy
America/St_Johns
America/St_Kitts
America/St_Lucia
America/St_Thomas
America/St_Vincent
America/Swift_Current
America/Tegucigalpa
America/Thule
America/Thunder_Bay
America/Tijuana
America/Toronto
America/Tortola
America/Vancouver
America/Virgin
America/Whitehorse
America/Winnipeg
America/Yakutat
America/Yellowknife
Antarctica/Casey
Antarctica/Davis
Antarctica/DumontDUrville
Antarctica/Macquarie
Antarctica/Mawson
Antarctica/McMurdo
Antarctica/Palmer
Antarctica/Rothera
Antarctica/South_Pole
Antarctica/Syowa
Antarctica/Troll
Antarctica/Vostok
Arctic/Longyearbyen
Asia/Aden
Asia/Almaty
Asia/Amman
Asia/Anadyr
Asia/Aqtau
Asia/Aqtobe
Asia/Ashgabat
Asia/Ashkhabad
Asia/Atyrau
Asia/Baghdad
Asia/Bahrain
Asia/Baku
Asia/Bangkok
Asia/Barnaul
Asia/Beirut
Asia/Bishkek
Asia/Brunei
Asia/Calcutta
Asia/Chita
Asia/Choibalsan
Asia/Chongqing
Asia/Chungking
Asia/Colombo
Asia/Dacca
Asia/Damascus
Asia/Dhaka
Asia/Dili
Asia/Dubai
Asia/Dushanbe
Asia/Gaza
Asia/Harbin
Asia/Hebron
Asia/Ho_Chi_Minh
Asia/Hong_Kong
Asia/Hovd
Asia/Irkutsk
Asia/Istanbul
Asia/Jakarta
Asia/Jayapura
Asia/Jerusalem
Asia/Kabul
Asia/Kamchatka
Asia/Karachi
Asia/Kashgar
Asia/Kathmandu
Asia/Katmandu
Asia/Khandyga
Asia/Kolkata
Asia/Krasnoyarsk
Asia/Kuala_Lumpur
Asia/Kuching
Asia/Kuwait
Asia/Macao
Asia/Macau
Asia/Magadan
Asia/Makassar
Asia/Manila
Asia/Muscat
Asia/Nicosia
Asia/Novokuznetsk
Asia/Novosibirsk
Asia/Omsk
Asia/Oral
Asia/Phnom_Penh
Asia/Pontianak
Asia/Pyongyang
Asia/Qatar
Asia/Qyzylorda
Asia/Rangoon
Asia/Riyadh
Asia/Saigon
Asia/Sakhalin
Asia/Samarkand
Asia/Seoul
Asia/Shanghai
Asia/Singapore
Asia/Srednekolymsk
Asia/Taipei
Asia/Tashkent
Asia/Tbilisi
Asia/Tehran
Asia/Tel_Aviv
Asia/Thimbu
Asia/Thimphu
Asia/Tokyo
Asia/Tomsk
Asia/Ujung_Pandang
Asia/Ulaanbaatar
Asia/Ulan_Bator
Asia/Urumqi
Asia/Ust-Nera
Asia/Vientiane
Asia/Vladivostok
Asia/Yakutsk
Asia/Yangon
Asia/Yekaterinburg
Asia/Yerevan
Atlantic/Azores
Atlantic/Bermuda
Atlantic/Canary
Atlantic/Cape_Verde
Atlantic/Faeroe
Atlantic/Faroe
Atlantic/Jan_Mayen
Atlantic/Madeira
Atlantic/Reykjavik
Atlantic/South_Georgia
Atlantic/St_Helena
Atlantic/Stanley
Australia/ACT
Australia/Adelaide
Australia/Brisbane
Australia/Broken_Hill
Australia/Canberra
Australia/Currie
Australia/Darwin
Australia/Eucla
Australia/Hobart
Australia/LHI
Australia/Lindeman
Australia/Lord_Howe
Australia/Melbourne
Australia/NSW
Australia/North
Australia/Perth
Australia/Queensland
Australia/South
Australia/Sydney
Australia/Tasmania
Australia/Victoria
Australia/West
Australia/Yancowinna
Brazil/Acre
Brazil/DeNoronha
Brazil/East
Brazil/West
CET
CST6CDT
Canada/Atlantic
Canada/Central
Canada/Eastern
Canada/Mountain
Canada/Newfoundland
Canada/Pacific
Canada/Saskatchewan
Canada/Yukon
Chile/Continental
Chile/EasterIsland
Cuba
EET
EST5EDT
Egypt
Eire
Europe/Amsterdam
Europe/Andorra
Europe/Astrakhan
Europe/Athens
Europe/Belfast
Europe/Belgrade
Europe/Berlin
Europe/Bratislava
Europe/Brussels
Europe/Bucharest
Europe/Budapest
Europe/Busingen
Europe/Chisinau
Europe/Copenhagen
Europe/Dublin
Europe/Gibraltar
Europe/Guernsey
Europe/Helsinki
Europe/Isle_of_Man
Europe/Istanbul
Europe/Jersey
Europe/Kaliningrad
Europe/Kiev
Europe/Kirov
Europe/Lisbon
Europe/Ljubljana
Europe/London
Europe/Luxembourg
Europe/Madrid
Europe/Malta
Europe/Mariehamn
Europe/Minsk
Europe/Monaco
Europe/Moscow
Europe/Nicosia
Europe/Oslo
Europe/Paris
Europe/Podgorica
Europe/Prague
Europe/Riga
Europe/Rome
Europe/Samara
Europe/San_Marino
Europe/Sarajevo
Europe/Simferopol
Europe/Skopje
Europe/Sofia
Europe/Stockholm
Europe/Tallinn
Europe/Tirane
Europe/Tiraspol
Europe/Ulyanovsk
Europe/Uzhgorod
Europe/Vaduz
Europe/Vatican
Europe/Vienna
Europe/Vilnius
Europe/Volgograd
Europe/Warsaw
Europe/Zagreb
Europe/Zaporozhye
Europe/Zurich
GB
GB-Eire
Hongkong
Iceland
Indian/Antananarivo
Indian/Chagos
Indian/Christmas
Indian/Cocos
Indian/Comoro
Indian/Kerguelen
Indian/Mahe
Indian/Maldives
Indian/Mauritius
Indian/Mayotte
Indian/Reunion
Iran
Israel
Jamaica
Japan
Kwajalein
Libya
MET
MST7MDT
Mexico/BajaNorte
Mexico/BajaSur
Mexico/General
NZ
NZ-CHAT
Navajo
PRC
PST8PDT
Pacific/Apia
Pacific/Auckland
Pacific/Bougainville
Pacific/Chatham
Pacific/Chuuk
Pacific/Easter
Pacific/Efate
Pacific/Enderbury
Pacific/Fakaofo
Pacific/Fiji
Pacific/Funafuti
Pacific/Galapagos
Pacific/Gambier
Pacific/Guadalcanal
Pacific/Guam
Pacific/Honolulu
Pacific/Johnston
Pacific/Kiritimati
Pacific/Kosrae
Pacific/Kwajalein
Pacific/Majuro
Pacific/Marquesas
Pacific/Midway
Pacific/Nauru
Pacific/Niue
Pacific/Norfolk
Pacific/Noumea
Pacific/Pago_Pago
Pacific/Palau
Pacific/Pitcairn
Pacific/Pohnpei
Pacific/Ponape
Pacific/Port_Moresby
Pacific/Rarotonga
Pacific/Saipan
Pacific/Samoa
Pacific/Tahiti
Pacific/Tarawa
Pacific/Tongatapu
Pacific/Truk
Pacific/Wake
Pacific/Wallis
Pacific/Yap
Poland
Portugal
ROK
Singapore
Turkey
US/Alaska
US/Aleutian
US/Arizona
US/Central
US/East-Indiana
US/Eastern
US/Hawaii
US/Indiana-Starke
US/Michigan
US/Mountain
US/Pacific
US/Pacific-New
US/Samoa
W-SU
WET
```
# DDL-Anweisungen
Verwenden Sie die hier vorgestellten DDL-Anweisungen (unterstützte Datendefinitionssprache) direkt in Athena. Die Athena-Abfrage-Engine basiert auf [HiveQL DDL](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+DDL). Athena unterstützt nicht alle DDL-Anweisungen und es gibt einige Unterschiede zwischen HiveQL DDL und Athena DDL. Weitere Informationen finden Sie in den Referenzthemen in diesem Abschnitt und [Nicht unterstützte DDLs](unsupported-ddl.md).
**Topics**
+ [Nicht unterstützte DDLs](unsupported-ddl.md)
+ [ALTER DATABASE SET DBPROPERTIES](alter-database-set-dbproperties.md)
+ [ALTER TABLE ADD COLUMNS](alter-table-add-columns.md)
+ [ALTER TABLE ADD PARTITION](alter-table-add-partition.md)
+ [ALTER TABLE CHANGE COLUMN](alter-table-change-column.md)
+ [ALTER TABLE DROP PARTITION](alter-table-drop-partition.md)
+ [ALTER TABLE RENAME PARTITION](alter-table-rename-partition.md)
+ [ALTER TABLE REPLACE COLUMNS](alter-table-replace-columns.md)
+ [ALTER TABLE SET LOCATION](alter-table-set-location.md)
+ [ALTER TABLE SET TBLPROPERTIES](alter-table-set-tblproperties.md)
+ [ANSICHTSDIALEKT ÄNDERN](alter-view-dialect.md)
+ [CREATE DATABASE](create-database.md)
+ [CREATE TABLE](create-table.md)
+ [CREATE TABLE AS](create-table-as.md)
+ [CREATE VIEW](create-view.md)
+ [DESCRIBE](describe-table.md)
+ [DESCRIBE VIEW](describe-view.md)
+ [DROP DATABASE](drop-database.md)
+ [DROP TABLE](drop-table.md)
+ [DROP VIEW](drop-view.md)
+ [MSCK REPAIR TABLE](msck-repair-table.md)
+ [SHOW COLUMNS](show-columns.md)
+ [SHOW CREATE TABLE](show-create-table.md)
+ [SHOW CREATE VIEW](show-create-view.md)
+ [SHOW DATABASES](show-databases.md)
+ [SHOW PARTITIONS](show-partitions.md)
+ [SHOW TABLES](show-tables.md)
+ [SHOW TBLPROPERTIES](show-tblproperties.md)
+ [SHOW VIEWS](show-views.md)
# Nicht unterstützte DDLs
Die folgenden DDL-Anweisungen werden von Athena SQL nicht unterstützt. Informationen zu DDL-Anweisungen, die für Iceberg-Tabellen in Athena unterstützt werden, finden Sie unter [Iceberg-Tabellenschema weiterentwickeln](querying-iceberg-evolving-table-schema.md) und [Andere DDL-Operationen an Iceberg-Tabellen ausführen](querying-iceberg-additional-operations.md).
+ ALTER INDEX
+ ALTER TABLE *table\$1name* ARCHIVE PARTITION
+ ALTER TABLE *table\$1name* CLUSTERED BY
+ ALTER TABLE *table\$1name* DROP COLUMN (unterstützt für Iceberg-Tabellen)
+ ALTER TABLE *table\$1name* EXCHANGE PARTITION
+ ALTER TABLE *table\$1name* NOT CLUSTERED
+ ALTER TABLE *table\$1name* NOT SKEWED
+ ALTER TABLE *table\$1name* NOT SORTED
+ ALTER TABLE *table\$1name* NOT STORED AS DIRECTORIES
+ ALTER TABLE *table\$1name* partitionSpec CHANGE COLUMNS
+ ALTER TABLE *table\$1name* partitionSpec COMPACT
+ ALTER TABLE *table\$1name* partitionSpec CONCATENATE
+ ALTER TABLE *table\$1name* partitionSpec SET FILEFORMAT
+ ALTER TABLE *table\$1name* RENAME TO (wird für Iceberg-Tabellen unterstützt)
+ ÄNDERN SIE DEN *table\$1name* TABELLENSATZ SERDEPROPERTIES
+ ALTER TABLE *table\$1name* SET SKEWED LOCATION
+ ALTER TABLE *table\$1name* SKEWED BY
+ ALTER TABLE *table\$1name* TOUCH
+ ALTER TABLE *table\$1name* UNARCHIVE PARTITION
+ COMMIT
+ CREATE INDEX
+ CREATE ROLE
+ CREATE TABLE *table\$1name* LIKE *existing\$1table\$1name*
+ CREATE TEMPORARY MACRO
+ DELETE FROM
+ DESCRIBE DATABASE
+ DFS
+ DROP INDEX
+ DROP ROLE
+ DROP TEMPORARY MACRO
+ EXPORT TABLE
+ GRANT ROLE
+ IMPORT TABLE
+ LOCK DATABASE
+ LOCK TABLE
+ REVOKE ROLE
+ ROLLBACK
+ SHOW COMPACTIONS
+ SHOW CURRENT ROLES
+ SHOW GRANT
+ SHOW INDEXES
+ SHOW LOCKS
+ SHOW PRINCIPALS
+ SHOW ROLE GRANT
+ SHOW ROLES
+ ANZEIGEN VON STATISTIKEN
+ SHOW TRANSACTIONS
+ START TRANSACTION
+ UNLOCK DATABASE
+ UNLOCK TABLE
# ALTER DATABASE SET DBPROPERTIES
Erstellt eine oder mehrere Eigenschaften für eine Datenbank. Sie können `DATABASE` und `SCHEMA` verwenden, beides hat dieselbe Bedeutung.
## Syntax
```
ALTER {DATABASE|SCHEMA} database_name
SET DBPROPERTIES ('property_name'='property_value' [, ...] )
```
## Parameters
**SET DBPROPERTIES ('property\$1name'='property\$1value' [, ...]**
Gibt eine Eigenschaft (oder mehrere) für die Datenbank mit dem Namen `property_name` an. Der Wert für jede dieser Eigenschaften wird entsprechend als `property_value` festgelegt. Sollte `property_name` bereits vorhanden sein, wird der alte Wert mit `property_value` überschrieben.
## Beispiele
```
ALTER DATABASE jd_datasets
SET DBPROPERTIES ('creator'='John Doe', 'department'='applied mathematics');
```
```
ALTER SCHEMA jd_datasets
SET DBPROPERTIES ('creator'='Jane Doe');
```
# ALTER TABLE ADD COLUMNS
Fügt einer vorhandenen Tabelle eine oder mehrere Spalten hinzu. Bei Verwendung der optionalen Syntax `PARTITION` werden Partitionsmetadaten aktualisiert.
## Syntax
```
ALTER TABLE table_name
[PARTITION
(partition_col1_name = partition_col1_value
[,partition_col2_name = partition_col2_value][,...])]
ADD COLUMNS (col_name data_type)
```
## Parameters
**PARTITION (partition\$1col\$1name = partition\$1col\$1value [,...])**
Erstellt eine Partition mit den von Ihnen angegebenen name/value Spaltenkombinationen. Umschließen Sie `partition_col_value` nur dann mit Anführungszeichen, wenn es sich beim Datentyp der Spalte um eine Zeichenfolge handelt.
**ADD COLUMNS (col\$1name data\$1type [,col\$1name data\$1type,…])**
Fügt Spalten nach vorhandenen Spalten, jedoch nicht vor Partitionsspalten hinzu.
## Beispiele
```
ALTER TABLE events ADD COLUMNS (eventowner string)
```
```
ALTER TABLE events PARTITION (awsregion='us-west-2') ADD COLUMNS (event string)
```
```
ALTER TABLE events PARTITION (awsregion='us-west-2') ADD COLUMNS (eventdescription string)
```
## Hinweise
+ Um im Navigationsbereich des Athena-Abfrage-Editors nach der Ausführung von `ALTER TABLE ADD COLUMNS` eine neue Tabellenspalte anzuzeigen, aktualisieren Sie die Tabellenliste im Editor manuell und erweitern die Tabelle anschließend erneut.
+ `ALTER TABLE ADD COLUMNS` funktioniert nicht für Spalten mit dem `date`-Datentyp Um dieses Problem zu umgehen, verwenden Sie den `timestamp`-Datentyp
# ALTER TABLE ADD PARTITION
Erstellt eine oder mehrere Partitionsspalten für die Tabelle. Jede Partition besteht aus einer oder mehreren unterschiedlichen name/value Spaltenkombinationen. Für jede angegebene Kombination wird ein eigenes Datenverzeichnis erstellt. Dies kann die Abfrageleistung in einigen Fällen verbessern. Partitionierte Spalten sind nicht in den Tabellendaten selbst vorhanden. Falls Sie also einen Spaltennamen angeben, der mit einer Spalte in der Tabelle übereinstimmt, wird ein Fehler ausgegeben. Weitere Informationen finden Sie unter [Ihre Daten partitionieren](partitions.md).
In Athena müssen eine Tabelle und ihre Partitionen die gleichen Datenformate verwenden, ihre Schemata können aber unterschiedlich sein. Weitere Informationen finden Sie unter [Tabellen mit Partitionen aktualisieren](updates-and-partitions.md).
Informationen zu den Berechtigungen auf Ressourcenebene, die in IAM-Richtlinien (einschließlich `glue:CreatePartition`) erforderlich sind, finden Sie unter [AWS Glue -API-Berechtigungen: Referenz zu Aktionen und Ressourcen](https://docs.aws.amazon.com/glue/latest/dg/api-permissions-reference.html) und [Konfigurieren Sie den Zugriff auf Datenbanken und Tabellen in der AWS Glue Data Catalog](fine-grained-access-to-glue-resources.md). Informationen zur Fehlerbehebung bei Berechtigungen bei der Verwendung von Athena finden Sie im Abschnitt [Berechtigungen](troubleshooting-athena.md#troubleshooting-athena-permissions) des Themas [Beheben von Problemen in Athena](troubleshooting-athena.md).
## Syntax
```
ALTER TABLE table_name ADD [IF NOT EXISTS]
PARTITION
(partition_col1_name = partition_col1_value
[,partition_col2_name = partition_col2_value]
[,...])
[LOCATION 'location1']
[PARTITION
(partition_colA_name = partition_colA_value
[,partition_colB_name = partition_colB_value
[,...])]
[LOCATION 'location2']
[,...]
```
## Parameters
Wenn Sie eine Partition hinzufügen, geben Sie ein oder mehrere name/value Spaltenpaare für die Partition und den Amazon S3 S3-Pfad an, in dem sich die Datendateien für diese Partition befinden.
**[IF NOT EXISTS]**
Führt in dem Fall, dass bereits eine Partition mit derselben Definition vorhanden ist, zu einer Fehlerunterdrückung.
**PARTITION (partition\$1col\$1name = partition\$1col\$1value [,...])**
Erstellt eine Partition mit den von Ihnen angegebenen name/value Spaltenkombinationen. Binden Sie `partition_col_value` nur als Zeichenfolgenzeichen ein, wenn der Datentyp der Spalte eine Zeichenfolge ist.
**[LOCATION 'location']**
Gibt das Verzeichnis an, in dem die in der vorherigen Anweisung definierten Partitionen gespeichert werden. Die `LOCATION`-Klausel ist optional, wenn die Daten Partitionierung (`pk1=v1/pk2=v2/pk3=v3`) im Hive-Stil verwenden. Bei der Partitionierung im Hive-Stil wird der vollständige Amazon-S3-URI automatisch aus dem Speicherort der Tabelle, den Partitionsschlüsselnamen und den Partitionsschlüsselwerten erstellt. Weitere Informationen finden Sie unter [Ihre Daten partitionieren](partitions.md).
## Überlegungen
Amazon Athena legt kein bestimmtes Begrenzung für die Anzahl der Partitionen fest, die Sie in einer einzelnen `ALTER TABLE ADD PARTITION`-DDL-Anweisung hinzufügen können. Wenn Sie jedoch eine beträchtliche Anzahl von Partitionen hinzufügen müssen, sollten Sie erwägen, den Vorgang in kleinere Stapel aufzuteilen, um potenzielle Leistungsprobleme zu vermeiden. Das folgende Beispiel verwendet aufeinanderfolgende Befehle, um Partitionen einzeln hinzuzufügen, und verwendet `IF NOT EXISTS`, um das Hinzufügen von Duplikaten zu vermeiden.
```
ALTER TABLE table_name ADD IF NOT EXISTS PARTITION (ds='2023-01-01')
ALTER TABLE table_name ADD IF NOT EXISTS PARTITION (ds='2023-01-02')
ALTER TABLE table_name ADD IF NOT EXISTS PARTITION (ds='2023-01-03')
```
Beachten Sie bei der Arbeit mit Partitionen in Athena auch die folgenden Punkte:
+ Athena unterstützt zwar das Abfragen von AWS Glue Tabellen mit 10 Millionen Partitionen, Athena kann jedoch nicht mehr als 1 Million Partitionen in einem einzigen Scan lesen.
+ Um Ihre Abfragen zu optimieren und die Anzahl der gescannten Partitionen zu reduzieren, sollten Sie Strategien wie das Bereinigen von Partitionen oder die Verwendung von Partitionsindizes in Betracht ziehen.
Weitere Überlegungen zur Arbeit mit Partitionen in Athena finden Sie unter [Ihre Daten partitionieren](partitions.md).
## Beispiele
Das folgende Beispiel fügt einer Tabelle für partitionierte Daten im Hive-Stil eine einzelne Partition hinzu.
```
ALTER TABLE orders ADD
PARTITION (dt = '2016-05-14', country = 'IN');
```
Das folgende Beispiel fügt einer Tabelle für partitionierte Daten im Hive-Stil mehrere Partitionen hinzu.
```
ALTER TABLE orders ADD
PARTITION (dt = '2016-05-31', country = 'IN')
PARTITION (dt = '2016-06-01', country = 'IN');
```
Wenn die Tabelle nicht für partitionierte Daten im Hive-Stil bestimmt ist, ist die `LOCATION`-Klausel erforderlich und sollte der vollständige Amazon-S3-URI für das Präfix sein, das die Daten der Partition enthält.
```
ALTER TABLE orders ADD
PARTITION (dt = '2016-05-31', country = 'IN') LOCATION 's3://amzn-s3-demo-bucket/path/to/INDIA_31_May_2016/'
PARTITION (dt = '2016-06-01', country = 'IN') LOCATION 's3://amzn-s3-demo-bucket/path/to/INDIA_01_June_2016/';
```
Um Fehler zu ignorieren, wenn die Partition bereits existiert, verwenden Sie die `IF NOT EXISTS`-Klausel, wie folgt.
```
ALTER TABLE orders ADD IF NOT EXISTS
PARTITION (dt = '2016-05-14', country = 'IN');
```
## Null Byte `_$folder$`-Datei
Wenn du eine `ALTER TABLE ADD PARTITION`-Anweisung ausführst und fälschlicherweise eine Partition angibts, die bereits vorhanden ist, und einen falschen Ort für Simple Storage Service (Amazon S3), Null-Byte-Platzhalterdateien des Formats `partition_value_$folder$` werden in Simple Storage Service (Amazon S3) erstellt. Sie müssen diese Dateien manuell entfernen.
Um dies zu verhindern, verwenden Sie die `ADD IF NOT EXISTS`-Syntax in Ihrer `ALTER TABLE ADD PARTITION`-Anweisung wie folgt.
```
ALTER TABLE table_name ADD IF NOT EXISTS PARTITION […]
```
# ALTER TABLE CHANGE COLUMN
Ändert den Namen, den Typ, die Reihenfolge oder den Kommentar für eine Spalte in einer Tabelle.
## Syntax
```
ALTER TABLE [db_name.]table_name
CHANGE [COLUMN] col_old_name col_new_name column_type
[COMMENT col_comment] [FIRST|AFTER column_name]
```
## Beispiele
Im folgenden Beispiel wird der Spaltenname `area` in `zip` geändert, der Datentyp auf Integer gesetzt und die umbenannte Spalte wird nach der `id`-Spalte platziert.
```
ALTER TABLE example_table CHANGE COLUMN area zip int AFTER id
```
Im folgenden Beispiel wird der `zip`Spalte in den Metadaten für `example_table` ein neuer Kommentar hinzugefügt. Um den Kommentar zu sehen, verwenden Sie den AWS CLI [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/athena/get-table-metadata.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/athena/get-table-metadata.html)Befehl oder besuchen Sie das Schema für die Tabelle in der AWS Glue Konsole.
```
ALTER TABLE example_table CHANGE COLUMN zip zip int COMMENT 'USA zipcode'
```
# ALTER TABLE DROP PARTITION
Löscht eine oder mehrere angegebene Partitionen für die benannte Tabelle.
## Syntax
```
ALTER TABLE table_name DROP [IF EXISTS] PARTITION (partition_spec) [, PARTITION (partition_spec)]
```
## Parameters
**[IF EXISTS]**
Unterdrückt die Fehlermeldung, wenn die angegebene Partition nicht vorhanden ist.
**PARTITION (partition\$1spec)**
Jeder `partition_spec` gibt eine name/value Spaltenkombination im Formular an`partition_col_name = partition_col_value [,...]`.
## Beispiele
```
ALTER TABLE orders
DROP PARTITION (dt = '2014-05-14', country = 'IN');
```
```
ALTER TABLE orders
DROP PARTITION (dt = '2014-05-14', country = 'IN'), PARTITION (dt = '2014-05-15', country = 'IN');
```
## Hinweise
Die `ALTER TABLE DROP PARTITION`-Anweisung bietet keine einzige Syntax zum Löschen aller Partitionen auf einmal oder unterstützt Filterkriterien, um einen Bereich von zu löschenden Partitionen anzugeben.
Um das Problem zu umgehen, können Sie die AWS Glue API [GetPartitions](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-catalog-partitions.html#aws-glue-api-catalog-partitions-GetPartitions)und die [BatchDeletePartition](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-catalog-partitions.html#aws-glue-api-catalog-partitions-BatchDeletePartition)Aktionen in der Skripterstellung verwenden. Die `GetPartitions`-Aktion unterstützt komplexe Filterausdrücke wie die in einem SQL-`WHERE`-Ausdruck. Nachdem Sie `GetPartitions` verwendet haben, um eine gefilterte Liste der zu löschenden Partitionen zu erstellen, können Sie mit der `BatchDeletePartition`-Aktion die Partitionen in Batches von 25 löschen.
# ALTER TABLE RENAME PARTITION
Benennt einen Partitionswert um.
**Anmerkung**
ALTER TABLE RENAME PARTITION benennt Partitionsspalten nicht um. Um den Namen einer Partitionsspalte zu ändern, können Sie die AWS Glue Konsole verwenden. Weitere Informationen finden Sie unter [Umbenennen einer Partitionsspalte in AWS Glue](#alter-table-rename-partition-column-name) an späterer Stelle in diesem Dokument.
## Syntax
Benennt für die Tabelle mit dem Namen `table_name` den durch `partition_spec`angegebenen Partitionswert in den von `new_partition_spec` angegebenen Wert um.
```
ALTER TABLE table_name PARTITION (partition_spec) RENAME TO PARTITION (new_partition_spec)
```
## Parameters
**PARTITION (partition\$1spec)**
Jeder `partition_spec` gibt eine name/value Spaltenkombination im Formular an`partition_col_name = partition_col_value [,...]`.
## Beispiele
```
ALTER TABLE orders
PARTITION (dt = '2014-05-14', country = 'IN') RENAME TO PARTITION (dt = '2014-05-15', country = 'IN');
```
## Umbenennen einer Partitionsspalte in AWS Glue
Gehen Sie wie folgt vor, um die Namen der Partitionsspalten in der AWS Glue -Konsole umzubenennen.
**Um eine Tabellenpartitionsspalte in der AWS Glue Konsole umzubenennen**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die AWS Glue Konsole unter [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. Wählen Sie im Navigationsbereich **Tables** (Tabellen) aus.
1. Verwenden Sie auf der Seite **Tabellen** das Suchfeld **Tabellen filtern**, um die Tabelle zu finden, die Sie ändern möchten.
1. Wählen Sie in der Spalte **Name** den Link der Tabelle aus, die Sie ändern möchten.
1. Führen Sie auf der Detailseite für die Tabelle, im Abschnitt **Schema**, einen der folgenden Schritte aus:
+ Um den Namen im JSON-Format zu ändern, wählen Sie **Schema als JSON bearbeiten** aus.
+ Um den Namen direkt zu ändern, wählen Sie **Schema bearbeiten**. Dieses Verfahren wählt **Schema bearbeiten** aus.
1. Aktivieren Sie das Kontrollkästchen für die partitionierte Spalte, die Sie umbenennen möchten, und wählen Sie dann **Bearbeiten**.
1. Geben Sie im Dialogfeld **Schemaeintrag bearbeiten** unter **Name** den neuen Namen für die Partitionsspalte ein.
1. Wählen Sie **Als neue Tabellenversion speichern** aus. Diese Aktion aktualisiert den Namen der Partitionsspalte und bewahrt den Verlauf der Schemaentwicklung, ohne eine separate physische Kopie Ihrer Daten zu erstellen.
1. Um Tabellenversionen zu vergleichen, wählen Sie auf der Detailseite der Tabelle **Aktionen** und dann **Versionen vergleichen** aus.
## Weitere Ressourcen
Weitere Informationen zur Partitionierung finden Sie unter [Ihre Daten partitionieren](partitions.md).
# ALTER TABLE REPLACE COLUMNS
Entfernt alle vorhandenen Spalten aus einer Tabelle, die mit dem erstellt wurde, [LazySimpleSerDe](lazy-simple-serde.md)und ersetzt sie durch den angegebenen Spaltensatz. Bei Verwendung der optionalen Syntax `PARTITION` werden Partitionsmetadaten aktualisiert. Sie können `ALTER TABLE REPLACE COLUMNS` auch verwenden, um Spalten zu löschen, indem Sie nur die Spalten angeben, die Sie behalten möchten.
## Syntax
```
ALTER TABLE table_name
[PARTITION
(partition_col1_name = partition_col1_value
[,partition_col2_name = partition_col2_value][,...])]
REPLACE COLUMNS (col_name data_type [, col_name data_type, ...])
```
## Parameters
**PARTITION (partition\$1col\$1name = partition\$1col\$1value [,...])**
Gibt eine Partition mit den von Ihnen angegebenen name/value Spaltenkombinationen an. Umschließen Sie `partition_col_value` nur dann mit Anführungszeichen, wenn es sich beim Datentyp der Spalte um eine Zeichenfolge handelt.
**REPLACE COLUMNS (col\$1name data\$1type [,col\$1name data\$1type,…])**
Ersetzt vorhandene Spalten durch die angegebenen Spaltennamen und Datentypen.
## Hinweise
+ Um die Änderung der Tabellenspalten im Navigationsbereich des Athena-Abfrage-Editors anzuzeigen, nachdem Sie `ALTER TABLE REPLACE COLUMNS` ausgeführt haben, müssen Sie möglicherweise die Tabellenliste im Editor manuell aktualisieren und die Tabelle dann erneut erweitern.
+ `ALTER TABLE REPLACE COLUMNS` funktioniert nicht für Spalten mit dem `date`-Datentyp Um dieses Problem zu umgehen, verwenden Sie stattdessen den `timestamp`-Datentyp in der Tabelle.
+ Beachten Sie, dass die Syntax `ALTER TABLE table-name REPLACE COLUMNS` sein muss, auch wenn Sie nur eine einzelne Spalte ersetzen, mit *Spalten* im Plural. Sie müssen nicht nur die Spalte angeben, die Sie ersetzen möchten, sondern auch die Spalten, die Sie beibehalten möchten. Andernfalls werden die Spalten, die Sie nicht angeben, gelöscht. Diese Syntax und dieses Verhalten leitet sich von Apache Hive DDL ab. Weitere Informationen finden Sie unter [Spalten hinzufügen/ersetzen](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+DDL#LanguageManualDDL-Add/ReplaceColumns) in der Apache-Dokumentation.
## Beispiel
Im folgenden Beispiel hat die Tabelle`names_cities`, die mit dem erstellt wurde [LazySimpleSerDe](lazy-simple-serde.md), drei Spalten mit den Namen `col1``col2`, und`col3`. Alle Spalten sind vom Typ `string`. Um die Spalten in der Tabelle anzuzeigen, verwendet der folgende Befehl die [SHOW COLUMNS](show-columns.md)-Anweisung.
```
SHOW COLUMNS IN names_cities
```
Ergebnis der Abfrage:
```
col1
col2
col3
```
Der folgende `ALTER TABLE REPLACE COLUMNS`-Befehl ersetzt die Spaltennamen durch `first_name`, `last_name`, und `city`. Die zugrunde liegenden Quelldaten sind nicht betroffen.
```
ALTER TABLE names_cities
REPLACE COLUMNS (first_name string, last_name string, city string)
```
Um das Ergebnis zu testen, wird `SHOW COLUMNS` erneut ausgeführt.
```
SHOW COLUMNS IN names_cities
```
Ergebnis der Abfrage:
```
first_name
last_name
city
```
Eine andere Möglichkeit, die neuen Spaltennamen anzuzeigen, besteht darin, eine [Vorschau der Tabelle](creating-tables-showing-table-information.md) im Athena-Abfrage-Editor anzuzeigen oder Ihre eigene `SELECT`-Abfrage auszuführen.
# ALTER TABLE SET LOCATION
Ändert den Speicherort für die Tabelle namens `table_name`und optional eine Partition mit `partition_spec`.
## Syntax
```
ALTER TABLE table_name [ PARTITION (partition_spec) ] SET LOCATION 'new location'
```
## Parameters
**PARTITION (partition\$1spec)**
Gibt die Partition mit `partition_spec`-Parametern an, dessen Speicherort Sie ändern möchten. Der `partition_spec` gibt eine name/value Spaltenkombination im Formular an`partition_col_name = partition_col_value`.
**SET LOCATION 'new location'**
Gibt den neuen Speicherort an. Es muss sich dabei um einen Amazon S3-Speicherort handeln. Weitere Informationen zur Syntax finden Sie unter [Tabellenort in Amazon S3](tables-location-format.md).
## Beispiele
```
ALTER TABLE customers PARTITION (zip='98040', state='WA') SET LOCATION 's3://amzn-s3-demo-bucket/custdata/';
```
# ALTER TABLE SET TBLPROPERTIES
Fügt benutzerdefinierte oder vordefinierte Metadateneigenschaften zu einer Tabelle hinzu und legt deren zugewiesene Werte fest. Um die Eigenschaften in einer Tabelle anzuzeigen, verwenden Sie den Befehl [SHOW TBLPROPERTIES](show-tblproperties.md).
Apache Hive [Verwaltete Tabellen](https://cwiki.apache.org/confluence/display/Hive/Managed+vs.+External+Tables) werden nicht unterstützt, so dass die Einstellung `'EXTERNAL'='FALSE'` keine Auswirkungen hat.
## Syntax
```
ALTER TABLE table_name SET TBLPROPERTIES ('property_name' = 'property_value' [ , ... ])
```
## Parameters
**SET TBLPROPERTIES ('property\$1name' = 'property\$1value' [ , ... ])**
Gib die Metadateneigenschaften, die als `property_name` hinzugefügt werden, und den jeweiligen Wert als `property value` an. Wenn `property_name` bereits vorhanden ist, wird der Wert auf den neu angegebenen `property_value` festgelegt.
Die folgenden vordefinierten Tabelleneigenschaften haben besondere Verwendungszwecke.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/athena/latest/ug/alter-table-set-tblproperties.html)
## Beispiele
Im folgenden Beispiel wird den Tabelleneigenschaften eine Kommentarnotiz hinzugefügt.
```
ALTER TABLE orders
SET TBLPROPERTIES ('notes'="Please don't drop this table.");
```
Im folgenden Beispiel wird die Tabelle `existing_table` so geändert, dass das Parquet-Dateiformat mit ZSTD-Komprimierung und ZSTD-Komprimierungsstufe 4 verwendet wird.
```
ALTER TABLE existing_table
SET TBLPROPERTIES ('parquet.compression' = 'ZSTD', 'compression_level' = 4)
```
# ANSICHTSDIALEKT ÄNDERN
Fügt einer AWS Glue Data Catalog Ansicht einen Engine-Dialekt hinzu oder löscht ihn aus. Gilt nur für AWS Glue Data Catalog Ansichten. Erfordert `Lake Formation`-Administrator- oder Definierberechtigungen.
Weitere Informationen zu AWS Glue Data Catalog Ansichten finden Sie unter[Datenkatalog-Ansichten in Athena verwenden](views-glue.md).
## Syntax
```
ALTER VIEW name [ FORCE ] [ ADD|UPDATE ] DIALECT AS query
```
```
ALTER VIEW name [ DROP ] DIALECT
```
**FORCE**
Das `FORCE`-Schlüsselwort führt dazu, dass widersprüchliche Engine-Dialektinformationen in einer Ansicht mit der neuen Definition überschrieben werden. Das `FORCE`-Schlüsselwort ist hilfreich, wenn eine Aktualisierung einer Data-Catalog-Ansicht zu widersprüchlichen Ansichtsdefinitionen in den vorhandenen Engine-Dialekten führt. Angenommen, eine Data-Catalog-Ansicht verfügt sowohl über den Athena- als auch den Amazon-Redshift-Dialekt und die Aktualisierung führt zu einem Konflikt mit Amazon Redshift in der Ansichtsdefinition. In diesem Fall können Sie das `FORCE`-Schlüsselwort verwenden, damit die Aktualisierung abgeschlossen werden kann und der Amazon-Redshift-Dialekt als veraltet markiert wird. Wenn als veraltet markierte Engines die Ansicht abfragen, schlägt die Abfrage fehl. Die Engines lösen eine Ausnahme aus, um veraltete Ergebnisse zu verhindern. Um dies zu beheben, aktualisieren Sie die veralteten Dialekte in der Ansicht.
**ADD**
Fügt der Data-Catalog-Ansicht einen neuen Engine-Dialekt hinzu. Die angegebene Engine darf nicht bereits in der Data-Catalog-Ansicht vorhanden sein.
**UPDATE**
Aktualisiert einen Engine-Dialekt, der bereits in der Data-Catalog-Ansicht vorhanden ist.
**DROP**
Löscht einen vorhandenen Engine-Dialekt aus einer Data-Catalog-Ansicht. Nachdem Sie eine Engine aus einer Data-Catalog-Ansicht gelöscht haben, kann die Data-Catalog-Ansicht nicht mehr von der gelöschten Engine abgefragt werden. Andere Engine-Dialekte in der Ansicht können die Ansicht weiterhin abfragen.
**DIALEKT ALS**
Führt eine Engine-spezifische SQL-Abfrage ein.
## Beispiele
```
ALTER VIEW orders_by_date FORCE ADD DIALECT
AS
SELECT orderdate, sum(totalprice) AS price
FROM orders
GROUP BY orderdate
```
```
ALTER VIEW orders_by_date FORCE UPDATE DIALECT
AS
SELECT orderdate, sum(totalprice) AS price
FROM orders
GROUP BY orderdate
```
```
ALTER VIEW orders_by_date DROP DIALECT
```
# CREATE DATABASE
Erstellt eine Datenbank. Sie können `DATABASE` oder `SCHEMA` gleichwertig verwenden. Sie haben dieselbe Bedeutung.
**Anmerkung**
Für ein Beispiel für das Erstellen einer Datenbank, das Erstellen einer Tabelle und das Ausführen einer `SELECT`-Abfrage auf dem Tisch in Athena siehe [Erste Schritte](getting-started.md).
## Syntax
```
CREATE {DATABASE|SCHEMA} [IF NOT EXISTS] database_name
[COMMENT 'database_comment']
[LOCATION 'S3_loc']
[WITH DBPROPERTIES ('property_name' = 'property_value') [, ...]]
```
Einschränkungen für Datenbanknamen in Athena finden Sie unter [Namen für Datenbanken, Tabellen und Spalten](tables-databases-columns-names.md).
## Parameters
**[IF NOT EXISTS]**
Führt dazu, dass der Fehler unterdrückt wird, wenn eine Datenbank mit dem Namen `database_name` bereits vorhanden ist.
**[COMMENT database\$1comment]**
Legt den Metadatenwert für die integrierte Metadateneigenschaft namens `comment` und den Wert, den Sie für `database_comment` angeben, fest. AWS Glue In werden die `COMMENT` Inhalte in das `Description` Feld der Datenbankeigenschaften geschrieben.
**[LOCATION S3\$1loc]**
Legt den Speicherort fest, an dem Datenbankdateien und Metaspeicher als `S3_loc` abgelegt werden. Der Speicherort muss ein Amazon S3-Speicherort sein.
**[WITH DBPROPERTIES ('property\$1name' = 'property\$1value') [, ...] ]**
Ermöglicht Ihnen, benutzerdefinierte Metadateneigenschaften für die Datenbankdefinition festzulegen.
## Beispiele
```
CREATE DATABASE clickstreams;
```
```
CREATE DATABASE IF NOT EXISTS clickstreams
COMMENT 'Site Foo clickstream data aggregates'
LOCATION 's3://amzn-s3-demo-bucket/clickstreams/'
WITH DBPROPERTIES ('creator'='Jane D.', 'Dept.'='Marketing analytics');
```
## Anzeigen von Datenbankeigenschaften
Um die Datenbankeigenschaften für eine Datenbank anzuzeigen, die Sie in AWSData Catalog mithilfe von Catalog erstellen`CREATE DATABASE`, können Sie den AWS CLI Befehl [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/glue/get-database.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/glue/get-database.html)wie im folgenden Beispiel verwenden:
```
aws glue get-database --name
```
In der JSON-Ausgabe sieht das Ergebnis wie folgt aus:
```
{
"Database": {
"Name": "",
"Description": "",
"LocationUri": "s3://amzn-s3-demo-bucket",
"Parameters": {
"": ""
},
"CreateTime": 1603383451.0,
"CreateTableDefaultPermissions": [
{
"Principal": {
"DataLakePrincipalIdentifier": "IAM_ALLOWED_PRINCIPALS"
},
"Permissions": [
"ALL"
]
}
]
}
}
```
Weitere Informationen zu AWS CLI finden Sie im [AWS Command Line Interface Benutzerhandbuch](https://docs.aws.amazon.com/cli/latest/userguide/).
# CREATE TABLE
Erstellt eine Tabelle mit dem Namen und den Parametern, den bzw. die Sie angeben.
**Anmerkung**
Diese Seite enthält zusammenfassende Referenzinformationen. Weitere Informationen zum Erstellen von Tabellen in Athena und ein Beispiel für eine `CREATE TABLE`-Anweisung finden Sie unter [Erstellen von Tabellen in Athena](creating-tables.md). Für ein Beispiel für das Erstellen einer Datenbank, das Erstellen einer Tabelle und das Ausführen einer `SELECT`-Abfrage auf dem Tisch in Athena siehe [Erste Schritte](getting-started.md).
## Syntax
```
CREATE EXTERNAL TABLE [IF NOT EXISTS]
[db_name.]table_name [(col_name data_type [COMMENT col_comment] [, ...] )]
[COMMENT table_comment]
[PARTITIONED BY (col_name data_type [COMMENT col_comment], ...)]
[CLUSTERED BY (col_name, col_name, ...) INTO num_buckets BUCKETS]
[ROW FORMAT row_format]
[STORED AS file_format]
[WITH SERDEPROPERTIES (...)]
[LOCATION 's3://amzn-s3-demo-bucket/[folder]/']
[TBLPROPERTIES ( ['has_encrypted_data'='true | false',] ['encryption_option'='SSE_S3 | SSE_KMS | CSE_KMS',] ['kms_key'='aws_kms_key_arn',] ['classification'='aws_glue_classification',] property_name=property_value [, ...] ) ]
```
## Parameters
**EXTERNAL**
Gibt an, dass die Tabelle auf einer Datendatei basiert, die in Amazon S3 an dem von Ihnen angegebenen `LOCATION` vorhanden ist. Verwenden Sie außer beim Erstellen von [Iceberg](querying-iceberg-creating-tables.md)-Tabellen immer das `EXTERNAL`-Schlüsselwort. Wenn Sie `CREATE TABLE` ohne das `EXTERNAL`-Schlüsselwort für Nicht-Iceberg-Tabellen verwenden, gibt Athena einen Fehler aus. Wenn Sie eine externe Tabelle erstellen, müssen die referenzierten Daten mit dem Standardformat oder dem Format übereinstimmen, das Sie über die Klauseln `ROW FORMAT`, `STORED AS` und `WITH SERDEPROPERTIES` festlegen.
**[IF NOT EXISTS]**
Dieser Parameter prüft, ob bereits eine Tabelle mit demselben Namen vorhanden ist. Ist dies der Fall, gibt der Parameter `TRUE` zurück und Amazon Athena bricht die `CREATE TABLE`-Aktion ab. Da die Stornierung erfolgt, bevor Athena den Datenkatalog aufruft, wird kein AWS CloudTrail Ereignis ausgegeben.
**[db\$1name.]table\$1name**
Gibt einen Namen für die zu erstellende Tabelle an. Der optionale Parameter `db_name` gibt die Datenbank an, in der die Tabelle gespeichert ist. Ist nichts angegeben, wird von der aktuellen Datenbank ausgegangen. Schließen Sie `table_name` in Anführungszeichen ein, wenn der Tabellenname Zahlen enthält, zum Beispiel `"table123"`. Wenn `table_name` mit einem Unterstrich beginnt, verwenden Sie Backticks, beispielsweise ``_mytable``. Sonderzeichen (außer Unterstriche) werden nicht unterstützt.
Bei Athena-Tabellennamen wird die Groß-/Kleinschreibung berücksichtigt. Wenn Sie mit Apache Spark arbeiten, beachten Sie, dass Spark Tabellennamen in Kleinbuchstaben erfordert. Einschränkungen für Tabellennamen in Athena finden Sie unter [Namen für Datenbanken, Tabellen und Spalten](tables-databases-columns-names.md).
**[ ( col\$1name data\$1type [COMMENT col\$1comment] [, ...] ) ]**
Gibt den Datentyp und den Namen jeder zu erstellenden Spalten an. Spaltennamen lassen außer Unterstrichen `(_)` keine Sonderzeichen zu. Falls `col_name` mit einem Unterstrich beginnt, schließen Sie den Spaltennamen in Backticks ein, beispielsweise ``_mycolumn``. Einschränkungen für Spaltennamen in Athena finden Sie unter [Namen für Datenbanken, Tabellen und Spalten](tables-databases-columns-names.md).
Beim Wert `data_type` kann es sich um den folgenden Typ handeln:
+ `boolean` – Die Werte sind `true` und `false`.
+ `tinyint` – Eine 8-Bit signierte Ganzzahl im Zweierkomplement-Format mit einem Mindestwert von -2^7 und einem Höchstwert von 2^7-1.
+ `smallint` – Eine 16-Bit signierte Ganzzahl im Zweierkomplement-Format mit einem Mindestwert von -2^15 und einem Höchstwert von 2^15-1.
+ `int` – Benutzen Sie in DDL-Abfragen (Data Definition Language) wie `CREATE TABLE` das `int`-Schlüsselwort, um eine Ganzzahl darzustellen. Verwenden Sie in anderen Abfragen das Schlüsselwort `integer`, wobei `integer` als 32-Bit-Wert mit Vorzeichen im Zweierkomplementformat mit einem Mindestwert von -2^31 und einem Höchstwert von 2^31-1 dargestellt wird. Im JDBC-Treiber wird `integer` zurückgegeben, um Kompatibilität mit den geschäftlichen Analyseanwendungen zu gewährleisten.
+ `bigint` – Eine 64-Bit signierte Ganzzahl im Zweierkomplement-Format mit einem Mindestwert von -2^63 und einem Höchstwert von 2^63-1.
+ `double` – Eine signierte 64-Bit-Gleitkommazahl mit doppelter Genauigkeit. Der Bereich liegt zwischen 4,94065645841246544e-324d bis 1,79769313486231570e\$1308d, positiv oder negativ. `double` folgt dem IEEE-Standard für Gleitkommaarithmetik (IEEE 754).
+ `float` – Eine signierte 32-Bit-Gleitkommazahl mit einfacher Genauigkeit. Der Bereich liegt zwischen 1,40129846432481707e-45 bis 3,40282346638528860e\$138, positiv oder negativ. `float` folgt dem IEEE-Standard für Gleitkommaarithmetik (IEEE 754). Entspricht dem `real` in Presto. Verwenden Sie in Athena `float` in DDL-Anweisungen wie `CREATE TABLE` und `real` in SQL-Funktionen wie `SELECT CAST`. Der AWS Glue Crawler gibt Werte in zurück`float`, und Athena übersetzt `real` und `float` tippt intern (siehe [5. Juni 2018](release-notes.md#release-note-2018-06-05) Versionshinweise).
+ `decimal [ (precision, scale) ]`, wobei `precision` die Gesamtanzahl der Stellen und `scale` (optional) die Anzahl der Nachkommastellen ist. Der Standardwert ist 0. Verwenden Sie z. B. diese Definitionen: `decimal(11,5)`, `decimal(15)`. Der Höchstwert für *precision* ist 38 und der Höchstwert für *scale* ist 38.
Um Dezimalwerte als Literale anzugeben, z. B. bei der Auswahl von Zeilen mit einem bestimmten Dezimalwert im DDL-Ausdruck einer Abfrage, legen Sie als Typdefinition `decimal` fest und listen Sie die Dezimalwerte als Literalwert (in einfachen Anführungszeichen) in Ihrer Abfrage auf, wie in diesem Beispiel: `decimal_value = decimal '0.12'`.
+ `char` – Zeichendaten mit fester Länge, die zwischen 1 und 255 Zeichen liegen muss, z. B `char(10)`. Weitere Informationen finden Sie unter [CHAR-Hive-Datentyp](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+Types#LanguageManualTypes-char).
+ `varchar` – Zeichendaten mit variabler Länge, die zwischen 1 und 65535 Zeichen liegen muss, z. B `varchar(10)`. Weitere Informationen finden Sie unter [VARCHAR-Hive-Datentyp](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+Types#LanguageManualTypes-varchar).
+ `string` – Ein Zeichenfolgenliteral, das in einfache oder doppelte Anführungszeichen eingeschlossen ist.
**Anmerkung**
Nicht-Zeichenfolgen-Datentypen können nicht zu `string` in Athena umgewandelt werden. Wandeln Sie sie stattdessen zu `varchar` um.
+ `binary` – (für Daten in Parquet)
+ `date` – Ein Datum im ISO-Format, z. B. `YYYY-MM-DD`. Beispiel, `date '2008-09-15'`. Eine Ausnahme bildet das Open CSVSer De, das die Anzahl der Tage verwendet, die seit dem 1. Januar 1970 vergangen sind. Weitere Informationen finden Sie unter [CSV SerDe für die Verarbeitung von CSV öffnen](csv-serde.md).
+ `timestamp`– Datum und Uhrzeit in einem [https://docs.oracle.com/javase/8/docs/api/java/sql/Timestamp.html](https://docs.oracle.com/javase/8/docs/api/java/sql/Timestamp.html)-kompatiblen Format bis zu einer maximalen Auflösung von Millisekunden, wie `yyyy-MM-dd HH:mm:ss[.f...]`. Beispiel, `timestamp '2008-09-15 03:04:05.324'`. Eine Ausnahme ist Open CSVSer De, bei dem `TIMESTAMP` Daten im numerischen UNIX-Format verwendet werden (z. B.`1579059880000`). Weitere Informationen finden Sie unter [CSV SerDe für die Verarbeitung von CSV öffnen](csv-serde.md).
+ `array` < data\$1type >
+ `map` < primitive\$1type, data\$1type >
+ `struct` < col\$1name : data\$1type [COMMENT col\$1comment] [, ...] >
**[COMMENT table\$1comment]**
Erstellt die Tabelleneigenschaft `comment` und füllt diese mit dem von Ihnen angegebenen `table_comment`.
**[PARTITIONED BY (col\$1name data\$1type [ COMMENT col\$1comment ], ... ) ]**
Erstellt eine partitionierte Tabelle mit einer oder mehreren Partitionsspalten, bei denen `col_name`, `data_type` und `col_comment` angegeben sind. Eine Tabelle kann eine oder mehrere Partitionen umfassen. Diese bestehen aus einem eindeutigen Spaltennamen und einer Wertekombination. Für jede angegebene Kombination wird ein eigenes Datenverzeichnis erstellt. Dies kann die Abfrageleistung in einigen Fällen verbessern. In den Tabellendaten selbst sind keine partitionierten Spalten vorhanden. Wenn Sie einen Wert für `col_name` verwenden, der mit einer Tabellenspalte identisch ist, erhalten Sie einen Fehler. Weitere Informationen finden Sie auf der Seite zum [Partitionieren von Daten](partitions.md).
Nach dem Erstellen einer Tabelle mit Partitionen führen Sie eine weitere Abfrage aus, die aus der Klausel [MSCK REPAIR TABLE](msck-repair-table.md) besteht, um die Partitionsmetadaten aufzufrischen, beispielsweise `MSCK REPAIR TABLE cloudfront_logs;`. Verwenden Sie für Partitionen, die nicht Hive-kompatibel sind, [ALTER TABLE ADD PARTITION](alter-table-add-partition.md) zum Laden von Partitionen, sodass Sie die Daten abfragen können.
**[CLUSTERED BY (col\$1name, col\$1name, ...) INTO num\$1buckets BUCKETS]**
Unterteilt die Daten in den angegebenen `col_name`-Spalten mit oder ohne Partitionierung in Datenteilmengen, die als *Buckets* bezeichnet werden. Der `num_buckets`-Parameter gibt die Anzahl der zu erstellenden Buckets an. Bucketing kann die Leistung einiger Abfragen auf großen Datensätzen verbessern.
**[ROW FORMAT row\$1format]**
Gibt das Zeilenformat der Tabelle und deren zugrunde liegenden Quelldaten an, wenn zutreffend. Für `row_format` können Sie mit der Klausel `DELIMITED` ein oder mehrere Trennzeichen angeben, oder alternativ die Klausel `SERDE` verwenden, wie unten beschrieben. Wenn `ROW FORMAT` es weggelassen oder angegeben `ROW FORMAT DELIMITED` ist, wird ein SerDe systemeigener Wert verwendet.
+ [DELIMITED FIELDS TERMINATED BY char [ESCAPED BY char]]
+ [DELIMITED COLLECTION ITEMS TERMINATED BY char]
+ [MAP KEYS TERMINATED BY char]
+ [LINES TERMINATED BY char]
+ [NULL DEFINED AS char]
Nur mit Hive 0.13 verfügbar und wenn das STORED AS-Dateiformat `TEXTFILE` ist.
**--ODER--**
+ SERDE 'serde\$1name' [WITH SERDEPROPERTIES ("property\$1name" = "property\$1value", "property\$1name" = "property\$1value" [, ...] )]
Das `serde_name` gibt an SerDe , dass es verwendet werden soll. Die `WITH SERDEPROPERTIES` Klausel ermöglicht es Ihnen, eine oder mehrere benutzerdefinierte Eigenschaften anzugeben, die gemäß der zulässig sind SerDe.
**[STORED AS Dateiformat]**
Gibt das Dateiformat für Tabellendaten an. Wenn nichts angegeben ist, wird standardmäßig `TEXTFILE` verwendet. Optionen für `file_format` sind:
+ SEQUENCEFILE
+ TEXTFILE
+ RCFILE
+ ORC
+ PARQUET
+ AVRO
+ ION
+ INPUTFORMAT input\$1format\$1classname OUTPUTFORMAT output\$1format\$1classname
**[LOCATION 's3://amzn-s3-demo-bucket/[folder]/']**
Gibt den Speicherort der zugrunde liegenden Daten in Amazon S3 an, aus denen die Tabelle erstellt wurde. Der Speicherpfad muss ein Bucket-Name oder ein Bucket-Name sowie ein oder mehrere Ordner sein. Wenn Sie Partitionen verwenden, geben Sie den Stamm der partitionierten Daten an. Weitere Informationen zum Speicherort der Tabelle finden Sie unter [Tabellenspeicherort in Amazon S3 angeben](tables-location-format.md). Weitere Informationen zum Datenformat und zu den Berechtigungen finden Sie unter [Überlegungen hinsichtlich Amazon S3](creating-tables.md#s3-considerations).
Verwenden Sie einen abschließenden Schrägstrich für Ihren Ordner oder Bucket. Verwenden Sie keine Dateinamen oder glob-Zeichen.
**Verwenden**:
`s3://amzn-s3-demo-bucket/`
`s3://amzn-s3-demo-bucket/folder/`
`s3://amzn-s3-demo-bucket/folder/anotherfolder/`
**Verwenden Sie nicht:**
`s3://amzn-s3-demo-bucket`
`s3://amzn-s3-demo-bucket/*`
`s3://amzn-s3-demo-bucket/mydatafile.dat`
**[TBLPROPERTIES (['has\$1encrypted\$1data'='true \$1 false',] ['encryption\$1option' = 'SSE\$1S3 \$1 SSE\$1KMS \$1 CSE\$1KMS',] ['kms\$1key'='aws\$1kms\$1key\$1arn',] ['classification'='classification\$1value',] property\$1name=property\$1value [,...])]**
Gibt zusätzlich zu den vordefinierten Tabelleneigenschaften wie `"comment"` benutzerdefinierte Schlüssel/Wert-Paare in Form von Metadaten für die Tabellendefinition an.
**has\$1encrypted\$1data** – Athena verfügt über eine integrierte Eigenschaft, `has_encrypted_data`. Setzen Sie diese Eigenschaft auf, `true` um anzugeben, dass die von angegebene zugrunde liegende Datenmenge CSE-KMS-verschlüsselt `LOCATION` ist. Wenn dies ausgelassen wird und die Einstellungen der Arbeitsgruppe clientseitige Einstellungen nicht überschreiben, wird `false` angenommen. Wenn nichts angegeben oder die Eigenschaft auf `false` gesetzt ist, schlägt die Abfrage fehl, wenn die zugrunde liegenden Daten verschlüsselt sind. Weitere Informationen finden Sie unter [Verschlüsselung im Ruhezustand](encryption.md).
**encryption\$1option** — Setzen Sie diese Eigenschaft entweder auf, oder `SSE_S3``CSE_KMS`, um die höchste Verschlüsselungsstufe anzugeben`SSE_KMS`, die in der zugrunde liegenden Datenmenge verwendet wird, die von angegeben ist. `LOCATION` Weitere Informationen finden Sie unter [Verschlüsselung im Ruhezustand](encryption.md).
**kms\$1key** — Setzen Sie diese Eigenschaft auf den AWS-KMS-Schlüssel-ARN, der zum Verschlüsseln und Entschlüsseln von Tabellendatendateien verwendet wird. Athena verwendet diesen Schlüssel, um Tabellendatendateien beim Schreiben mit `SSE_KMS` oder `CSE_KMS` Verschlüsselung zu verschlüsseln und um mit CSE-KMS verschlüsselte Tabellendatendateien zu entschlüsseln. Diese Eigenschaft ist nur erforderlich, wenn sie `encryption_option` auf oder gesetzt ist. `SSE_KMS` `CSE_KMS` Weitere Informationen finden Sie unter [Verschlüsselung im Ruhezustand](encryption.md).
**Klassifizierung** — Tabellen, die für Athena in der CloudTrail Konsole erstellt wurden, werden `cloudtrail` als Wert für die `classification` Eigenschaft hinzugefügt. Um ETL-Jobs auszuführen, AWS Glue müssen Sie eine Tabelle mit der `classification` Eigenschaft erstellen, den Datentyp für AWS Glue as`csv`,, `parquet` `orc``avro`, oder `json` anzugeben. Beispiel, `'classification'='csv'`. ETL-Aufträge schlagen fehl, wenn Sie diese Eigenschaft nicht festlegen. Sie können diese nachträglich über AWS Glue -Konsole, die API oder die CLI angeben. Weitere Informationen finden Sie unter [Tabellen für ETL-Aufträge erstellen](schema-classifier.md) und [Authoring Jobs in AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/author-job.html) im *AWS Glue Developer Guide*.
**compression\$1level** – Die Eigenschaft `compression_level` gibt die zu verwendende Komprimierungsstufe an. Diese Eigenschaft gilt nur für die ZSTD-Komprimierung. Mögliche Werte liegen zwischen 1 und 22. Der Standardwert ist 3. Weitere Informationen finden Sie unter [ZSTD-Komprimierungsstufen verwenden](compression-support-zstd-levels.md).
Weitere Informationen zu anderen Tabelleneigenschaften finden Sie unter [ALTER TABLE SET TBLPROPERTIES](alter-table-set-tblproperties.md).
## Beispiele
Die folgende `CREATE TABLE`-Beispielanweisung erstellt eine Tabelle, die auf tabulatorgetrennten Planetendaten basiert, die in Amazon S3 gespeichert sind.
```
CREATE EXTERNAL TABLE planet_data (
planet_name string,
order_from_sun int,
au_to_sun float,
mass float,
gravity_earth float,
orbit_years float,
day_length float
)
ROW FORMAT DELIMITED
FIELDS TERMINATED BY '\t'
STORED AS TEXTFILE
LOCATION 's3://amzn-s3-demo-bucket/tsv/'
```
Beachten Sie folgende Punkte:
+ Die `ROW FORMAT DELIMITED`-Klausel gibt an, dass die Daten durch ein bestimmtes Zeichen getrennt sind.
+ Die `FIELDS TERMINATED BY '\t'`-Klausel gibt an, dass die Felder in den TSV-Daten durch das Tabulatorzeichen ('\$1 t') getrennt sind.
+ Die `STORED AS TEXTFILE`-Klausel gibt an, dass die Daten als reine Textdateien in Amazon S3 gespeichert werden.
Um die Daten abzufragen, könnten Sie eine einfache `SELECT`-Anweisung wie die folgende verwenden:
```
SELECT * FROM planet_data
```
Um das Beispiel zum Erstellen Ihrer eigenen TSV-Tabelle in Athena zu verwenden, ersetzen Sie die Tabellen- und Spaltennamen durch die Namen und Datentypen Ihrer eigenen Tabelle und Spalten und aktualisieren Sie die `LOCATION`-Klausel so, dass sie auf den Amazon S3-Pfad verweist, in dem Ihre TSV-Dateien gespeichert sind.
Weitere Informationen zum Erstellen von Tabellen finden Sie unter [Erstellen von Tabellen in Athena](creating-tables.md).
# CREATE TABLE AS
Erstellt eine neue Tabelle mit den Ergebnissen einer [SELECT](select.md)-Abfrage. Um eine leere Tabelle zu erstellen, verwenden Sie [CREATE TABLE](create-table.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, dass CTAS-Abfragen in Athena, obwohl `CREATE TABLE AS` hier mit anderen DDL-Anweisungen gruppiert ist, für Service Quotas als DML behandelt werden. Informationen zu Service Quotas für Athena finden Sie unter [Service Quotas](service-limits.md).
**Anmerkung**
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).
Weitere Informationen zu `CREATE TABLE AS`, die über den Rahmen dieses Referenzthemas hinausgehen, finden Sie unter [Erstellen einer Tabelle aus Abfrageergebnissen (CTAS)](ctas.md).
**Topics**
+ [Syntax](#synopsis)
+ [CTAS-Tabelleneigenschaften](#ctas-table-properties)
+ [Beispiele](#ctas-table-examples)
## Syntax
```
CREATE TABLE table_name
[ WITH ( property_name = expression [, ...] ) ]
AS query
[ WITH [ NO ] DATA ]
```
Wobei Folgendes gilt:
**WITH ( property\$1name = expression [, ...] )**
Eine Liste der optionalen CTAS-Tabelleneigenschaften, von denen einige für das Datenspeicherformat spezifisch sind. Siehe [CTAS-Tabelleneigenschaften](#ctas-table-properties).
**query**
Eine [SELECT](select.md)-Abfrage, die verwendet wird, um eine neue Tabelle zu erstellen.
Wenn Sie eine Abfrage mit Partitionen erstellen möchten, geben Sie die Namen der partitionierten Spalten am Ende der Liste in der Liste der Spalten in der `SELECT` Anweisung an.
**[ WITH [ NO ] DATA ]**
Wenn `WITH NO DATA` verwendet wird, wird eine neue leere Tabelle mit demselben Schema wie die ursprüngliche Tabelle erstellt.
**Anmerkung**
Um Spaltenüberschriften in Ihre Abfrageergebnis-Ausgabe einzubeziehen, können Sie eine einfache `SELECT`-Abfrage statt einer CTAS-Abfrage verwenden. Sie können die Ergebnisse aus Ihrem Speicherort für Abfrageergebnisse abrufen oder die Ergebnisse direkt über die Athena-Konsole herunterladen. Weitere Informationen finden Sie unter [Arbeiten mit Abfrageergebnissen und aktuellen Abfragen](querying.md).
## CTAS-Tabelleneigenschaften
Jede CTAS-Tabelle in Athena verfügt über eine Liste der optionalen CTAS-Tabelleneigenschaften, die Sie mit `WITH (property_name = expression [, ...] )` angeben. Informationen zur Verwendung dieser Parameter finden Sie unter [Beispiele für CTAS-Abfragen](ctas-examples.md).
** `WITH (property_name = expression [, ...], )` **
`table_type = ['HIVE', 'ICEBERG']`
Optional. Der Standardwert ist `HIVE`. Gibt den Tabellentyp der resultierenden Tabelle an
Beispiel:
```
WITH (table_type ='ICEBERG')
```
`external_location = [location]`
Da Iceberg-Tabellen nicht extern sind, gilt diese Eigenschaft nicht für Iceberg-Tabellen. Um den Stammspeicherort einer Iceberg-Tabelle in einer CTAS-Anweisung zu definieren, verwenden Sie die später in diesem Abschnitt beschriebene `location`-Eigenschaft.
Optional. Der Speicherort, an dem Athena Ihre CTAS-Abfrage in Amazon S3 speichert.
Beispiel:
```
WITH (external_location ='s3://amzn-s3-demo-bucket/tables/parquet_table/')
```
Athena verwendet nicht zweimal denselben Pfad für Abfrageergebnisse. Wenn Sie den Speicherort manuell angeben, müssen Sie sicherstellen, dass der von Ihnen angegebene Amazon-S3-Speicherort keine Daten enthält. Athena versucht nie, Ihre Daten zu löschen. Wenn Sie denselben Speicherort erneut verwenden möchten, müssen Sie die Daten manuell löschen. Andernfalls schlägt Ihre CTAS-Abfrage fehl.
Wenn Sie eine CTAS-Abfrage ausführen, die einen `external_location` in einer Arbeitsgruppe angibt, die [einen Speicherort für Abfrageergebnisse erzwingt](workgroups-settings-override.md), schlägt die Abfrage mit einer Fehlermeldung fehl. Sie können den für die Arbeitsgruppe angegebenen Abfrageergebnisspeicherort in den [Arbeitsgruppendetails](viewing-details-workgroups.md) anzeigen.
Wenn Ihre Arbeitsgruppe die clientseitige Einstellung für den Abfrageergebnisspeicherort überschreibt, erstellt Athena die Tabelle am folgenden Speicherort:
```
s3://amzn-s3-demo-bucket/tables/query-id/
```
Wenn Sie nicht die Eigenschaft `external_location` verwenden, um einen Speicherort anzugeben, und Ihre Arbeitsgruppe clientseitige Einstellungen nicht überschreibt, verwendet Athena Ihre [clientseitige Einstellung](query-results-specify-location-console.md) für den Abfrageergebnisspeicherort, um die Tabelle am folgenden Speicherort zu erstellen:
```
s3://amzn-s3-demo-bucket/Unsaved-or-query-name/year/month/date/tables/query-id/
```
`is_external = [boolean]`
Optional. Gibt an, ob es sich bei der Tabelle um eine externe Tabelle handelt. Der Standardwert ist true. Für Iceberg-Tabellen muss dies auf „false“ gesetzt werden.
Beispiel:
```
WITH (is_external = false)
```
`location = [location]`
Erforderlich für Iceberg-Tabellen. Gibt den Stammspeicherort für die aus den Abfrageergebnissen zu erstellende Iceberg-Tabelle an.
Beispiel:
```
WITH (location ='s3://amzn-s3-demo-bucket/tables/iceberg_table/')
```
`field_delimiter = [delimiter]`
Optionale und speziell für Text-basierte Datenspeicherformate. Das einstellige Feldtrennzeichen für Dateien in CSV-, TSV- und Textdateien. Beispiel, `WITH (field_delimiter = ',')`. Derzeit werden mehrzeilige Feldtrennzeichen für CTAS-Abfragen nicht unterstützt. Wenn Sie kein Feldtrennzeichen angeben, wird `\001` standardmäßig verwendet.
`format = [storage_format]`
Das Speicherformat für die CTAS-Abfrageergebnisse, z. B. `ORC`, `PARQUET`, `AVRO`, `JSON`, `ION` oder `TEXTFILE`. Für Iceberg-Tabellen sind die zulässigen Formate `ORC`, `PARQUET` und `AVRO`. Wenn nichts angegeben ist, wird standardmäßig `PARQUET` verwendet. Der Name dieses Parameters, `format`, muss in Kleinbuchstaben angegeben werden oder Ihre CTAS-Abfrage schlägt fehl.
Beispiel:
```
WITH (format = 'PARQUET')
```
`bucketed_by = ARRAY[ column_name[,…], bucket_count = [int] ]`
Diese Eigenschaft gilt nicht für Iceberg-Tabellen. Verwenden Sie für Iceberg-Tabellen die Partitionierung mit Bucket-Transformation.
Eine Array-Liste der Buckets zum Gruppieren von Daten. Wenn nicht angegeben, gruppiert Athena Ihre Daten nicht in dieser Abfrage.
`bucket_count = [int]`
Diese Eigenschaft gilt nicht für Iceberg-Tabellen. Verwenden Sie für Iceberg-Tabellen die Partitionierung mit Bucket-Transformation.
Die Anzahl der Buckets für das Bucketing Ihrer Daten. Wenn nicht angegeben, gruppiert Athena Ihre Daten nicht. Beispiel:
```
CREATE TABLE bucketed_table WITH (
bucketed_by = ARRAY[column_name],
bucket_count = 30, format = 'PARQUET',
external_location ='s3://amzn-s3-demo-bucket/tables/parquet_table/'
) AS
SELECT
*
FROM
table_name
```
`partitioned_by = ARRAY[ col_name[,…] ]`
Diese Eigenschaft gilt nicht für Iceberg-Tabellen. Verwenden Sie die später in diesem Abschnitt beschriebene `partitioning`-Eigenschaft, um Partitionstransformationen für Iceberg-Tabellen zu verwenden.
Optional. Eine Array-Liste der Spalten, nach denen die CTAS-Tabelle partitioniert wird. Stellen Sie sicher, dass die Namen der partitionierten Spalten am Ende der Liste in der Liste der Spalten in der `SELECT`-Anweisung aufgeführt werden.
`partitioning = ARRAY[partition_transform, ...]`
Optional. Gibt die Partitionierung der zu erstellenden Iceberg-Tabelle an. Iceberg unterstützt eine Vielzahl von Partitionstransformationen und Partitionsentwicklungen. Partitionstransformationen sind in der folgenden Tabelle zusammengefasst.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/athena/latest/ug/create-table-as.html)
Beispiel:
```
WITH (partitioning = ARRAY['month(order_date)',
'bucket(account_number, 10)',
'country']))
```
`optimize_rewrite_min_data_file_size_bytes = [long]`
Optional. Spezifische Konfiguration zur Datenoptimierung. Dateien, die kleiner als der angegebene Wert sind, werden zur Optimierung eingeschlossen. Der Standardwert ist das 0,75-fache des Wertes von `write_target_data_file_size_bytes`. Diese Eigenschaft gilt nur für Iceberg-Tabellen. Weitere Informationen finden Sie unter [Iceberg-Tabellen optimieren](querying-iceberg-data-optimization.md).
Beispiel:
```
WITH (optimize_rewrite_min_data_file_size_bytes = 402653184)
```
`optimize_rewrite_max_data_file_size_bytes = [long]`
Optional. Spezifische Konfiguration zur Datenoptimierung. Dateien, die größer als der angegebene Wert sind, werden zur Optimierung eingeschlossen. Der Standardwert ist das 1,8-fache des Wertes von `write_target_data_file_size_bytes`. Diese Eigenschaft gilt nur für Iceberg-Tabellen. Weitere Informationen finden Sie unter [Iceberg-Tabellen optimieren](querying-iceberg-data-optimization.md).
Beispiel:
```
WITH (optimize_rewrite_max_data_file_size_bytes = 966367641)
```
`optimize_rewrite_data_file_threshold = [int]`
Optional. 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. Der Standardwert ist 5. Diese Eigenschaft gilt nur für Iceberg-Tabellen. Weitere Informationen finden Sie unter [Iceberg-Tabellen optimieren](querying-iceberg-data-optimization.md).
Beispiel:
```
WITH (optimize_rewrite_data_file_threshold = 5)
```
`optimize_rewrite_delete_file_threshold = [int]`
Optional. 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 Ansammlöung von mehr Löschdateien für jede Datendatei zur Kosteneinsparung. Der Standardwert ist 2. Diese Eigenschaft gilt nur für Iceberg-Tabellen. Weitere Informationen finden Sie unter [Iceberg-Tabellen optimieren](querying-iceberg-data-optimization.md).
Beispiel:
```
WITH (optimize_rewrite_delete_file_threshold = 2)
```
`vacuum_min_snapshots_to_keep = [int]`
Optional. Vakuum-spezifische Konfiguration. Die Mindestanzahl der aktuellsten Snapshots, die beibehalten werden sollen. Der Standardwert ist 1. Diese Eigenschaft gilt nur für Iceberg-Tabellen. Weitere Informationen finden Sie unter [VACUUM](vacuum-statement.md).
Die `vacuum_min_snapshots_to_keep`-Eigenschaft erfordert die Athena-Engine-Version 3.
Beispiel:
```
WITH (vacuum_min_snapshots_to_keep = 1)
```
`vacuum_max_snapshot_age_seconds = [long]`
Optional. Vakuum-spezifische Konfiguration. Ein Zeitraum in Sekunden, der das Alter der beibehaltenden Snapshots darstellt. Der Standardwert beträgt 432 000 (5 Tage). Diese Eigenschaft gilt nur für Iceberg-Tabellen. Weitere Informationen finden Sie unter [VACUUM](vacuum-statement.md).
Die `vacuum_max_snapshot_age_seconds`-Eigenschaft erfordert die Athena-Engine-Version 3.
Beispiel:
```
WITH (vacuum_max_snapshot_age_seconds = 432000)
```
`write_compression = [compression_format]`
Der Komprimierungstyp, der für jedes Speicherformat verwendet werden soll, mit dem die Komprimierung angegeben werden kann. Der `compression_format`-Wert gibt die Komprimierung an, die verwendet werden soll, wenn die Daten in die Tabelle geschrieben werden. Sie können die Komprimierung für die `TEXTFILE`-, `JSON`-, `PARQUET`- und `ORC`-Dateiformate angeben.
Wenn die `format`-Eigenschaft beispielsweise `PARQUET` als Speicherformat angibt, gibt der Wert für `write_compression` das Komprimierungsformat für Parquet an. In diesem Fall entspricht die Angabe eines Wertes für `write_compression` der Angabe eines Wertes für `parquet_compression`.
Wenn die `format`-Eigenschaft `ORC` als Speicherformat angibt, gibt der Wert für `write_compression` das Komprimierungsformat für ORC an. In diesem Fall entspricht die Angabe eines Wertes für `write_compression` der Angabe eines Wertes für `orc_compression`.
Mehrere Eigenschaften von Komprimierungsformaten können in derselben CTAS-Abfrage nicht angegeben werden. Sie können beispielsweise nicht sowohl `write_compression` als auch `parquet_compression` in derselben Abfrage angeben. Dasselbe gilt für `write_compression` und `orc_compression`. Informationen zu den für jedes Dateiformat unterstützten Komprimierungstypen finden Sie unter [Komprimierung in Athena verwenden](compression-formats.md).
`orc_compression = [compression_format]`
Der Komprimierungstyp verwendet das `ORC`-Dateiformat, wenn die `ORC`-Daten in die Tabelle geschrieben werden. Beispiel, `WITH (orc_compression = 'ZLIB')`. Teile innerhalb der `ORC`-Datei (mit Ausnahme von `ORC` Postscript) werden mit der von Ihnen angegebenen Komprimierung komprimiert. Wenn es weggelassen wird, wird die ZLIB-Komprimierung standardmäßig für `ORC` verwendet.
Aus Gründen der Kontinuität empfehlen wir, die `write_compression`-Eigenschaft anstelle von `orc_compression` zu verwenden. Verwenden Sie die `format`-Eigenschaft, um das Speicherformat als `ORC` anzugeben, und verwenden Sie dann die `write_compression`-Eigenschaft, um das von `ORC` verwendete Komprimierungsformat anzugeben.
`parquet_compression = [compression_format]`
Der Komprimierungstyp verwendet das Parquet-Dateiformat, wenn die Parquet-Daten in die Tabelle geschrieben werden. Beispiel, `WITH (parquet_compression = 'SNAPPY')`. Diese Komprimierung wird auf Spaltenstücke innerhalb der Parquet-Dateien angewendet. Wenn dies weggelassen wird, wird die GZIP-Komprimierung standardmäßig für Parquet verwendet.
Aus Gründen der Kontinuität empfehlen wir, die `write_compression`-Eigenschaft anstelle von `parquet_compression` zu verwenden. Verwenden Sie die `format`-Eigenschaft, um das Speicherformat als `PARQUET` anzugeben, und verwenden Sie dann die `write_compression`-Eigenschaft, um das von `PARQUET` verwendete Komprimierungsformat anzugeben.
`compression_level = [compression_level]`
Die zu verwendende Komprimierungsstufe. Diese Eigenschaft gilt nur für die ZSTD-Komprimierung. Mögliche Werte liegen zwischen 1 und 22. Der Standardwert ist 3. Weitere Informationen finden Sie unter [ZSTD-Komprimierungsstufen verwenden](compression-support-zstd-levels.md).
## Beispiele
Beispiele für CTAS-Abfragen finden Sie in den folgenden Ressourcen.
+ [Beispiele für CTAS-Abfragen](ctas-examples.md)
+ [Verwenden von CTAS und INSERT INTO für ETL und Datenanalyse](ctas-insert-into-etl.md)
+ [Verwendung von CTAS-Anweisungen mit Amazon Athena, um die Kosten zu senken und die Leistung zu verbessern](https://aws.amazon.com/blogs/big-data/using-ctas-statements-with-amazon-athena-to-reduce-cost-and-improve-performance/)
+ [Verwenden von CTAS und INSERT INTO zum Umgehen des Limits von 100 Partitionen](ctas-insert-into.md)
# CREATE VIEW und CREATE PROTECTED MULTI DIALECT VIEW
Eine Ansicht ist eine logische Tabelle, auf die in zukünftigen Abfragen verwiesen werden kann. Ansichten enthalten keine Daten und schreiben keine Daten. Stattdessen wird die in der Ansicht angegebene Abfrage jedes Mal ausgeführt, wenn Sie in einer anderen Abfrage auf die Ansicht verweisen.
+ `CREATE VIEW` erstellt eine neue Athena-Ansicht aus einer angegebenen `SELECT`-Abfrage. Athena-Ansichten funktionieren innerhalb von Athena. Weitere Information zu Ansichten in Atehna finden Sie unter [Arbeiten mit Ansichten](views.md).
+ `CREATE PROTECTED MULTI DIALECT VIEW`erstellt eine AWS Glue Data Catalog Ansicht in der AWS Glue Data Catalog. AWS Glue Data Catalog Ansichten bieten eine einzige gemeinsame Ansicht für Amazon AWS-Services Athena und Amazon Redshift. Weitere Informationen zu AWS Glue Data Catalog Ansichten finden Sie unter. [Datenkatalog-Ansichten in Athena verwenden](views-glue.md)
## CREATE VIEW
Erstellt eine Ansicht zur Verwendung in Athena.
### Syntax
```
CREATE [ OR REPLACE ] VIEW view_name AS query
```
Mit der optionalen `OR REPLACE`-Klausel können Sie die vorhandene Ansicht aktualisieren, indem Sie sie ersetzen. Weitere Informationen finden Sie unter [Ansichten erstellen](views-console.md#creating-views).
### Beispiele
Verwenden Sie zum Erstellen einer Ansicht `test` aus der Tabelle `orders` eine Abfrage wie die folgende:
```
CREATE VIEW test AS
SELECT
orderkey,
orderstatus,
totalprice / 2 AS half
FROM orders;
```
Verwenden Sie zum Erstellen einer Ansicht `orders_by_date` aus der Tabelle `orders` die folgende Abfrage:
```
CREATE VIEW orders_by_date AS
SELECT orderdate, sum(totalprice) AS price
FROM orders
GROUP BY orderdate;
```
Verwenden Sie zum Aktualisieren einer vorhandenen Ansicht ein Beispiel wie das folgende:
```
CREATE OR REPLACE VIEW test AS
SELECT orderkey, orderstatus, totalprice / 4 AS quarter
FROM orders;
```
Weitere Informationen zur Verwendung Ansichten in finden Sie unter [Arbeiten mit Ansichten](views.md).
## CREATE PROTECTED MULTI DIALECT VIEW
Erstellt eine AWS Glue Data Catalog Ansicht in der AWS Glue Data Catalog. Eine Data-Catalog-Ansicht ist ein einzelnes Ansichtsschema, das mit Athena und anderen SQL-Engines wie Amazon Redshift und Amazon EMR funktioniert.
### Syntax
```
CREATE [ OR REPLACE ] PROTECTED MULTI DIALECT VIEW view_name
SECURITY DEFINER
[ SHOW VIEW JSON ]
AS query
```
**OR REPLACE**
(Optional) Aktualisiert die vorhandene Ansicht, indem sie ersetzt wird. Eine Data-Catalog-Ansicht kann nicht ersetzt werden, wenn in der Ansicht SQL-Dialekte von anderen Engines vorhanden sind. Wenn die aufrufende Engine über den einzigen in der Ansicht vorhandenen SQL-Dialekt verfügt, kann die Ansicht ersetzt werden.
**GESCHÜTZT**
Erforderliches Schlüsselwort. Gibt an, dass die Ansicht vor Datenverlusten geschützt ist. Data-Catalog-Ansichten können nur als `PROTECTED`-Ansicht erstellt werden.
**MULTI-DIALEKT**
Gibt an, dass die Ansicht die SQL-Dialekte unterschiedlicher Abfrage-Engines unterstützt und daher von diesen Engines gelesen werden kann.
**SICHERHEITS-DEFINER**
Gibt an, dass die Definer-Semantik für diese Ansicht in Kraft ist. Definer-Semantik bedeutet, dass die effektiven Leseberechtigungen für die zugrunde liegenden Tabellen dem Prinzipal oder der Rolle gehören, der die Ansicht definiert hat, und nicht dem Prinzipal, der den tatsächlichen Lesevorgang ausführt.
**SHOW VIEW JSON**
(Optional) Gibt das JSON für die Datenkatalog-Ansichtsspezifikation zurück, ohne tatsächlich eine Ansicht zu erstellen. Diese „Dry-Run“-Option ist nützlich, wenn Sie die SQL-Anweisung für die Ansicht validieren und die zu verwendenden Tabellenmetadaten zurückgeben möchten, die AWS Glue verwenden wird.
### Beispiel
Im folgenden Beispiel wird die Data-Catalog-Ansicht `orders_by_date` basierend auf einer Abfrage der `orders`-Tabelle erstellt.
```
CREATE PROTECTED MULTI DIALECT VIEW orders_by_date
SECURITY DEFINER
AS
SELECT orderdate, sum(totalprice) AS price
FROM orders
WHERE order_city = 'SEATTLE'
GROUP BY orderdate
```
Weitere Informationen zur Verwendung von AWS Glue Data Catalog Ansichten finden Sie unter[Datenkatalog-Ansichten in Athena verwenden](views-glue.md).
# DESCRIBE
Zeigt eine oder mehrere Spalten, einschließlich Partitionsspalten, für die angegebene Tabelle an. Dieser Befehl ist nützlich, um die Attribute komplexer Spalten zu untersuchen.
## Syntax
```
DESCRIBE [EXTENDED | FORMATTED] [db_name.]table_name [PARTITION partition_spec] [col_name ( [.field_name] | [.'$elem$'] | [.'$key$'] | [.'$value$'] )]
```
**Wichtig**
Die Syntax für diese Anweisung lautet `DESCRIBE table_name`, nicht `DESCRIBE TABLE table_name`. Die Verwendung der letztgenannten Syntax führt zu der Fehlermeldung SemanticException FAILED: [Fehler 10001]: Tabelle nicht gefunden.
## Parameters
**[EXTENDED \$1 FORMATTED]**
Bestimmt das Format der Ausgabe. Wenn Sie diese Parameter weglassen, werden Spaltennamen und ihre entsprechenden Datentypen, einschließlich Partitionsspalten, im Tabellenformat angezeigt. Die Angabe von `FORMATTED` zeigt nicht nur Spaltennamen und Datentypen in tabellarischer Form, sondern auch detaillierte Tabellen- und Speicherinformationen. `EXTENDED` zeigt Spalten- und Datentypinformationen im Tabellenformat und detaillierte Metadaten für die Tabelle in serialisierter Thrift-Form. Dieses Format ist weniger lesbar und eignet sich in erster Linie für das Debugging.
**[PARTITION partition\$1spec]**
Wenn diese Option enthalten ist, werden die von `partition_spec` angegebenen Metadaten für die Partition aufgeführt, wobei `partition_spec` das Format `(partition_column = partition_col_value, partition_column = partition_col_value, ...)` aufweist.
**[col\$1name ( [.field\$1name] \$1 [.'\$1elem\$1'] \$1 [.'\$1key\$1'] \$1 [.'\$1value\$1'] )\$1 ]**
Gibt die zu untersuchende Spalte und die zu untersuchenden Attribute an. Sie können `.field_name` für ein Element einer Struktur, `'$elem$'` für ein Array-Element, `'$key$'` für einen Zuordnungsschlüssel und `'$value$'` für einen Zuordnungswert angeben. Sie können dies rekursiv angeben, um die komplexe Spalte eingehender zu prüfen.
### Beispiele
```
DESCRIBE orders
```
```
DESCRIBE FORMATTED mydatabase.mytable PARTITION (part_col = 100) columnA;
```
Die folgende Abfrage und Ausgabe zeigt Spalten- und Datentyp-Informationen aus einer `impressions`-Tabelle basierend auf Amazon-EMR-Beispieldaten.
```
DESCRIBE impressions
```
```
requestbegintime string from deserializer
adid string from deserializer
impressionid string from deserializer
referrer string from deserializer
useragent string from deserializer
usercookie string from deserializer
ip string from deserializer
number string from deserializer
processid string from deserializer
browsercokie string from deserializer
requestendtime string from deserializer
timers struct from deserializer
threadid string from deserializer
hostname string from deserializer
sessionid string from deserializer
dt string
# Partition Information
# col_name data_type comment
dt string
```
Die folgende Beispielabfrage und -ausgabe zeigen das Ergebnis für dieselbe Tabelle, wenn die Option `FORMATTED` verwendet wird.
```
DESCRIBE FORMATTED impressions
```
```
requestbegintime string from deserializer
adid string from deserializer
impressionid string from deserializer
referrer string from deserializer
useragent string from deserializer
usercookie string from deserializer
ip string from deserializer
number string from deserializer
processid string from deserializer
browsercokie string from deserializer
requestendtime string from deserializer
timers struct from deserializer
threadid string from deserializer
hostname string from deserializer
sessionid string from deserializer
dt string
# Partition Information
# col_name data_type comment
dt string
# Detailed Table Information
Database: sampledb
Owner: hadoop
CreateTime: Thu Apr 23 02:55:21 UTC 2020
LastAccessTime: UNKNOWN
Protect Mode: None
Retention: 0
Location: s3://us-east-1.elasticmapreduce/samples/hive-ads/tables/impressions
Table Type: EXTERNAL_TABLE
Table Parameters:
EXTERNAL TRUE
transient_lastDdlTime 1587610521
# Storage Information
SerDe Library: org.openx.data.jsonserde.JsonSerDe
InputFormat: org.apache.hadoop.mapred.TextInputFormat
OutputFormat: org.apache.hadoop.hive.ql.io.IgnoreKeyTextOutputFormat
Compressed: No
Num Buckets: -1
Bucket Columns: []
Sort Columns: []
Storage Desc Params:
paths requestbegintime, adid, impressionid, referrer, useragent, usercookie, ip
serialization.format 1
```
Die folgende Beispielabfrage und -ausgabe zeigen das Ergebnis für dieselbe Tabelle, wenn die Option `EXTENDED` verwendet wird. Die detaillierten Tabelleninformationen werden in einer einzigen Zeile ausgegeben, aber hier zur Lesbarkeit formatiert.
```
DESCRIBE EXTENDED impressions
```
```
requestbegintime string from deserializer
adid string from deserializer
impressionid string from deserializer
referrer string from deserializer
useragent string from deserializer
usercookie string from deserializer
ip string from deserializer
number string from deserializer
processid string from deserializer
browsercokie string from deserializer
requestendtime string from deserializer
timers struct from deserializer
threadid string from deserializer
hostname string from deserializer
sessionid string from deserializer
dt string
# Partition Information
# col_name data_type comment
dt string
Detailed Table Information Table(tableName:impressions, dbName:sampledb, owner:hadoop, createTime:1587610521,
lastAccessTime:0, retention:0, sd:StorageDescriptor(cols:[FieldSchema(name:requestbegintime, type:string, comment:null),
FieldSchema(name:adid, type:string, comment:null), FieldSchema(name:impressionid, type:string, comment:null),
FieldSchema(name:referrer, type:string, comment:null), FieldSchema(name:useragent, type:string, comment:null),
FieldSchema(name:usercookie, type:string, comment:null), FieldSchema(name:ip, type:string, comment:null),
FieldSchema(name:number, type:string, comment:null), FieldSchema(name:processid, type:string, comment:null),
FieldSchema(name:browsercokie, type:string, comment:null), FieldSchema(name:requestendtime, type:string, comment:null),
FieldSchema(name:timers, type:struct, comment:null), FieldSchema(name:threadid,
type:string, comment:null), FieldSchema(name:hostname, type:string, comment:null), FieldSchema(name:sessionid,
type:string, comment:null)], location:s3://us-east-1.elasticmapreduce/samples/hive-ads/tables/impressions,
inputFormat:org.apache.hadoop.mapred.TextInputFormat,
outputFormat:org.apache.hadoop.hive.ql.io.IgnoreKeyTextOutputFormat, compressed:false, numBuckets:-1,
serdeInfo:SerDeInfo(name:null, serializationLib:org.openx.data.jsonserde.JsonSerDe, parameters:{serialization.format=1,
paths=requestbegintime, adid, impressionid, referrer, useragent, usercookie, ip}), bucketCols:[], sortCols:[], parameters:{},
skewedInfo:SkewedInfo(skewedColNames:[], skewedColValues:[], skewedColValueLocationMaps:{}),
storedAsSubDirectories:false), partitionKeys:[FieldSchema(name:dt, type:string, comment:null)],
parameters:{EXTERNAL=TRUE, transient_lastDdlTime=1587610521}, viewOriginalText:null, viewExpandedText:null,
tableType:EXTERNAL_TABLE)
```
# DESCRIBE VIEW
Zeigt die Liste der Spalten für die angegebene Athena oder AWS Glue Data Catalog Ansicht an. Nützlich, um die Attribute einer komplexen Ansicht zu untersuchen.
Bei Datenkatalogansichten wird die Ausgabe der Anweisung durch die Zugriffskontrolle von Lake Formation gesteuert und zeigt nur die Spalten an, auf die der Aufrufer Zugriff hat.
## Syntax
```
DESCRIBE [db_name.]view_name
```
## Beispiel
```
DESCRIBE orders
```
Siehe auch [SHOW COLUMNS](show-columns.md), [SHOW CREATE VIEW](show-create-view.md), [SHOW VIEWS](show-views.md) und [DROP VIEW](drop-view.md).
# DROP DATABASE
Entfernt die benannte Datenbank aus dem Katalog. Wenn die Datenbank Tabellen enthält, müssen Sie die Tabellen entweder vor dem Ausführen von `DROP DATABASE` löschen oder die `CASCADE`-Klausel verwenden. Sie können `DATABASE` oder `SCHEMA` gleichwertig verwenden. Sie haben dieselbe Bedeutung.
## Syntax
```
DROP {DATABASE | SCHEMA} [IF EXISTS] database_name [RESTRICT | CASCADE]
```
## Parameters
**[IF EXISTS]**
Falls `database_name` nicht vorhanden ist, wird der Fehler unterdrückt.
**[RESTRICT\$1CASCADE]**
Legt fest, wie Tabellen in `database_name` während der `DROP`-Operation behandelt werden. Wenn Sie `RESTRICT` angeben, wird die Datenbank nicht gelöscht, wenn sie Tabellen enthält. Dies ist das Standardverhalten. Wenn Sie `CASCADE` angeben, werden die Datenbank und alle darin enthaltenen Tabellen gelöscht.
## Beispiele
```
DROP DATABASE clickstreams;
```
```
DROP SCHEMA IF EXISTS clickstreams CASCADE;
```
**Anmerkung**
Wenn Sie versuchen, eine Datenbank zu löschen, deren Name Sonderzeichen enthält (z. B. `my-database`), wird möglicherweise eine Fehlermeldung angezeigt. Um dieses Problem zu beheben, versuchen Sie, den Namen der Datenbank in hintere Anführungszeichen (`) einzuschließen. Informationen zum Benennen von Datenbanken in Athena finden Sie unter [Namen für Datenbanken, Tabellen und Spalten](tables-databases-columns-names.md).
# DROP TABLE
Entfernt die Metadatendefinition für die Tabelle `table_name`. Wenn Sie eine externe Tabelle löschen, bleiben die zugrunde liegenden Daten intakt.
## Syntax
```
DROP TABLE [IF EXISTS] table_name
```
## Parameters
**[ IF EXISTS ]**
Falls `table_name` nicht vorhanden ist, wird der Fehler unterdrückt.
## Beispiele
```
DROP TABLE fulfilled_orders
```
```
DROP TABLE IF EXISTS fulfilled_orders
```
Wenn Sie den Athena-Konsolenabfrage-Editor verwenden, um eine Tabelle mit anderen Sonderzeichen als dem Unterstrich (\$1) zu löschen, verwenden Sie Backticks, wie im folgenden Beispiel.
```
DROP TABLE `my-athena-database-01.my-athena-table`
```
Wenn Sie den JDBC-Konnektor verwenden, um eine Tabelle mit Sonderzeichen zu löschen, sind Backtick-Zeichen nicht erforderlich.
```
DROP TABLE my-athena-database-01.my-athena-table
```
# DROP VIEW
Löscht (löscht) eine bestehende Athena oder AWS Glue Data Catalog Ansicht. Mit der optionalen `IF EXISTS`-Klausel wird der Fehler unterdrückt, falls die Ansicht nicht existiert.
Löscht die Ansicht bei Datenkatalog-Ansichten nur wenn die Syntax der Athena-Ansicht (Dialekt) in der Datenkatalog-Ansicht vorhanden ist. Wenn ein Benutzer beispielsweise `DROP VIEW` von Athena aus aufruft, wird die Ansicht nur gelöscht, wenn der Athena-Dialekt in der Ansicht vorhanden ist. Andernfalls schlägt sie fehl. Das Löschen von Datenkatalogansichten erfordert Berechtigungen als Lake Formation-Administrator oder Ansichtsdefinierer.
Weitere Informationen erhalten Sie unter [Arbeiten mit Ansichten](views.md) und [Datenkatalog-Ansichten in Athena verwenden](views-glue.md).
## Syntax
```
DROP VIEW [ IF EXISTS ] view_name
```
## Beispiele
```
DROP VIEW orders_by_date
```
```
DROP VIEW IF EXISTS orders_by_date
```
Siehe auch [CREATE VIEW und CREATE PROTECTED MULTI DIALECT VIEW](create-view.md), [SHOW COLUMNS](show-columns.md), [SHOW CREATE VIEW](show-create-view.md), [SHOW VIEWS](show-views.md) und [DESCRIBE VIEW](describe-view.md).
# MSCK REPAIR TABLE
Verwenden Sie den `MSCK REPAIR TABLE`-Befehl, um die Metadaten im Katalog zu aktualisieren, nachdem Sie mit Hive kompatible Partitionen hinzugefügt haben.
Der `MSCK REPAIR TABLE`-Befehl durchsucht ein Dateisystem, z. B., Amazon S3, nach mit Hive kompatiblen Partitionen, die dem Dateisystem hinzugefügt wurden, nachdem die Tabelle erstellt wurde. `MSCK REPAIR TABLE` vergleicht die Partitionen in den Tabellenmetadaten und die Partitionen in S3. Wenn neue Partitionen am S3-Speicherort vorhanden sind, den Sie beim Erstellen der Tabelle angegeben haben, werden diese Partitionen den Metadaten und der Athena-Tabelle hinzugefügt.
Wenn Sie physische Partitionen hinzufügen, werden die Metadaten im Katalog mit dem Layout der Daten im Dateisystem inkonsistent und Informationen über die neuen Partitionen müssen dem Katalog hinzugefügt werden. Um die Metadaten zu aktualisieren, führen Sie `MSCK REPAIR TABLE` aus, damit Sie die Daten in den neuen Partitionen von Athena abfragen können.
**Anmerkung**
`MSCK REPAIR TABLE` fügt nur Partitionen zu Metadaten hinzu; sie werden nicht entfernt. Um Partitionen aus den Metadaten zu entfernen, nachdem die Partitionen in Amazon S3 manuell gelöscht wurden, führen Sie den Befehl `ALTER TABLE table-name DROP PARTITION` aus. Weitere Informationen finden Sie unter [ALTER TABLE DROP PARTITION](alter-table-drop-partition.md).
## Überlegungen und Einschränkungen
Beachten Sie bei der Verwendung von `MSCK REPAIR TABLE` die folgenden Punkte:
+ Möglicherweise dauert es etwas, bis alle Partitionen hinzugefügt wurden. Wird das Zeitlimit für diese Operation überschritten, ist der Status "unvollständig", da nur einige Partitionen zum Katalog hinzugefügt wurden. Führen Sie `MSCK REPAIR TABLE` für dieselbe Tabelle so lange aus, bis alle Partitionen hinzugefügt wurden. Weitere Informationen finden Sie unter [Ihre Daten partitionieren](partitions.md).
+ Verwenden Sie für nicht mit Hive kompatible Partitionen [ALTER TABLE ADD PARTITION](alter-table-add-partition.md), um sie zu laden und ihre Daten abzufragen.
+ Partitionsspeicherorte zur Verwendung mit Athena müssen das `s3`-Protokoll verwenden (z. B. `s3://amzn-s3-demo-bucket/folder/`). In Athena führen Speicherorte, die andere Protokolle verwenden (z. B.`s3a://bucket/folder/` ), zu Abfragefehlern, wenn `MSCK REPAIR TABLE`-Abfragen für die enthaltenen Tabellen ausgeführt werden.
+ Da es sich bei `MSCK REPAIR TABLE` durchsucht sowohl einen Ordner als auch seine Unterordner, um ein übereinstimmendes Partitionsschema zu finden. Achten Sie darauf, dass die Daten für separate Tabellen in separaten Ordnerhierarchien aufbewahrt werden. Angenommen, Sie haben Daten für Tabelle 1 in `s3://amzn-s3-demo-bucket1` und Daten für Tabelle 2 in `s3://amzn-s3-demo-bucket1/table-2-data`. Wenn beide Tabellen nach einer Zeichenfolge partitioniert sind, wird `MSCK REPAIR TABLE` die Partitionen für Tabelle 2 zu Tabelle 1 hinzufügen. Um dies zu vermeiden, verwenden Sie stattdessen separate Ordnerstrukturen wie `s3://amzn-s3-demo-bucket1` und `s3://amzn-s3-demo-bucket2`. Beachten Sie, dass dieses Verhalten mit Amazon EMR und Apache Hive konsistent ist.
+ Aufgrund eines bekannten Problems schlägt `MSCK REPAIR TABLE` ohne Fehlermeldung fehl, wenn Partitionswerte einen Doppelpunkt (`:`) enthalten (wenn der Partitionswert z. B. ein Zeitstempel ist). Als Problemumgehung verwenden Sie [ALTER TABLE ADD PARTITION](alter-table-add-partition.md).
+ `MSCK REPAIR TABLE` fügt keine Partitionsspaltennamen hinzu, die mit einem Unterstrich (\$1) beginnen. Verwenden Sie [ALTER TABLE ADD PARTITION](alter-table-add-partition.md), um dieses Limit zu umgehen.
## Syntax
```
MSCK REPAIR TABLE table_name
```
## Beispiele
```
MSCK REPAIR TABLE orders;
```
## Fehlerbehebung
Wenn Athena nach der Ausführung `MSCK REPAIR TABLE` die Partitionen nicht zur Tabelle in der hinzufügt AWS Glue Data Catalog, überprüfen Sie Folgendes:
+ **AWS Glue Zugriff** — Stellen Sie sicher, dass die AWS Identity and Access Management (IAM-) Rolle über eine Richtlinie verfügt, die die `glue:BatchCreatePartition` Aktion zulässt. Weitere Informationen finden Sie unter [Glue zulassen: BatchCreatePartition in der IAM-Richtlinie](#msck-repair-table-troubleshooting-allow-gluebatchcreatepartition-in-the-policy) an späterer Stelle in diesem Dokument.
+ **Amazon-S3-Zugriff** – Stellen Sie sicher, dass die Rolle über eine Richtlinie mit ausreichenden Berechtigungen für den Zugriff auf Amazon S3 verfügt, einschließlich der [https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_DescribeJob.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_DescribeJob.html)-Aktion. Ein Beispiel dafür, welche Amazon-S3-Aktionen zulässig sind, finden Sie in der Beispiel-Bucket-Richtlinie in [Kontoübergreifender Zugriff auf Amazon-S3-Buckets in Athena konfigurieren](cross-account-permissions.md).
+ **Amazon-S3-Objektschlüssel-Case-Schreibweise** – Achten Sie darauf, dass der Amazon-S3-Pfad in Kleinbuchstaben und nicht mit der Camel-Case-Schreibweise geschrieben ist (z. B. `userid` statt `userId`), oder verwenden Sie `ALTER TABLE ADD PARTITION`, um die Objektschlüsselnamen anzugeben. Weitere Informationen finden Sie unter [Den Amazon-S3-Pfad ändern oder neu definieren](#msck-repair-table-troubleshooting-change-or-redefine-the-amazon-s3-path) an späterer Stelle in diesem Dokument.
+ **Zeitüberschreitungen bei Abfragen** – `MSCK REPAIR TABLE` wird am besten verwendet, wenn eine Tabelle zum ersten Mal erstellt wird oder wenn Unsicherheit bezüglich der Parität zwischen Daten und Partitionsmetadaten besteht. Wenn Sie `MSCK REPAIR TABLE` verwenden, um häufig neue Partitionen hinzuzufügen (z. B. täglich) und Abfragezeitüberschreitungen auftreten, sollten Sie [ALTER TABLE ADD PARTITION](alter-table-add-partition.md) verwenden.
+ **Partitionen, die im Dateisystem fehlen** – Wenn Sie eine Partition manuell in Amazon S3 löschen und dann `MSCK REPAIR TABLE` ausführen, erhalten Sie möglicherweise die Fehlermeldung Partitionen fehlen im Dateisystem. Dies tritt auf, weil `MSCK REPAIR TABLE` keine veralteten Partitionen aus den Tabellenmetadaten entfernt. Um die gelöschten Partitionen aus den Tabellenmetadaten zu entfernen, führen Sie stattdessen [ALTER TABLE DROP PARTITION](alter-table-drop-partition.md) aus. Beachten Sie, dass [SHOW PARTITIONS](show-partitions.md) ebenfalls nur die Partitionen in den Metadaten auflistet, nicht die Partitionen im Dateisystem.
+ **Fehler „NullPointerException Name ist Null“**
Wenn Sie die AWS Glue [CreateTable](https://docs.aws.amazon.com/glue/latest/webapi/API_CreateTable.html)API-Operation oder die CloudFormation [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-glue-table.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-glue-table.html)Vorlage verwenden, um eine Tabelle für die Verwendung in Athena zu erstellen, ohne die `TableType` Eigenschaft anzugeben, und dann eine DDL-Abfrage wie `SHOW CREATE TABLE` oder ausführen`MSCK REPAIR TABLE`, können Sie die Fehlermeldung FAILED: NullPointerException Name is null erhalten.
[Um den Fehler zu beheben, geben Sie im Rahmen des AWS Glue`CreateTable` API-Aufrufs oder CloudFormation der Vorlage einen Wert für das [TableInput](https://docs.aws.amazon.com/glue/latest/webapi/API_TableInput.html)`TableType`Attribut an.](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-table-tableinput.html) Mögliche Werte für `TableType` sind `EXTERNAL_TABLE` oder `VIRTUAL_VIEW`.
Diese Anforderung gilt nur, wenn Sie eine Tabelle mithilfe der AWS Glue `CreateTable` API-Operation oder der `AWS::Glue::Table` Vorlage erstellen. Wenn Sie eine Tabelle für Athena mithilfe einer DDL-Anweisung oder eines AWS Glue -Crawlers erstellen, wird die `TableType`-Eigenschaft automatisch für Sie definiert.
In den folgenden Abschnitten finden Sie zusätzliche Informationen.
### Glue zulassen: BatchCreatePartition in der IAM-Richtlinie
Überprüfen Sie die IAM-Richtlinien, die der Rolle zugeordnet sind, die Sie zum Ausführen von `MSCK REPAIR TABLE` verwenden. Wenn Sie [das AWS Glue Data Catalog mit Athena verwenden](data-sources-glue.md), muss die IAM-Richtlinie die `glue:BatchCreatePartition` Aktion zulassen. Ein Beispiel für eine IAM-Richtlinie, die die Aktion `glue:BatchCreatePartition` zulässt, finden Sie unter [AWS verwaltete Richtlinie: AmazonAthenaFullAccess](security-iam-awsmanpol.md#amazonathenafullaccess-managed-policy).
### Den Amazon-S3-Pfad ändern oder neu definieren
Wenn ein oder mehrere Objektschlüssel im Amazon-S3-Pfad in Großbuchstaben statt in Kleinbuchstaben geschrieben sind, werden die `MSCK REPAIR TABLE` möglicherweise nicht zur AWS Glue Data Catalog hinzugefügt. Wenn Ihr Amazon-S3-Pfad beispielsweise den Objektschlüsselnamen `userId` enthält, werden die folgenden Partitionen möglicherweise nicht zur AWS Glue Data Catalog hinzugefügt:
```
s3://amzn-s3-demo-bucket/path/userId=1/
s3://amzn-s3-demo-bucket/path/userId=2/
s3://amzn-s3-demo-bucket/path/userId=3/
```
Sie lösen dieses Problem, indem Sie einen der folgenden Schritte ausführen:
+ Verwenden Sie Kleinbuchstaben statt Großbuchstaben, wenn Sie Ihre Amazon-S3-Objektschlüssel erstellen:
```
s3://amzn-s3-demo-bucket/path/userid=1/
s3://amzn-s3-demo-bucket/path/userid=2/
s3://amzn-s3-demo-bucket/path/userid=3/
```
+ Verwenden Sie [ALTER TABLE ADD PARTITION](alter-table-add-partition.md), um den Standort neu zu definieren, wie im folgenden Beispiel:
```
ALTER TABLE table_name ADD [IF NOT EXISTS]
PARTITION (userId=1)
LOCATION 's3://amzn-s3-demo-bucket/path/userId=1/'
PARTITION (userId=2)
LOCATION 's3://amzn-s3-demo-bucket/path/userId=2/'
PARTITION (userId=3)
LOCATION 's3://amzn-s3-demo-bucket/path/userId=3/'
```
Beachten Sie, dass Amazon-S3-Objektschlüsselnamen zwar Großbuchstaben verwenden können, die Amazon-S3-Bucket-Namen selbst jedoch immer in Kleinbuchstaben geschrieben werden müssen. Weitere Informationen finden Sie unter [Richtlinien zur Benennung von Objektschlüsseln](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html#object-key-guidelines) und [Regeln zur Benennung von Buckets](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucketnamingrules.html) im *Amazon-S3-Benutzerhandbuch*.
# SHOW COLUMNS
Zeigt nur die Spaltennamen für eine einzelne angegebene Tabelle, Athena-Ansicht oder Datenkatalog-Ansicht an. Um detailliertere Informationen für Athena-Ansichten zu erhalten, fragen Sie AWS Glue Data Catalog stattdessen die ab. Informationen und Beispiele finden Sie in den folgenden Abschnitten im [Fragen Sie die ab AWS Glue Data Catalog](querying-glue-catalog.md)-Thema:
+ Zur Anzeige von Spaltenmetadaten, wie z. B. dem Datentyp, siehe [Auflisten oder Durchsuchen von Spalten für eine angegebene Tabelle oder Ansicht](querying-glue-catalog-listing-columns.md).
+ Um alle Spalten für alle Tabellen in einer bestimmten Datenbank in `AwsDataCatalog` anzuzeigen, siehe [Auflisten oder Durchsuchen von Spalten für eine angegebene Tabelle oder Ansicht](querying-glue-catalog-listing-columns.md).
+ Um alle Spalten für alle Tabellen in allen Datenbanken in `AwsDataCatalog` anzuzeigen, siehe [Auflisten aller Spalten für alle Tabellen](querying-glue-catalog-listing-all-columns-for-all-tables.md).
+ Informationen zur Anzeige der Spalten, die bestimmte Tabellen in einer Datenbank gemeinsam haben, finden Sie unter[Auflistung der Spalten, die bestimmte Tabellen gemeinsam haben](querying-glue-catalog-listing-columns-in-common.md).
Bei Datenkatalogansichten wird die Ausgabe der Anweisung durch die Zugriffskontrolle von Lake Formation gesteuert und zeigt nur die Spalten an, auf die der Aufrufer Zugriff hat.
## Syntax
```
SHOW COLUMNS {FROM|IN} database_name.table_or_view_name
```
```
SHOW COLUMNS {FROM|IN} table_or_view_name [{FROM|IN} database_name]
```
Die `FROM`- und `IN`-Schlüsselwörter können synonym verwendet werden. Wenn *table\$1or\$1view\$1name* oder Sonderzeichen wie Bindestriche *database\$1name* enthält, setzen Sie den Namen in umgekehrte Anführungszeichen (z. B.). ``my-database`.`my-table`` Setzen Sie das oder nicht in einfache *table\$1or\$1view\$1name* oder *database\$1name* doppelte Anführungszeichen. Derzeit wird die Verwendung von `LIKE`- und Mustervergleichsausdrücken nicht unterstützt.
## Beispiele
Die folgenden äquivalenten Beispiele zeigen die Spalten aus der `orders`-Tabelle in der `customers`-Datenbank. Die ersten beiden Beispiele gehen davon aus, dass `customers` die aktuelle Datenbank ist.
```
SHOW COLUMNS FROM orders
```
```
SHOW COLUMNS IN orders
```
```
SHOW COLUMNS FROM customers.orders
```
```
SHOW COLUMNS IN customers.orders
```
```
SHOW COLUMNS FROM orders FROM customers
```
```
SHOW COLUMNS IN orders IN customers
```
# SHOW CREATE TABLE
Analysiert eine vorhandene Tabelle namens `table_name`, um die Abfrage zu erzeugen, mit der sie erstellt wurde.
## Syntax
```
SHOW CREATE TABLE [db_name.]table_name
```
## Parameters
**TABLE [db\$1name.]table\$1name**
Der Parameter `db_name` ist optional. Wird er nicht angegeben, wird als Standardkontext die aktuelle Datenbank verwendet.
Der Tabellenname ist erforderlich.
## Beispiele
```
SHOW CREATE TABLE orderclickstoday;
```
```
SHOW CREATE TABLE `salesdata.orderclickstoday`;
```
## Fehlerbehebung
Wenn Sie die AWS Glue [CreateTable](https://docs.aws.amazon.com/glue/latest/webapi/API_CreateTable.html)API-Operation oder die CloudFormation [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-glue-table.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-glue-table.html)Vorlage verwenden, um eine Tabelle für die Verwendung in Athena zu erstellen, ohne die `TableType` Eigenschaft anzugeben, und dann eine DDL-Abfrage wie `SHOW CREATE TABLE` oder ausführen`MSCK REPAIR TABLE`, können Sie die Fehlermeldung FAILED: NullPointerException Name is null erhalten.
[Um den Fehler zu beheben, geben Sie im Rahmen des AWS Glue`CreateTable` API-Aufrufs oder CloudFormation der Vorlage einen Wert für das [TableInput](https://docs.aws.amazon.com/glue/latest/webapi/API_TableInput.html)`TableType`Attribut an.](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-table-tableinput.html) Mögliche Werte für `TableType` sind `EXTERNAL_TABLE` oder `VIRTUAL_VIEW`.
Diese Anforderung gilt nur, wenn Sie eine Tabelle mithilfe der AWS Glue `CreateTable` API-Operation oder der `AWS::Glue::Table` Vorlage erstellen. Wenn Sie eine Tabelle für Athena mithilfe einer DDL-Anweisung oder eines AWS Glue -Crawlers erstellen, wird die `TableType`-Eigenschaft automatisch für Sie definiert.
# SHOW CREATE VIEW
Zeigt die SQL-Anweisung an, die die angegebene Athena- oder Datenkatalog-Ansicht erstellt. Die zurückgegebene SQL zeigt die in Athena verwendete Syntax zum Erstellen einer Ansicht. Das Aufrufen von `SHOW CREATE VIEW` in Datenkatalogansichten erfordert Berechtigungen als Lake Formation-Administrator oder Ansichtsdefinierer.
## Syntax
```
SHOW CREATE VIEW view_name
```
## Beispiele
```
SHOW CREATE VIEW orders_by_date
```
Weitere Informationen finden Sie auch unter [CREATE VIEW und CREATE PROTECTED MULTI DIALECT VIEW](create-view.md) und [DROP VIEW](drop-view.md).
# SHOW DATABASES
Listet alle Datenbanken auf, die im Metastore definiert sind. Sie können `DATABASES` oder `SCHEMAS` verwenden. Sie haben dieselbe Bedeutung.
Das programmatische Äquivalent von `SHOW DATABASES` ist die [ListDatabases](https://docs.aws.amazon.com/athena/latest/APIReference/API_ListDatabases.html)Athena-API-Aktion. [Die entsprechende Methode in AWS SDK für Python (Boto3) ist list\$1databases.](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/athena/client/list_databases.html)
## Syntax
```
SHOW {DATABASES | SCHEMAS} [LIKE 'regular_expression']
```
## Parameters
**[WIE ''*regular\$1expression*]**
Filtert die Liste der Datenbanken nach dem von Ihnen spezifizierten `regular_expression`. Für den Platzhalterzeichenabgleich können Sie die Kombination `.*` verwenden, die null Mal bis unbegrenzt oft einem beliebigen Zeichen entspricht.
## Beispiele
```
SHOW SCHEMAS;
```
```
SHOW DATABASES LIKE '.*analytics';
```
# SHOW PARTITIONS
Listet alle Partitionen in einer Athena-Tabelle in unsortierter Reihenfolge auf.
## Syntax
```
SHOW PARTITIONS table_name
```
+ Wie Sie Partitionen in einer Tabelle anzeigen und in einer bestimmten Reihenfolge auflisten, erfahren Sie im Abschnitt [Auflisten von Partitionen für eine bestimmte Tabelle](querying-glue-catalog-listing-partitions.md) auf der Seite [Fragen Sie die ab AWS Glue Data Catalog](querying-glue-catalog.md).
+ Wie Sie den Inhalt einer Partition anzeigen, erfahren Sie im Abschnitt [Abfragen der Daten](partitions.md#query-the-data) auf der Seite [Ihre Daten partitionieren](partitions.md).
+ `SHOW PARTITIONS`listet keine Partitionen auf, die von Athena projiziert, aber nicht im AWS Glue Katalog registriert sind. Weitere Informationen zur Partitionsprojektion finden Sie unter [Partitionsprojektion mit Amazon Athena verwenden](partition-projection.md).
+ `SHOW PARTITIONS` listet die Partitionen in Metadaten auf, nicht die Partitionen im eigentlichen Dateisystem. Um die Metadaten nach dem manuellen Löschen von Partitionen in Amazon S3 zu aktualisieren, führen Sie [ALTER TABLE DROP PARTITION](alter-table-drop-partition.md) aus.
## Beispiele
Die folgende Beispielabfrage zeigt die Partitionen für die `flight_delays_csv`-Tabelle, die Flugtabellendaten des US-Verkehrsministeriums anzeigt. Weitere Informationen zu dieser Beispieltabelle `flight_delays_csv` finden Sie unter [Lazy Simple SerDe für CSV-, TSV- und benutzerdefinierte Dateien](lazy-simple-serde.md). Die Tabelle ist nach Jahr partitioniert.
```
SHOW PARTITIONS flight_delays_csv
```
**Ergebnisse**
```
year=2007
year=2015
year=1999
year=1993
year=1991
year=2003
year=1996
year=2014
year=2004
year=2011
...
```
Die folgende Beispielabfrage zeigt die Partitionen für die `impressions`-Tabelle, die Beispieldaten zum Surfen im Internet enthält. Weitere Informationen zu dieser Beispieltabelle `impressions` finden Sie unter [Ihre Daten partitionieren](partitions.md). Die Tabelle wird durch die Spalte `dt` (datetime) partitioniert.
```
SHOW PARTITIONS impressions
```
**Ergebnisse**
```
dt=2009-04-12-16-00
dt=2009-04-13-18-15
dt=2009-04-14-00-20
dt=2009-04-12-13-00
dt=2009-04-13-02-15
dt=2009-04-14-12-05
dt=2009-04-14-06-15
dt=2009-04-12-21-15
dt=2009-04-13-22-15
...
```
### Partitionen in sortierter Reihenfolge auflisten
Um die Partitionen in der Ergebnisliste zu ordnen, verwenden Sie die folgende `SELECT`-Syntax anstelle von `SHOW PARTITIONS`.
```
SELECT * FROM database_name."table_name$partitions" ORDER BY column_name
```
Die folgende Abfrage zeigt die Liste der Partitionen für das `flight_delays_csv`-Beispiel, jedoch in sortierter Reihenfolge.
```
SELECT * FROM "flight_delays_csv$partitions" ORDER BY year
```
**Ergebnisse**
```
year
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999
...
```
Weitere Informationen finden Sie im [Auflisten von Partitionen für eine bestimmte Tabelle](querying-glue-catalog-listing-partitions.md)-Abschnitt auf der [Fragen Sie die ab AWS Glue Data Catalog](querying-glue-catalog.md)-Seite.
# SHOW TABLES
Listet alle Basistabellen und Ansichten in einer Datenbank auf.
**Anmerkung**
Der [StatementType](https://docs.aws.amazon.com/athena/latest/APIReference/API_QueryExecution.html#athena-Type-QueryExecution-StatementType)Parameter für `SHOW TABLES` im [GetQueryExecution](https://docs.aws.amazon.com/athena/latest/APIReference/API_GetQueryExecution.html)API-Betrieb ist als `UTILITY` nicht kategorisiert`DDL`.
## Syntax
```
SHOW TABLES [IN database_name] ['regular_expression']
```
## Parameters
**[IN database\$1name]**
Gibt den `database_name` an, aus der die Tabellen aufgeführt werden. Wird dies nicht angegeben, wird die Datenbank des aktuellen Kontexts verwendet.
`SHOW TABLES` kann scheitern, wenn `database_name` ein [nicht unterstütztes Zeichen](tables-databases-columns-names.md) verwendet, wie etwa einen Bindestrich. Versuchen Sie zur Behebung, den Datenbanknamen in umgekehrten Anzeichen einzuschließen.
**['regular\$1expression']**
Filtert die Liste der Tabellen nach dem von Ihnen spezifizierten `regular_expression`. Um ein beliebiges Zeichen in `AWSDataCatalog`-Tabellen anzugeben, können Sie den `*`- oder `.*`-Platzhalterausdruck verwenden. Verwenden Sie für Apache Hive-Datenbanken den Platzhalterausdruck `.*`. Um eine Auswahl zwischen Zeichen anzuzeigen, verwenden Sie das `|`-Zeichen.
## Beispiele
**Example – alle Tabellen in der Datenbank „`sampledb`“ anzeigen**
```
SHOW TABLES IN sampledb
```
`Results`
```
alb_logs
cloudfront_logs
elb_logs
flights_2016
flights_parquet
view_2016_flights_dfw
```
**Example – die Namen aller Tabellen in `sampledb` anzeigen, die das Wort „Flüge“ enthalten**
```
SHOW TABLES IN sampledb '*flights*'
```
`Results`
```
flights_2016
flights_parquet
view_2016_flights_dfw
```
**Example – die Namen aller Tabellen in `sampledb` anzeigen, die mit dem Wort „Protokolle“ enden**
```
SHOW TABLES IN sampledb '*logs'
```
`Results`
```
alb_logs
cloudfront_logs
elb_logs
```
# SHOW TBLPROPERTIES
Listet Tabelleneigenschaften für die benannte Tabelle auf.
## Syntax
```
SHOW TBLPROPERTIES table_name [('property_name')]
```
## Parameters
**[('property\$1name')]**
Falls angegeben, wird nur der Wert der Eigenschaft `property_name` aufgelistet.
## Beispiele
```
SHOW TBLPROPERTIES orders;
```
```
SHOW TBLPROPERTIES orders('comment');
```
# SHOW VIEWS
Führt die Athena- oder Datenkatalog-Ansichten in einer Liste von `STRING` Typwerten auf. Jeder Wert in der Liste ist der Name einer Ansicht in der angegebenen Datenbank oder in der aktuellen Datenbank auf, wenn Sie den Datenbanknamen weglassen. Verwenden Sie die optionale `LIKE`-Klausel mit einem regulären Ausdruck, um die Liste der Ansichtsnamen einzugrenzen. Für Datenkatalogansichten werden nur die Ansichten aufgelistet, die die Athena-SQL-Syntax verwenden. Andere Datenkatalog-Ansichten werden herausgefiltert.
## Syntax
```
SHOW VIEWS [IN database_name] [LIKE 'regular_expression']
```
### Parameters
**[IN database\$1name]**
Gibt den `database_name` an, aus der die Ansichten aufgeführt werden. Wird dies nicht angegeben, wird die Datenbank des aktuellen Kontexts verwendet.
**[LIKE 'regular\$1expression']**
Filtert die Liste der Ansichten nach dem von Ihnen spezifizierten `regular_expression`. Lediglich der Platzhalter `*`, der für ein beliebiges Zeichen steht oder `|`, welches eine Auswahl zwischen Zeichen anzeigt, können verwendet werden.
## Beispiele
```
SHOW VIEWS
```
```
SHOW VIEWS IN marketing_analytics LIKE 'orders*'
```
Siehe auch [SHOW COLUMNS](show-columns.md), [SHOW CREATE VIEW](show-create-view.md), [DESCRIBE VIEW](describe-view.md) und [DROP VIEW](drop-view.md).
# Überlegungen und Einschränkungen für SQL-Abfragen in Amazon Athena
Beachten Sie beim Ausführen von Abfragen in Athena die folgenden Überlegungen und Einschränkungen:
+ **Gespeicherte Verfahren** – Gespeicherte Verfahren werden nicht unterstützt.
+ **Maximale Anzahl von Partitionen** – Die maximale Anzahl von Partitionen, die Sie mit CTAS-Anweisungen (`CREATE TABLE AS SELECT`) erstellen können, beträgt 100. Weitere Informationen finden Sie unter [CREATE TABLE AS](create-table-as.md). Eine Problemumgehung finden Sie unter [Verwenden von CTAS und INSERT INTO zum Umgehen des Limits von 100 Partitionen](ctas-insert-into.md).
+ **Nicht unterstützte Anweisungen** – Die folgenden Anweisungen werden nicht unterstützt. Eine komplette Liste der nicht unterstützten DDL-Anweisungen in Athena finden Sie unter [Nicht unterstützte DDLs](unsupported-ddl.md).
+ `CREATE TABLE LIKE` wird nicht unterstützt.
+ `DESCRIBE INPUT` und `DESCRIBE OUTPUT` werden nicht unterstützt.
+ Die `MERGE`-Anweisung wird nur für Transaktionstabellenformate unterstützt. Weitere Informationen finden Sie unter [MERGE INTO](merge-into-statement.md).
+ `UPDATE`-Anweisungen werden nicht unterstützt.
+ `DELETE FROM` wird nicht unterstützt.
+ **Trino- und Presto-Konnektoren** – Weder [Trino](https://trino.io/docs/current/connector.html)- noch [Presto](https://prestodb.io/docs/current/connector.html)-Konnektoren werden unterstützt. Sie können mit Amazon Athena Federated Query verbinden. Weitere Informationen finden Sie unter [Nutzung von Amazon-Athena-Verbundabfrage](federated-queries.md).
+ **Zeitüberschreitungen für Tabellen mit vielen Partitionen** – Bei Athena können Zeitüberschreitungen bei Abfragen zu einer Tabelle auftreten, die Tausende von Partitionen enthält. Das kann vorkommen, wenn die Tabelle viele Partitionen hat, die nicht dem Typ `string` angehören. Wenn Sie den Typ `string` verwenden, schneidet Athena Partitionen auf MetaStore-Ebene heraus. Verwenden Sie jedoch andere Datentypen, schneidet Athena Partitionen auf der Serverseite heraus. Je mehr Partitionen vorhanden sind, desto länger dauert dieser Vorgang und desto wahrscheinlicher ist es, dass eine Zeitüberschreitung für Ihre Abfragen eintritt. Um dieses Problem zu beheben, legen Sie den Partitionstyp mit `string` fest, sodass Athena Partitionen auf MetaStore-Ebene herauschneidet. Dies reduziert den Overhead und verhindert, dass Zeitüberschreitungen bei Abfragen auftreten.
+ Unterstützung von **Amazon Glacier** – Informationen zum Abfragen wiederhergestellter Amazon-Glacier-Objekte finden Sie unter [Wiederhergestellte Amazon-Glacier-Objekte abfragen](querying-glacier.md).
+ **Als augeblendet behandelte Dateien** – Athena behandelt Quelldateien, die mit einem Unterstrich (`_`) oder einem Punkt (`.`) beginnen, als ausgeblendet. Benennen Sie die Dateien um, um diese Einschränkung zu umgehen.
+ **Begrenzung der Zeilen- oder Spaltengröße** – Die Größe einer einzelnen Zeile oder ihrer Spalten darf 32 MB nicht überschreiten. Dieser Grenzwert kann überschritten werden, wenn beispielsweise eine Zeile eine einzelne Spalte mit 35 MB enthält. Dies ist eine harte Limit des Dienstes und kann nicht geändert werden.
+ **Maximale Zeilenlänge in einer Textdatei** – Die Größe einer einzelnen Zeile in einer Textdatei hat eine Obergrenze von 200 MB. Eine Überschreitung dieses Limits kann zu der Fehlermeldung führen TextLineLengthLimitExceededException: Zu viele Byte vor dem Zeilenumbruch. Um diese Einschränkung zu umgehen, stellen Sie sicher, dass Sie keine einzelne Zeile in einer Textdatei haben, die größer als 200 MB ist.
+ **LIMIT-Klausel-Maximalwert** – Die maximale Anzahl von Zeilen für die `LIMIT`-Klausel lautet
9223372036854775807. Bei Verwendung von `ORDER BY` ist die maximale Anzahl unterstützter Zeilen für die LIMIT-Klausel 2 147 483 647. Ein Überschreiten dieser Grenze führt zur Fehlermeldung NOT\$1SUPPORTED: ORDER BY LIMIT > 2147483647 is not supported (NOT\$1SUPPORTED: ORDER BY LIMIT > 2147483647 wird nicht unterstützt).
+ **information\$1schema** — Abfragen sind am performantesten, wenn Sie über `information_schema` eine geringe bis mäßige Menge an Metadaten verfügen. AWS Glue Wenn Sie eine große Menge an Metadaten haben, können Fehler auftreten. Hinweise zum Abfragen von Metadaten in der `information_schema` Datenbank finden Sie unter. AWS Glue [Fragen Sie die ab AWS Glue Data Catalog](querying-glue-catalog.md)
+ **Array-Initialisierungen** – Aufgrund einer Einschränkung in Java ist es nicht möglich, ein Array in Athena zu initialisieren, das mehr als 254 Argumente hat.
+ **Versteckte Metadatenspalten** – Die versteckten Hive- oder Iceberg-Metadatenspalten `$bucket`, `$file_modified_time`, `$file_size` und `$partition` werden für Ansichten nicht unterstützt. Informationen zur Verwendung der `$path`-Metadatenspalte in Athena finden Sie unter [Abrufen der Dateispeicherorte für Quelldaten in Amazon S3](select.md#select-path).
Informationen zur maximalen Länge von Abfragezeichenfolgen, Kontingenten für Abfrage-Timeouts und Kontingenten für die aktive Anzahl von DML-Abfragen finden Sie unter [Service Quotas](service-limits.md).