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.

# Athena-Engine-Version 3
<a name="engine-versions-reference-0003"></a>

Für die Engine-Version 3 hat Athena einen kontinuierlichen Integrationsansatz für die Verwaltung von Open-Source-Software eingeführt, der die Aktualität mit den [Trino](https://trino.io/)- und [Presto](https://prestodb.io/)-Projekten verbessert. So erhalten Sie schnelleren Zugriff auf Verbesserungen der Community, die in die Athena-Engine integriert und darauf abgestimmt sind.

Diese Version der Athena-Engine Version 3 unterstützt alle Features der früheren Engine-Versionen. Dieses Dokument hebt die wichtigsten Unterschiede zwischen frühere Engine-Versionen und der Athena-Engine Version 3 hervor. Weitere Informationen finden Sie im *AWS -Big-Data-Blogartikel* [Upgrade auf Athena Engine Version 3, um die Abfrageleistung zu erhöhen und auf mehr Analysefeatures zuzugreifen](https://aws.amazon.com/blogs/big-data/upgrade-to-athena-engine-version-3-to-increase-query-performance-and-access-more-analytics-features/).
+ [Erste Schritte](#engine-versions-reference-0003-getting-started)
+ [Neue Features und Verbesserungen](#engine-versions-reference-0003-improvements-and-new-features)
  + [Hinzugefügte Features](#engine-versions-reference-0003-added-features)
  + [Erweiterte Funktionen](#engine-versions-reference-0003-added-functions)
  + [Leistungsverbesserungen](#engine-versions-reference-0003-performance-improvements)
  + [Verbesserungen der Zuverlässigkeit](#engine-versions-reference-0003-reliability-enhancements)
  + [Verbesserungen der Abfragesyntax](#engine-versions-reference-0003-query-syntax-enhancements)
  + [Verbesserungen des Datenformats und des Datentyps](#engine-versions-reference-0003-data-format-and-data-type-enhancements)
+ [Abwärtskompatible Änderungen](#engine-versions-reference-0003-breaking-changes)
  + [Änderungen der Abfragesyntax](#engine-versions-reference-0003-syntax-changes)
  + [Änderungen der Datenverarbeitung](#engine-versions-reference-0003-data-processing-changes)
  + [Änderungen des Zeitstempels](#engine-versions-reference-0003-timestamp-changes)
+ [Einschränkungen](#engine-versions-reference-0003-known-limitations)

## Erste Schritte
<a name="engine-versions-reference-0003-getting-started"></a>

Erstellen Sie zunächst entweder eine neue Athena-Arbeitsgruppe, die Athena engine version 3 (Athena-Engine-Version 3) verwendet, oder konfigurieren Sie eine vorhandene Arbeitsgruppe für die Verwendung von Version 3. 

Weitere Informationen finden Sie unter [Ändern von Athena-Engine-Versionen](https://docs.aws.amazon.com/athena/latest/ug/engine-versions-changing.html).

## Neue Features und Verbesserungen
<a name="engine-versions-reference-0003-improvements-and-new-features"></a>

Die aufgeführten Features und Aktualisierungen umfassen Verbesserungen von Athena selbst und von Funktionen, die von Open-Source-Trino integriert wurden. Eine vollständige Liste der SQL-Abfrageoperatoren und -Funktionen finden Sie in der [Trino-Dokumentation](https://trino.io/docs/current/functions.html).

### Hinzugefügte Features
<a name="engine-versions-reference-0003-added-features"></a>

#### Unterstützung für den Apache-Spark-Bucketing-Algorithmus
<a name="engine-versions-reference-0003-spark-bucketing-support"></a>

Athena kann Buckets lesen, die vom Spark-Hash-Algorithmus generiert wurden. Um anzugeben, dass Daten ursprünglich vom Spark-Hash-Algorithmus geschrieben wurden, fügen Sie `('bucketing_format'='spark')` in die `TBLPROPERTIES`-Klausel Ihrer `CREATE TABLE`-Anweisung ein. Wenn diese Eigenschaft nicht angegeben wird, wird der Hive-Hash-Algorithmus verwendet.

```
CREATE EXTERNAL TABLE `spark_bucket_table`(
  `id` int, 
  `name` string
  )
CLUSTERED BY (`name`) 
INTO 8 BUCKETS
STORED AS PARQUET
LOCATION 
  's3://amzn-s3-demo-bucket/to/bucketed/table/'
TBLPROPERTIES ('bucketing_format'='spark')
```

### Erweiterte Funktionen
<a name="engine-versions-reference-0003-added-functions"></a>

Die Funktionen in diesem Abschnitt sind neu in der Athena-Engine-Version 3.

#### Aggregationsfunktionen
<a name="engine-versions-reference-0003-aggregate-functions"></a>

**listagg(x, separator)** – Gibt die verketteten Eingabewerte zurück, getrennt durch die Trennzeichenfolge.

```
SELECT listagg(value, ',') WITHIN GROUP (ORDER BY value) csv_value 
FROM (VALUES 'a', 'c', 'b') t(value);
```

#### Array-Funktionen
<a name="engine-versions-reference-0003-array-functions"></a>

**contains\$1sequence(x, seq)** – Gibt wahr zurück, wenn Array x alle Array seq als sequentielle Teilmenge enthält (alle Werte in derselben aufeinanderfolgenden Reihenfolge).

```
SELECT contains_sequence(ARRAY [1,2,3,4,5,6], ARRAY[1,2]);
```

#### Binäre Funktionen
<a name="engine-versions-reference-0003-binary-functions"></a>

**murmur3 (binär)** — Berechnet den MurmurHash 128-Bit-3-Hash einer Binärdatei.

```
SELECT murmur3(from_base64('aaaaaa'));
```

#### Konvertierungs-Funktionen
<a name="engine-versions-reference-0003-conversion-functions"></a>

**format\$1number(number)** – Gibt eine formatierte Zeichenfolge mithilfe eines Einheitensymbols zurück.

```
SELECT format_number(123456); -- '123K'
```

```
SELECT format_number(1000000); -- '1M'
```

#### Datums- und Zeitfunktionen
<a name="engine-versions-reference-0003-date-and-time-functions"></a>

**timezone\$1hour(timestamp)** – Gibt die Stunde des Zeitzonen-Offsets aus dem Zeitstempel zurück.

```
SELECT EXTRACT(TIMEZONE_HOUR FROM TIMESTAMP '2020-05-10 12:34:56 +08:35');
```

**timezone\$1minute(Zeitstempel)** – Gibt die Minute des Zeitzonen-Offsets aus dem Zeitstempel zurück.

```
SELECT EXTRACT(TIMEZONE_MINUTE FROM TIMESTAMP '2020-05-10 12:34:56 +08:35');
```

#### Geodatenfunktionen
<a name="engine-versions-reference-0003-geospatial-functions"></a>

**to\$1encoded\$1polyline(Geometry)** – Codiert eine Linienfolge oder einen Mehrpunkt in eine Polylinie.

```
SELECT to_encoded_polyline(ST_GeometryFromText(
   'LINESTRING (-120.2 38.5, -120.95 40.7, -126.453 43.252)'));
```

**from encoded polyline(varchar)** – Decodiert eine Polylinie in eine Linienfolge.

```
SELECT ST_AsText(from_encoded_polyline('_p~iF~ps|U_ulLnnqC_mqNvxq`@'));         
```

**to\$1geojson\$1geometry (SphericalGeography)** — Gibt die angegebene sphärische Geografie im GeoJSON-Format zurück.

```
SELECT to_geojson_geometry(to_spherical_geography(ST_GeometryFromText(
   'LINESTRING (0 0, 1 2, 3 4)')));
```

**from\$1geojson\$1geometry(varchar)** – Gibt das Objekt vom Typ sphärische Geografie aus der GeoJSON-Darstellung zurück und entfernt dabei Schlüssel/Werte, die nicht geometrisch sind. `Feature` und `FeatureCollection` werden nicht unterstützt.

```
SELECT from_geojson_geometry(to_geojson_geometry(to_spherical_geography(ST_GeometryFromText(
   'LINESTRING (0 0, 1 2, 3 4)'))));
```

**geometry\$1nearest\$1points(Geometry, Geometry)** – Gibt die Punkte auf jeder Geometrie zurück, die einander am nächsten liegen. Wenn eine der Geometrien leer ist, wird NULL zurückgegeben. Gibt andernfalls eine Reihe von zwei `Point`-Objekten zurück, die den Mindestabstand von zwei beliebigen Punkten auf den Geometrien aufweisen. Der erste Punkt stammt aus dem ersten Geometrie-Argument, der zweite aus dem zweiten Geometrie-Argument. Bei mehreren Paaren mit gleichem Mindestabstand wird ein Paar willkürlich gewählt.

```
SELECT geometry_nearest_points(ST_GeometryFromText(
   'LINESTRING (50 100, 50 200)'), ST_GeometryFromText(
   'LINESTRING (10 10, 20 20)'));
```

#### Festlegen von Digest-Funktionen
<a name="engine-versions-reference-0003-set-digest-functions"></a>

**make\$1set\$1digest(x)** – Fasst alle Eingabewerte von x in einem setdigest zusammen.

```
SELECT make_set_digest(value) FROM (VALUES 1, 2, 3) T(value);
```

#### Zeichenfolgenfunktionen
<a name="engine-versions-reference-0003-string-functions"></a>

**soundex(char)** – Gibt eine Zeichenfolge zurück, die die phonetische Darstellung von char enthält.

```
SELECT name 
FROM nation 
WHERE SOUNDEX(name) = SOUNDEX('CHYNA'); -- CHINA
```

**concat\$1ws(string0, string1,..., stringN)** – Gibt die Verkettung von `string1, string2, ..., stringN` mit `string0` als Trennzeichen zurück. Wenn `string0` null ist, ist der Rückgabewert null. Alle in den Argumenten nach dem Trennzeichen angegebenen Nullwerte werden übersprungen.

```
SELECT concat_ws(',', 'def', 'pqr', 'mno');
```

#### Fensterfunktionen
<a name="engine-versions-reference-0003-window-functions"></a>

**GROUPS** – Fügt Unterstützung für Fensterrahmen basierend auf Gruppen hinzu.

```
SELECT array_agg(a) OVER(
   ORDER BY a ASC NULLS FIRST GROUPS BETWEEN 1 PRECEDING AND 2 FOLLOWING) 
FROM (VALUES 3, 3, 3, 2, 2, 1, null, null) T(a);
```

### Leistungsverbesserungen
<a name="engine-versions-reference-0003-performance-improvements"></a>

Die Leistungsverbesserungen in Athena-Engine-Version 3 umfassen Folgendes.
+ **Schnellerer Abruf von AWS Glue Tabellenmetadaten** — Bei Abfragen, die mehrere Tabellen betreffen, wird die Planungszeit für Abfragen reduziert.
+ **Dynamische Filterung für RIGHT JOIN** – Die dynamische Filterung ist jetzt für Rechtsverknüpfungen mit Equality-Join-Bedingungen aktiviert, wie im folgenden Beispiel.

  ```
  SELECT * 
  FROM lineitem RIGHT JOIN tpch.tiny.supplier 
  ON lineitem.suppkey = supplier.suppkey 
  WHERE supplier.name = 'abc';
  ```
+ **Große vorbereitete Anweisungen** — Die Standardgröße des request/response HTTP-Headers wurde auf 2 MB erhöht, um umfangreiche vorbereitete Anweisungen zu ermöglichen.
+ **approx\$1percentile ()** – Die `approx_percentile`-Funktion verwendet nun `tdigest` anstelle von `qdigest`, um ungefähre Quantilwerte aus Verteilungen abzurufen. Dies führt zu höherer Leistung und geringerem Speicherverbrauch. Beachten Sie, dass die Funktion aufgrund dieser Änderung andere Ergebnisse liefert als in früheren Engine-Versionen. Weitere Informationen finden Sie unter [Die Funktion approx\$1percentile gibt unterschiedliche Ergebnisse zurück](#engine-versions-reference-0003-approx-percentile-function).

### Verbesserungen der Zuverlässigkeit
<a name="engine-versions-reference-0003-reliability-enhancements"></a>

Die allgemeine Engine-Speichernutzung und -Nachverfolgung in Athena-Engine-Version 3 wurde verbessert. Große Abfragen sind weniger anfällig für Ausfälle durch Knotenabstürze.

### Verbesserungen der Abfragesyntax
<a name="engine-versions-reference-0003-query-syntax-enhancements"></a>

**INTERSECT ALL** – Unterstützung für `INTERSECT ALL` hinzugefügt.

```
SELECT * FROM (VALUES 1, 2, 3, 4) INTERSECT ALL SELECT * FROM (VALUES 3, 4);
```

**EXCEPT ALL** – Unterstützung für `EXCEPT ALL` hinzugefügt.

```
SELECT * FROM (VALUES 1, 2, 3, 4) EXCEPT ALL SELECT * FROM (VALUES 3, 4);
```

**RANGE PRECEDING** – Unterstützung für `RANGE PRECEDING` in Fensterfunktionen hinzugefügt.

```
SELECT sum(x) over (order by x range 1 preceding) 
FROM (values (1), (1), (2), (2)) t(x);
```

**MATCH\$1RECOGNIZE** – Unterstützung für Zeilenmusterabgleich hinzugefügt, wie im folgenden Beispiel gezeigt.

```
SELECT m.id AS row_id, m.match, m.val, m.label 
FROM (VALUES(1, 90),(2, 80),(3, 70),(4, 70)) t(id, value) 
MATCH_RECOGNIZE ( 
        ORDER BY id 
        MEASURES match_number() AS match, 
        RUNNING LAST(value) AS val, 
        classifier() AS label 
        ALL ROWS PER MATCH 
        AFTER MATCH SKIP PAST LAST ROW 
        PATTERN (() | A) DEFINE A AS true 
) AS m;
```

### Verbesserungen des Datenformats und des Datentyps
<a name="engine-versions-reference-0003-data-format-and-data-type-enhancements"></a>

Athena-Engine-Version 3 verfügt über die folgenden Verbesserungen für Datenformat und Datentyp.
+ **LZ4 und ZSTD** — Unterstützung für das Lesen LZ4 und ZSTD-komprimierte Parquet-Daten hinzugefügt. Unterstützung für das Schreiben von ZSTD-komprimierten ORC-Daten hinzugefügt.
+ **Symlink-basierten Tabellen** – Unterstützung für das Erstellen von Symlink-basierten Tabellen in Avro-Dateien hinzugefügt. Ein Beispiel folgt.

  ```
  CREATE TABLE test_avro_symlink  
  ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.avro.AvroSerDe'  
  ... 
  INPUTFORMAT 'org.apache.hadoop.hive.ql.io.SymlinkTextInputFormat'
  ```
+ **SphericalGeography**— Der SphericalGeography Typ bietet native Unterstützung für räumliche Merkmale, die auf geographischen Koordinaten (manchmal auch als geodätische Koordinaten bezeichnet) dargestellt werden. lat/lon, or lon/lat Geografische Koordinaten sind sphärische Koordinaten, die in Winkeleinheiten (Grad) ausgedrückt werden.

  Die `to_spherical_geography`-Funktion gibt geographische (sphärische) Koordinaten aus geometrischen (planaren) Koordinaten zurück, wie im folgenden Beispiel gezeigt.

  ```
  SELECT to_spherical_geography(ST_GeometryFromText(
     'LINESTRING (-40.2 28.9, -40.2 31.9, -37.2 31.9)'));
  ```

## Abwärtskompatible Änderungen
<a name="engine-versions-reference-0003-breaking-changes"></a>

Wenn Sie von frühere Engine-Versionen zu Athena-Engine Version 3 migrieren, können sich bestimmte Änderungen auf das Tabellenschema, die Syntax oder die Verwendung von Datentypen auswirken. Dieser Abschnitt listet die zugehörigen Fehlermeldungen auf und enthält Vorschläge für Problemumgehungen.

### Änderungen der Abfragesyntax
<a name="engine-versions-reference-0003-syntax-changes"></a>

#### IGNORE NULLS kann nicht mit Fensterfunktionen ohne Wert verwendet werden
<a name="engine-versions-reference-0003-remove-ignore-nulls-for-bool_or"></a>

**Fehlermeldung**: Für die `bool_or`-Funktion kann keine Nullbehandlungsklausel angegeben werden.

**Ursache**: `IGNORE NULLS` kann jetzt nur mit den [Wertfunktionen](https://trino.io/docs/current/functions/window.html#value-functions) `first_value`, `last_value`, `nth_value`, `lead` und `lag` verwendet werden. Diese Änderung wurde vorgenommen, um der ANSI-SQL-Spezifikation zu entsprechen.

**Vorgeschlagene Lösung**: Entfernen Sie `IGNORE NULLS` in Abfragezeichenfolgen von Fensterfunktionen ohne Wert.

#### Die CONCAT-Funktion muss über zwei oder mehr Argumente verfügen
<a name="engine-versions-reference-0003-concat-str-minimum-two-args"></a>

**Fehlermeldung**: INVALID\$1FUNCTION\$1ARGUMENT: Es müssen zwei oder mehr Verkettungsargumente vorhanden sein

**Ursache**: Zuvor akzeptierte die `CONCAT`-Zeichenfolgenfunktion ein einzelnes Argument. In Athena-Engine-Version 3 erfordert die `CONCAT`-Funktion mindestens zwei Argumente.

**Lösungsvorschlag**: Ändern Sie das Vorkommen von `CONCAT(str)` auf `CONCAT(str, '')`.

In Athena-Engine-Version 3 können Funktionen nicht mehr als 127 Argumente haben. Weitere Informationen finden Sie unter [Zu viele Argumente für den Funktionsaufruf](troubleshooting-athena.md#troubleshooting-athena-too-many-arguments).

#### Die Funktion approx\$1percentile gibt unterschiedliche Ergebnisse zurück
<a name="engine-versions-reference-0003-approx-percentile-function"></a>

Die `approx_percentile`-Funktion liefert in der Athena-Engine Version 3 andere Ergebnisse als in frühere Engine-Versionen.

**Fehlermeldung**: Keine.

**Ursache**: Die `approx_percentile`-Funktion unterliegt Versionsänderungen.

**Wichtig**  
Da es sich bei den Ausgaben der `approx_percentile`-Funktion um Näherungen handelt und sich die Näherungen von einer Version zur nächsten ändern können, sollten Sie sich bei kritischen Anwendungen nicht auf die `approx_percentile`-Funktion verlassen.

**Vorgeschlagene Lösung**: Um das Verhalten früherer Engine-Versionen von `approx_percentile` anzunähern, können Sie in Athena-Engine Version 3 einen anderen Funktionsumfang verwenden. Angenommen, Sie haben die folgende Abfrage in früheren Engine-Versionen:

```
SELECT approx_percentile(somecol, 2E-1)
```

Um die gleiche Ausgabe in Athena-Engine-Version 3 anzunähern, können Sie die Funktionen `value_at_quantile` und `qdigest_agg` ausprobieren, wie im folgenden Beispiel. Beachten Sie, dass das gleiche Verhalten auch mit dieser Problemumgehung nicht garantiert werden kann.

```
SELECT value_at_quantile(qdigest_agg(somecol, 1), 2E-1)
```

#### Die Geodatenfunktion unterstützt keine varbinary-Eingabe
<a name="engine-versions-reference-0003-geo-spatial-function-does-not-support-varbinary-input"></a>

**Fehlermeldung**: FUNCTION\$1NOT\$1FOUND für st\$1XXX

**Ursache**: Einige Geodatenfunktionen unterstützen den Legacy-Eingabetyp `VARBINARY` oder textbezogene Funktionssignaturen nicht mehr.

**Lösungsvorschlag**: Verwenden Sie Geodatenfunktionen, um die Eingabetypen in unterstützte Typen zu konvertieren. Unterstützte Eingabetypen sind in der Fehlermeldung angegeben.

#### In GROUP-BY-Klauseln müssen verschachtelte Spalten in doppelte Anführungszeichen gesetzt werden
<a name="engine-versions-reference-0003-group-by-nested-columns-require-double-quotes"></a>

**Fehlermeldung**: "*column\$1name*„.“ *nested\$1column*"muss ein Aggregatausdruck sein oder in der GROUP BY-Klausel vorkommen

**Ursache**: Athena-Engine-Version 3 erfordert, dass verschachtelte Spaltennamen in `GROUP BY`-Klauseln in doppelten Anführungszeichen stehen. Beispielsweise erzeugt die folgende Abfrage den Fehler, weil sie in der `GROUP BY`-Klausel `user.name` nicht in doppelten Anführungszeichen steht.

```
SELECT "user"."name" FROM dataset 
GROUP BY user.name
```

**Lösungsvorschlag**: Setzen Sie geschachtelte Spaltennamen in `GROUP BY`-Klauseln in doppelte Anführungszeichen, wie im folgenden Beispiel.

```
SELECT "user"."name" FROM dataset 
GROUP BY "user"."name"
```

#### Unerwarteter FilterNode Fehler bei der Verwendung von OPTIMIZE für eine Iceberg-Tabelle
<a name="engine-versions-reference-0003-iceberg-optimize-where-clause-filters"></a>

**Fehlermeldung**: Unerwarteter Fehler im Plan FilterNode gefunden. Wahrscheinlich konnte der Connector den angegebenen WHERE-Ausdruck nicht verarbeiten.

**Ursache**: Die `OPTIMIZE`-Anweisung, die für die Iceberg-Tabelle ausgeführt wurde, verwendete eine `WHERE`-Klausel, die eine Spalte ohne Partition in ihren Filterausdruck aufnahm.

**Vorgeschlagene Lösung**: Die `OPTIMIZE`-Anweisung unterstützt nur das Filtern nach Partitionen. Wenn Sie `OPTIMIZE` auf partitionierten Tabellen ausführen, nehmen Sie nur Partitionsspalten in die `WHERE`-Klausel auf. Wenn Sie `OPTIMIZE` auf partitionierten Tabellen ausführen, geben Sie keine `WHERE`-Klausel an.

#### Reihenfolge der Argumente der Funktion Log()
<a name="engine-versions-reference-0003-log-function"></a>

In Athena-Engine Version 3 wurde die Reihenfolge der Argumente für die `log()` Funktion gemäß den SQL-Standards auf `log(base, value)` geändert.

#### Die Funktion minute() unterstützt nicht das Intervall Jahr bis Monat
<a name="engine-versions-reference-0003-minute-function"></a>

**Fehlermeldung**: Unerwartete Parameter (Intervall von Jahr zu Monat) für die Funktion Minute. Erwartet: minute(Zeitstempel mit Zeitzone), minute(Zeit mit Zeitzone), minute(Zeitstempel), minute(Zeit), minute(Intervall Tag zu Sekunde).

**Ursache**: In Athena-Engine-Version 3 wurden Typprüfungen für `EXTRACT` gemäß der ANSI-SQL-Spezifikation präzisiert.

**Lösungsvorschlag**: Aktualisieren Sie die Abfragen, um sicherzustellen, dass Typen mit den vorgeschlagenen Funktionssignaturen übereinstimmen.

#### ORDER-BY-Ausdrücke müssen in der SELECT-Liste angezeigt werden
<a name="engine-versions-reference-0003-order-by-expressions-must-appear-in-select-list"></a>

**Fehlermeldung**: Für SELECT DISTINCT müssen ORDER BY-Ausdrücke in der SELECT-Liste angezeigt werden

**Ursache**: In einer `SELECT`-Klausel wird ein falscher Tabellen-Aliasing verwendet.

**Lösungsvorschlag**: Vergewissern Sie sich, dass alle Spalten im `ORDER BY`-Ausdruck die richtigen Verweise in der `SELECT DISTINCT`-Klausel haben.

#### Abfragefehler beim Vergleich mehrerer Spalten, die von einer Unterabfrage zurückgegeben wurden
<a name="engine-versions-reference-0003-subquery-failure-multiple-columns"></a>

**Beispiel für eine Fehlermeldung**: Wertausdruck und Ergebnis der Unterabfrage müssen vom gleichen Typ sein: row(varchar, varchar) vs row(row(varchar, varchar))

**Ursache**: Aufgrund einer Syntaxaktualisierung in Athena-Engine-Version 3 tritt dieser Fehler auf, wenn eine Abfrage versucht, mehrere von einer Unterabfrage zurückgegebene Werte zu vergleichen, und die `SELECT`-Unterabfrage-Anweisung ihre Spaltenliste in Klammern einschließt, wie im folgenden Beispiel. 

```
SELECT *
FROM table1
WHERE (t1_col1, t1_col2)
IN (SELECT (t2_col1, t2_col2) FROM table2)
```

**Lösung**: Entfernen Sie in Athena-Engine-Version 3 die Klammern um die Liste der Spalten in der `SELECT`-Unterabfrageanweisung, wie in der folgenden aktualisierten Beispielabfrage.

```
SELECT *
FROM table1
WHERE (t1_col1, t1_col2)
IN (SELECT t2_col1, t2_col2 FROM table2)
```

#### SKIP ist ein reserviertes Wort für DML-Abfragen
<a name="engine-versions-reference-0003-skip-is-a-reserved-word-for-dml"></a>

Das Wort `SKIP` ist jetzt ein reserviertes Wort für DML-Abfragen wie `SELECT`. Um `SKIP` als Bezeichner in einer DML-Abfrage zu verwenden, schließen Sie es in doppelte Anführungszeichen ein.

Weitere Informationen zu reservierten Wörtern in Athena finden Sie unter [Reservierte Schlüsselwörter in Abfragen umgehen](reserved-words.md).

#### Die Klauseln SYSTEM\$1TIME und SYSTEM\$1VERSION sind für Zeitreisen veraltet
<a name="engine-versions-reference-0003-time-travel-syntax"></a>

**Fehlermeldung**: nicht übereinstimmende Eingabe 'SYSTEM\$1TIME'. Erwartet: 'TIMESTAMP', 'VERSION'

**Ursache**: In früheren Engine-Versionen verwendeten Iceberg-Tabellen die `FOR SYSTEM_TIME AS OF`- und `FOR SYSTEM_VERSION AS OF`-Klauseln für Zeitstempel- und Versionszeitreisen. Athena-Engine-Version 3 verwendet die `FOR TIMESTAMP AS OF`- und `FOR VERSION AS OF`-Klauseln. 

**Lösungsvorschlag**: Aktualisieren Sie die SQL-Abfrage, um die `TIMESTAMP AS OF`- und `VERSION AS OF`-Klauseln für Zeitreiseoperationen zu verwenden, wie in den folgenden Beispielen.

Zeitreise nach Zeitstempel:

```
SELECT * FROM TABLE FOR TIMESTAMP AS OF (current_timestamp - interval '1' day)
```

 Zeitreise nach Version:

```
SELECT * FROM TABLE FOR VERSION AS OF 949530903748831860
```

#### Zu viele Argumente für einen Array-Konstruktor
<a name="engine-versions-reference-0003-array-max-elements"></a>

**Fehlermeldung**: TOO\$1MANY\$1ARGUMENTS: Zu viele Argumente für den Array-Konstruktor.

**Ursache**: Die maximale Anzahl von Elementen in einem Array-Konstruktor ist jetzt auf 254 festgelegt.

**Vorgeschlagene Lösung**: Teilen Sie die Elemente in mehrere Arrays auf, die jeweils 254 oder weniger Elemente enthalten, und verwenden Sie die `CONCAT`-Funktion, um die Arrays zu verketten, wie im folgenden Beispiel gezeigt.

```
CONCAT(
ARRAY[x1,x2,x3...x254],
ARRAY[y1,y2,y3...y254],
...
)
```

#### Bezeichner mit Null-Längenbegrenzung ist nicht zulässig
<a name="engine-versions-reference-0003-zero-length-delimited-identifier"></a>

**Fehlermeldung**: Durch Null getrennte Kennung nicht zulässig.

**Ursache**: Eine Abfrage verwendete eine leere Zeichenfolge als Spalten-Alias.

**Lösungsvorschlag**: Aktualisieren Sie die Abfrage so, dass für die Spalte ein nicht leerer Alias verwendet wird.

### Änderungen der Datenverarbeitung
<a name="engine-versions-reference-0003-data-processing-changes"></a>

#### Bucket-Validierung
<a name="engine-versions-reference-0003-bucket-validation"></a>

**Fehlermeldung**: HIVE\$1INVALID\$1BUCKET\$1FILES: Die Hive-Tabelle ist beschädigt.

**Ursache**: Die Tabelle ist möglicherweise beschädigt. Um die Richtigkeit der Abfragen für Bucket-Tabellen sicherzustellen, ermöglicht die Athena-Engine-Version 3 eine zusätzliche Validierung von Bucket-Tabellen, um die Richtigkeit der Abfragen sicherzustellen und unerwartete Fehler zur Laufzeit zu vermeiden.

**Vorgeschlagene Lösung**: Erstellen Sie die Tabelle mit Athena-Engine-Version 3 neu.

#### Das Umwandeln einer Struktur in JSON gibt jetzt Feldnamen zurück
<a name="engine-versions-reference-0003-cast-struct-to-json"></a>

Wenn Sie in Athena-Engine-Version 3 in einer `SELECT`-Abfrage ein `struct` in JSON umwandeln, gibt die Umwandlung jetzt sowohl die Feldnamen als auch die Werte (z. B. `useragent":null`) statt nur die Werte (z. B. `null`) zurück.

#### Änderung der Sicherheitserzwingung auf Spaltenebene der Iceberg-Tabelle
<a name="engine-versions-reference-0003-iceberg-column-security"></a>

**Fehlermeldung**: Zugriff verweigert: Kann nicht aus Spalten ausgewählt werden

**Ursache**: Die Iceberg-Tabelle wurde außerhalb von Athena erstellt und verwendet eine [Apache Iceberg SDK](https://iceberg.apache.org/releases/)-Version vor 0.13.0. Da frühere SDK-Versionen keine Spalten auffüllen AWS Glue, konnte Lake Formation die für den Zugriff autorisierten Spalten nicht ermitteln.

**Lösungsvorschlag**: Führen Sie ein Update mit der [ALTER TABLE SET TBLPROPERTIES](querying-iceberg-alter-table-set-properties.md)-Anweisung von Athena durch oder verwenden Sie das neueste Iceberg-SDK, um die Tabelle zu reparieren und die Spalteninformationen in AWS Glue zu aktualisieren.

#### Nullen in List-Datentypen werden jetzt weitergegeben an UDFs
<a name="engine-versions-reference-0003-nulls-in-list-datatypes-for-udfs"></a>

**Fehlermeldung**: Null-Zeiger-Ausnahme

**Ursache**: Dieses Problem kann Sie betreffen, wenn Sie den UDF-Konnektor verwenden und eine benutzerdefinierte Lambda-Funktion implementiert haben.

Die frühere Engine-Version hat die Nullen in Listendatentypen herausgefiltert, die an eine benutzerdefinierte Funktion übergeben wurden. In Athena-Engine-Version 3 werden die Nullen jetzt beibehalten und an die UDF weitergegeben. Dies kann zu einer Null-Zeiger-Ausnahme führen, wenn die UDF versucht, das Null-Element ohne Überprüfung zu dereferenzieren.

Wenn sich beispielsweise die Daten `[null, 1, null, 2, 3, 4]` in einer Ursprungsdatenquelle wie DynamoDB befinden, werden die folgenden Daten an die benutzerdefinierte Lambda-Funktion übergeben:

**Athena-Engine-Version 3**: `[null, 1, null, 2, 3, 4]`

**Lösungsvorschlag**: Stellen Sie sicher, dass Ihre benutzerdefinierte Lambda-Funktion Nullelemente in Listendatentypen verarbeitet.

#### Teilzeichenfolgen aus Zeichen-Arrays enthalten keine aufgefüllten Leerzeichen mehr
<a name="engine-versions-reference-0003-substring-no-padded-spaces"></a>

**Fehlermeldung**: Es wird kein Fehler ausgegeben, aber die zurückgegebene Zeichenfolge enthält keine aufgefüllten Leerzeichen mehr. Beispielsweise gibt `substr(char[20],1,100)` jetzt eine Zeichenfolge mit der Länge 20 statt 100 zurück.

**Lösungsvorschlag**: Es sind keine Maßnahmen erforderlich.

#### Nicht unterstützte Umwandlung des Dezimalspaltentyps
<a name="engine-versions-reference-0003-unsupported-column-type"></a>

**Fehlermeldungen**: HIVE\$1CURSOR\$1ERROR: Parquet-Datei konnte nicht gelesen werden: s3://amzn-s3-demo-bucket/*path*/*file\$1name*.parquet oder Der Spaltentyp (varchar) für die Parquet-Spalte ([] wird nicht unterstützt *column\$1name*

**Ursache**: Athena-Engine-Version 2 war gelegentlich erfolgreich (schlug aber häufig fehl), wenn versucht wurde, Datentypzwänge von `varchar` zu dezimal zu ändern. Da die Athena-Engine-Version 3 über eine Typüberprüfung verfügt, die die Kompatibilität des Typs prüft, bevor sie versucht, den Wert zu lesen, schlagen solche Zwangsverknüpfungen jetzt immer fehl.

**Vorgeschlagene Lösung**: Ändern Sie für Athena-Engine-Version 3 Ihr Schema so, AWS Glue dass es einen numerischen Datentyp anstelle von `varchar` Dezimalspalten in Parquet-Dateien verwendet. Durchforsten Sie entweder die Daten erneut und stellen Sie sicher, dass der neue Spaltendatentyp ein Dezimaltyp ist, oder erstellen Sie die Tabelle in Athena manuell neu und verwenden Sie die Syntax `decimal(precision, scale)`, um einen [decimal](data-types.md#data-types-decimal)-Datentyp für die Spalte anzugeben.

#### Float- oder Double-NaN-Werte können nicht mehr in bigint umgewandelt werden
<a name="engine-versions-reference-0003-no-nan-to-bigint"></a>

**Fehlermeldung**: INVALID\$1CAST\$1ARGUMENT: NaN kann nicht in Bigint umgewandelt werden real/double 

**Ursache**: `NaN` kann in Athena-Engine-Version 3 nicht mehr auf 0 als `bigint` gecastet werden als.

**Lösungsvorschlag**: Stellen Sie sicher, dass beim Umwandeln in `bigint` keine `NaN`-Werte in den Spalten `double` oder `float` vorhanden sind.

#### Änderung des Rückgabetyps der Funktion uuid ()
<a name="engine-versions-reference-0003-uuid-function-return-type-change"></a>

Das folgende Problem betrifft sowohl Tabellen als auch Ansichten.

**Fehlermeldung**: Hive-Typ: uuid wird nicht unterstützt

**Ursache**: In früheren Engine-Versionen gab die `uuid()`-Funktion eine Zeichenfolge zurück, aber in Athena-Engine-Version 3 gibt sie eine zufällig generierte Pseudo-UUID (Typ 4) zurück. Da der UUID-Spaltendatentyp in Athena nicht unterstützt wird, kann die `uuid()`-Funktion in Athena-Engine-Version 3 nicht mehr direkt in CTAS-Abfragen zum Generieren von UUID-Spalten verwendet werden.

Die folgende `CREATE TABLE`-Anweisung wird beispielsweise in früheren Engine-Versionen erfolgreich abgeschlossen, gibt aber NOT\$1SUPPORTED: Nicht unterstützter Hive-Type: uuid in Athena-Engine Version 3:

```
CREATE TABLE uuid_table AS 
   SELECT uuid() AS myuuid
```

In ähnlicher Weise wird die folgende Anweisung `CREATE VIEW` in Athena-Engine-Version 2 erfolgreich abgeschlossen, gibt aber den ungültigen Spaltentyp für die Spalte myuuid zurück: Nicht unterstützter Hive-Typ: uuid in Athena-Engine-Version 3:

```
CREATE VIEW uuid_view AS 
   SELECT uuid() AS myuuid
```

Wenn eine so in früheren Engine-Versionen erstellte Ansicht in Athena-Engine-Version 3 abgefragt wird, tritt ein Fehler wie der folgende auf:

VIEW\$1IS\$1STALE: Zeile 1:15: Die Ansicht 'awsdatacatalog.mydatabase.uuid\$1view' ist veraltet oder befindet sich in einem ungültigen Zustand: Die Spalte [myuuid] vom Typ uuid, die von der Abfrageansicht an Position 0 projiziert wird, kann nicht in die Spalte [myuuid] vom Typ varchar, die in der Ansichtsdefinition gespeichert ist, umgewandelt werden

**Vorgeschlagene Lösung**: Verwenden Sie beim Erstellen der Tabelle oder Ansicht die `cast()`-Funktion, um die Ausgabe von `uuid()` in ein `varchar` zu konvertieren, wie in den folgenden Beispielen:

```
CREATE TABLE uuid_table AS
   SELECT CAST(uuid() AS VARCHAR) AS myuuid
```

```
CREATE VIEW uuid_view AS
   SELECT CAST(uuid() AS VARCHAR) AS myuuid
```

#### Probleme mit Zwangsmaßnahmen bei CHAR und VARCHAR
<a name="engine-versions-reference-0003-char-varchar-coercion-issues"></a>

Verwenden Sie die Problemumgehungen in diesem Abschnitt, wenn Sie mit `varchar` und `char` in der Athena-Engine-Version 3 auf Zwangsprobleme stoßen. Wenn Sie diese Problemumgehungen nicht verwenden können, wenden Sie sich bitte an. Support

##### CONCAT-Funktionsfehler bei gemischten CHAR- und VARCHAR-Eingaben
<a name="engine-versions-reference-0003-concat-function-failure"></a>

**Problem**: Die folgende Abfrage ist auf Athena-Engine-Version 2 erfolgreich.

```
SELECT concat(CAST('abc' AS VARCHAR(20)), '12', CAST('a' AS CHAR(1)))
```

In der Athena-Engine-Version 3 schlägt dieselbe Abfrage jedoch wie folgt fehl:

**Fehlermeldung**: FUNCTION\$1NOT\$1FOUND: Zeile 1:8: Unerwartete Parameter (varchar(20), varchar(2), char(1)) für die Funktion concat. Erwartet: concat (char (x), char (y)), concat (array (E), E) E, concat (E, array (E)) E, concat (array (E)) E, concat (array (E)) E, concat (varchar), concat (varbinary)

**Vorgeschlagene Lösung**: Wenn Sie die `concat`-Funktion verwenden, konvertieren Sie entweder in `char` oder `varchar`, aber nicht in eine Mischung aus beidem.

##### SQL \$1\$1 Fehler bei der Verkettung mit CHAR- und VARCHAR-Eingaben
<a name="engine-versions-reference-0003-double-pipe-char-varchar-failure"></a>

In der Athena-Engine-Version 3 erfordert der `||`-Operator für die Verkettung von doppelten vertikalen Balken `varchar` als Eingaben. Bei den Eingaben darf es sich nicht um eine Kombination von `varchar`- und `char`-Typen handeln.

**Fehlermeldung**: TYPE\$1NOT\$1FOUND: Zeile 1:26: Unbekannter Typ: char(65537) 

**Ursache**: Eine Abfrage, die `||` verwendet, um ein `char` und ein `varchar` zu verketten, kann zu dem Fehler führen, wie im folgenden Beispiel.

```
SELECT CAST('a' AS CHAR) || CAST('b' AS VARCHAR)
```

**Vorgeschlagene Lösung**: Verketten Sie `varchar` mit `varchar`, wie im folgenden Beispiel.

```
SELECT CAST('a' AS VARCHAR) || CAST('b' AS VARCHAR) 
```

##### Fehler bei der CHAR- und VARCHAR-UNION-Abfrage
<a name="engine-versions-reference-0003-char-varchar-union-query-failure"></a>

**Fehlermeldung**: NOT\$1SUPPORTED: Hive-Typ wird nicht unterstützt: char(65536). Unterstützte CHAR-Typen: CHAR(<=255) 

**Ursache**: Eine Abfrage, die versucht, `char` und `varchar` zu kombinieren, wie im folgenden Beispiel:

```
CREATE TABLE t1 (c1) AS SELECT CAST('a' as CHAR) as c1 UNION ALL SELECT CAST('b' AS VARCHAR) AS c1 
```

**Vorgeschlagene Lösung**: Verwenden Sie in der Beispielabfrage die `'a'`-Umwandlung zu `varchar` und nicht `char`. 

##### Unerwünschte Leerzeichen nach CHAR- oder VARCHAR-Zwang
<a name="engine-versions-reference-0003-empty-spaces-added-after-coercion"></a>

In Athena-Engine-Version 3 ist der Zieltyp, wenn `char(X)`- und `varchar`-Daten bei der Bildung eines Arrays oder einer einzelnen Spalte zu einem einzigen Typ gezwungen werden `char(65535)` und jedes Feld enthält viele unerwünschte Leerzeichen am Ende.

**Ursache**: Athena-Engine-Version 3 wandelt `varchar` und `char(X)` zu `char(65535)` und füllt die Daten dann nach rechts mit Leerzeichen auf.

**Vorgeschlagene Lösung**: Wandeln Sie jedes Feld explizit in `varchar` um.

### Änderungen des Zeitstempels
<a name="engine-versions-reference-0003-timestamp-changes"></a>

#### Überlauf des Datums-Zeitstempels löst Fehler aus
<a name="engine-versions-reference-0003-date-timestamp-overflow"></a>

**Fehlermeldung**: Millis-Überlauf: XXX

**Ursache**: Da ISO 8601-Datumsangaben in früheren Engine-Versionen nicht auf Überlauf geprüft wurden, erzeugten einige Daten einen negativen Zeitstempel. Athena-Engine-Version 3 prüft auf diesen Überlauf und löst eine Ausnahme aus.

**Lösungsvorschlag**: Stellen Sie sicher, dass der Zeitstempel innerhalb des Bereichs liegt.

#### Politische Zeitzonen mit TIME werden nicht unterstützt
<a name="engine-versions-reference-0003-political-time-zones"></a>

**Fehlermeldung**: INVALID LITERAL

**Ursache**: Abfragen wie `SELECT TIME '13:21:32.424 America/Los_Angeles'`.

**Lösungsvorschlag**: Vermeiden Sie die Verwendung politischer Zeitzonen mit `TIME`.

#### Genauigkeitsabweichung in Timestamp-Spalten verursacht Serialisierungsfehler
<a name="engine-versions-reference-0003-timestamp-precision-serialization-error"></a>

**Fehlermeldung**: SERIALIZATION\$1ERROR: Die Spalte '' vom Typ 'timestamp (3) *COLUMNZ* 'konnte an der folgenden Position nicht serialisiert werden: *X* *Y*

*COLUMNZ*ist der Ausgabename der Spalte, die das Problem verursacht. Die Zahlen*X*: *Y* geben die Position der Spalte in der Ausgabe an.

**Ursache**: Athena-Engine-Version 3 prüft, ob die Genauigkeit der Zeitstempel in den Daten mit der Genauigkeit übereinstimmt, die für den Spaltendatentyp in der Tabellenspezifikation angegeben ist. Derzeit liegt diese Genauigkeit immer bei 3. Wenn die Daten eine höhere Genauigkeit aufweisen, schlagen Abfragen mit dem angegebenen Fehler fehl.

**Lösungsvorschlag**: Überprüfen Sie Ihre Daten, um sicherzustellen, dass Ihre Zeitstempel auf die Millisekunde genau sind.

#### Falsche Zeitstempelgenauigkeit in UNLOAD- und CTAS-Abfragen für Iceberg-Tabellen
<a name="engine-versions-reference-0003-timestamp-precision-unload-ctas-iceberg"></a>

**Fehlermeldung**: Falsche Zeitstempelgenauigkeit für Zeitstempel(6); die konfigurierte Genauigkeit ist MILLISEKUNDEN

**Ursache**: Athena-Engine-Version 3 prüft, ob die Genauigkeit der Zeitstempel in den Daten mit der Genauigkeit übereinstimmt, die für den Spaltendatentyp in der Tabellenspezifikation angegeben ist. Derzeit liegt diese Genauigkeit immer bei 3. Wenn die Daten eine höhere Genauigkeit haben (z. B. Mikrosekunden statt Millisekunden), können Abfragen mit dem angegebenen Fehler fehlschlagen.

**Lösung**: Um dieses Problem zu umgehen, `CAST` Sie zunächst die Genauigkeit des Zeitstempels auf 6 ein, wie im folgenden CTAS-Beispiel, das eine Iceberg-Tabelle erstellt. Beachten Sie, dass die Genauigkeit mit 6 statt mit 3 angegeben werden muss, um den Fehler Zeitstempelpräzision (3) nicht unterstützt für Iceberg zu vermeiden.

```
CREATE TABLE my_iceberg_ctas
WITH (table_type = 'ICEBERG', location = 's3://amzn-s3-demo-bucket/table_ctas/',
format = 'PARQUET')
AS SELECT id, CAST(dt AS timestamp(6)) AS "dt"
FROM my_iceberg
```

Da Athena Zeitstempel 6 nicht unterstützt, wandeln Sie den Wert dann erneut in Zeitstempel um (z. B. in einer Ansicht). Das folgende Beispiel erstellt eine Ansicht aus der `my_iceberg_ctas`-Tabelle.

```
CREATE OR REPLACE VIEW my_iceberg_ctas_view AS
SELECT cast(dt AS timestamp) AS dt
FROM my_iceberg_ctas
```

#### Das Lesen des Long-Typs als Zeitstempel in ORC-Dateien verursacht jetzt einen Fehler „fehlerhafte-ORC-Datei“
<a name="engine-versions-reference-0003-orc-no-implicit-long-to-timestamp-coercion"></a>

**Fehlermeldung**: Fehler beim Öffnen von Hive Split ‘FILE (SPLIT POSITION)’ Fehlerhafte ORC-Datei. Der Zeitstempel des SQL-Typs kann nicht aus dem ORC-Stream .long\$1type vom Typ LONG gelesen werden

**Ursache**: Athena-Engine-Version 3 lehnt nun impliziten Zwang vom `Long`-Datentyp zu `Timestamp` oder von `Timestamp` zu `Long` ab. Zuvor wurden `Long`-Werte implizit in Zeitstempel umgewandelt, als wären sie Epochen-Millisekunden.

**Lösungsvorschlag**: Verwenden Sie die `from_unixtime`-Funktion, um die Spalte explizit umzuwandeln, oder verwenden Sie die `from_unixtime`-Funktion, um eine zusätzliche Spalte für zukünftige Abfragen zu erstellen.

#### Zeit und Intervall von Jahr zu Monat werden nicht unterstützt
<a name="engine-versions-reference-0003-time-and-interval-year-to-month"></a>

**Fehlermeldung**: TYPE MISMATCH

**Ursache**: Athena-Engine-Version 3 unterstützt Zeit und Intervall von Jahr zu Monat nicht (z. B. `SELECT TIME '01:00' + INTERVAL '3' MONTH`).

#### Zeitstempelüberlauf für das int96-Parquet-Format
<a name="engine-versions-reference-0003-timestamp-overflow-for-int96-parquet-format"></a>

**Fehlermeldung**: Ungültige timeOfDay Nanos

**Ursache**: Ein Zeitstempelüberlauf für das `int96`-Parquet-Format.

**Lösungsvorschlag**: Identifizieren Sie die spezifischen Dateien, bei denen das Problem auftritt. Generieren Sie dann die Datendatei erneut mit einer up-to-date bekannten Parquet-Bibliothek oder verwenden Sie Athena CTAS. Wenn das Problem weiterhin besteht, wenden Sie sich an den Athena-Support und teilen Sie uns mit, wie die Datendateien generiert werden.

#### Bei der Umwandlung von einer Zeichenfolge in einen Zeitstempel ist Platz zwischen Datums- und Uhrzeitwerten erforderlich
<a name="engine-versions-reference-0003-timestamp-cast-space"></a>

**Fehlermeldung**: INVALID\$1CAST\$1ARGUMENT: Der Wert kann nicht in einen Zeitstempel umgewandelt werden.

**Ursache**: Athena-Engine-Version 3 akzeptiert keinen Bindestrich mehr als gültiges Trennzeichen zwischen Datums- und Uhrzeitwerten in der Eingabezeichenfolge zu `cast`. Zum Beispiel, folgende Abfrage funktioniert nicht in Athena-Engine Version 3:

```
SELECT CAST('2021-06-06-23:38:46' AS timestamp) AS this_time
```

**Vorgeschlagene Lösung**: Ersetzen Sie in Athena-Engine-Version 3 den Bindestrich zwischen Datum und Uhrzeit durch ein Leerzeichen, wie im folgenden Beispiel.

```
SELECT CAST('2021-06-06 23:38:46' AS timestamp) AS this_time
```

#### Änderung des Zeitstempel-Rückgabewerts von to\$1iso8601 ()
<a name="engine-versions-reference-0003-to-iso8601-function"></a>

**Fehlermeldung**: Keine.

**Ursache**: In früheren Engine-Versionen gibt die `to_iso8601`-Funktion einen Zeitstempel mit Zeitzone zurück, auch wenn der an die Funktion übergebene Wert die Zeitzone nicht enthält. In Athena-Engine-Version 3 gibt die `to_iso8601`-Funktion nur dann einen Zeitstempel mit Zeitzone zurück, wenn das übergebene Argument die Zeitzone enthält.

Die folgende Abfrage übergibt beispielsweise das aktuelle Datum zweimal an die `to_iso8601`-Funktion: zuerst als Zeitstempel mit Zeitzone und dann als Zeitstempel.

```
SELECT TO_ISO8601(CAST(CURRENT_DATE AS TIMESTAMP WITH TIME ZONE)), TO_ISO8601(CAST(CURRENT_DATE AS TIMESTAMP))
```

Die folgende Ausgabe zeigt das Ergebnis der Abfrage in der Athen-Engine Version 3.

In früheren Engine-Versionen:


****  

| \$1 | \$1col0 | \$1col1 | 
| --- | --- | --- | 
| 1 |  `2023-02-24T00:00:00.000Z `  |  `2023-02-24T00:00:00.000Z`  | 

Athena-Engine-Version 3


****  

| \$1 | \$1col0 | \$1col1 | 
| --- | --- | --- | 
| 1 |  `2023-02-24T00:00:00.000Z`  |  `2023-02-24T00:00:00.000`  | 

**Lösungsvorschlag**: Um das vorherige Verhalten zu replizieren, können Sie den Zeitstempelwert an die `with_timezone`-Funktion übergeben, bevor Sie ihn an `to_iso8601` übergeben, wie im folgenden Beispiel: 

```
SELECT to_iso8601(with_timezone(TIMESTAMP '2023-01-01 00:00:00.000', 'UTC'))
```

Ergebnis


****  

| \$1 | \$1col0 | 
| --- | --- | 
| 1 |  2023-01-01T00:00:00.000Z  | 

#### Der erste Parameter at\$1timezone () muss ein Datum angeben
<a name="engine-versions-reference-at-timezone-function"></a>

**Problem**: In Athena-Engine-Version 3 kann die `at_timezone`-Funktion keinen `time_with_timezone`-Wert als ersten Parameter annehmen.

**Ursache**: Ohne Datumsinformationen kann nicht festgestellt werden, ob es sich bei dem übergebenen Wert um Sommerzeit oder Normalzeit handelt. `at_timezone('12:00:00 UTC', 'America/Los_Angeles')` ist beispielsweise mehrdeutig, da nicht bestimmt werden kann, ob es sich bei dem übergebenen Wert um Pacific Daylight Time (PDT) oder Pacific Standard Time (PST) handelt.

## Einschränkungen
<a name="engine-versions-reference-0003-known-limitations"></a>

Athena-Engine-Version 3 weist die folgenden Einschränkungen auf.
+ **Abfrageleistung** – Viele Abfragen werden mit der Athena-Engine Version 3 schneller ausgeführt, aber einige Abfragepläne können sich von denen der früheren Engine-Versionen unterscheiden. Daher können sich einige Abfragen in Bezug auf Latenz oder Kosten unterscheiden.
+ **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).
+ **Fehlertolerante Ausführung** – Die [fehlertolerante Ausführung](https://trino.io/docs/current/admin/fault-tolerant-execution.html) von Trino (Trino Tardigrade) wird nicht unterstützt.
+ **Grenzwert für Funktionsparameter** – Funktionen können nicht mehr als 127 Parameter annehmen. Weitere Informationen finden Sie unter [Zu viele Argumente für den Funktionsaufruf](troubleshooting-athena.md#troubleshooting-athena-too-many-arguments).

Die folgenden Grenzwerte wurden in Athena-Engine-Version 2 eingeführt, um sicherzustellen, dass Abfragen aufgrund von Ressourcenbeschränkungen nicht fehlschlagen. Diese Grenzwerte sind von Benutzern nicht konfigurierbar.
+ **Anzahl der Ergebniselemente** – Die Anzahl der Ergebniselemente `n` ist für die folgenden Funktionen auf 10.000 oder weniger beschränkt: `min(col, n)`, `max(col, n)`, `min_by(col1, col2, n)` und `max_by(col1, col2, n)`.
+ **GROUPING SETS** – Die maximale Anzahl von Slices in einem Gruppierungssatz ist 2048.
+ **Maximale Zeilenlänge der Textdatei** – Die standardmäßige maximale Zeilenlänge für Textdateien beträgt 200 MB.
+ **Sequenzfunktion maximale Ergebnisgröße** – Die maximale Ergebnisgröße einer Sequenzfunktion beträgt 50000 Einträge. Zum Beispiel ist `SELECT sequence(0,45000,1)` erfolgreich, aber `SELECT sequence(0,55000,1)` schlägt mit der Fehlermeldung fehl. Das Ergebnis der Sequenzfunktion darf nicht mehr als 50000 Einträge haben. Diese Beschränkung gilt für alle Eingabetypen für Sequenzfunktionen, auch für Zeitstempel.