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.
# Arrays abfragen
Sie können mit Amazon Athena Arrays erstellen, sie verketten, in andere Datentypen umwandeln und anschließend filtern, reduzieren und sortieren.
**Topics**
+ [Arrays erstellen](creating-arrays.md)
+ [Zeichenfolgen und Arrays verketten](concatenating-strings-and-arrays.md)
+ [Array-Datentypen konvertieren](converting-array-data-types.md)
+ [Array-Längen ermitteln](finding-lengths.md)
+ [Auf Array-Elemente zugreifen](accessing-array-elements.md)
+ [Verschachtelte Arrays abflachen](flattening-arrays.md)
+ [Erstellen von Arrays aus Unterabfragen](creating-arrays-from-subqueries.md)
+ [Filtern von Arrays](filtering-arrays.md)
+ [Arrays sortieren](sorting-arrays.md)
+ [Aggregations-Funktionen mit Arrays verwenden](arrays-and-aggregation.md)
+ [Arrays in Zeichenfolgen konvertieren](converting-arrays-to-strings.md)
+ [Arrays zum Erstellen von Karten verwenden](arrays-create-maps.md)
+ [Abfragen von Arrays mit komplexen Typen](rows-and-structs.md)
# Arrays erstellen
Zum Erstellen eines Arrayliterals in Athena verwenden Sie das Schlüsselwort `ARRAY`, gefolgt von Klammern `[ ]`, und schließen die durch Kommata getrennten Array-Elemente ein.
## Beispiele
Diese Abfrage erstellt ein Array mit vier Elementen.
```
SELECT ARRAY [1,2,3,4] AS items
```
Folgendes wird zurückgegeben:
```
+-----------+
| items |
+-----------+
| [1,2,3,4] |
+-----------+
```
Diese Abfrage erstellt zwei Arrays.
```
SELECT ARRAY[ ARRAY[1,2], ARRAY[3,4] ] AS items
```
Folgendes wird zurückgegeben:
```
+--------------------+
| items |
+--------------------+
| [[1, 2], [3, 4]] |
+--------------------+
```
Zum Erstellen eines Arrays aus ausgewählten Spalten kompatibler Typen nutzen Sie eine Abfrage, wie im folgenden Beispiel gezeigt:
```
WITH
dataset AS (
SELECT 1 AS x, 2 AS y, 3 AS z
)
SELECT ARRAY [x,y,z] AS items FROM dataset
```
Diese Abfrage gibt Folgendes zurück:
```
+-----------+
| items |
+-----------+
| [1,2,3] |
+-----------+
```
Im folgenden Beispiel werden zwei Arrays ausgewählt und in Form einer Willkommensnachricht zurückgegeben.
```
WITH
dataset AS (
SELECT
ARRAY ['hello', 'amazon', 'athena'] AS words,
ARRAY ['hi', 'alexa'] AS alexa
)
SELECT ARRAY[words, alexa] AS welcome_msg
FROM dataset
```
Diese Abfrage gibt Folgendes zurück:
```
+----------------------------------------+
| welcome_msg |
+----------------------------------------+
| [[hello, amazon, athena], [hi, alexa]] |
+----------------------------------------+
```
Zum Erstellen eines Arrays aus Schlüssel/Wert-Paaren nutzen Sie den `MAP`-Operator. Dieser verwendet ein Schlüssel-Array gefolgt von einem Werte-Array, wie im folgenden Beispiel gezeigt:
```
SELECT ARRAY[
MAP(ARRAY['first', 'last', 'age'],ARRAY['Bob', 'Smith', '40']),
MAP(ARRAY['first', 'last', 'age'],ARRAY['Jane', 'Doe', '30']),
MAP(ARRAY['first', 'last', 'age'],ARRAY['Billy', 'Smith', '8'])
] AS people
```
Diese Abfrage gibt Folgendes zurück:
```
+-----------------------------------------------------------------------------------------------------+
| people |
+-----------------------------------------------------------------------------------------------------+
| [{last=Smith, first=Bob, age=40}, {last=Doe, first=Jane, age=30}, {last=Smith, first=Billy, age=8}] |
+-----------------------------------------------------------------------------------------------------+
```
# Zeichenfolgen und Arrays verketten
Beim Verketten von Zeichenfolgen und beim Verketten von Arrays werden ähnliche Techniken verwendet.
## Zeichenfolgen verketten
Um zwei Zeichenfolgen zu verketten, können Sie doppelte Pipe-`||`-Operator verwenden, wie im folgenden Beispiel gezeigt.
```
SELECT 'This' || ' is' || ' a' || ' test.' AS Concatenated_String
```
Diese Abfrage gibt Folgendes zurück:
****
| \$1 | Concatenated\$1String |
| --- | --- |
| 1 | `This is a test.` |
Sie können die `concat()`-Funktion verwenden, um dasselbe Ergebnis zu erzielen.
```
SELECT concat('This', ' is', ' a', ' test.') AS Concatenated_String
```
Diese Abfrage gibt Folgendes zurück:
****
| \$1 | Concatenated\$1String |
| --- | --- |
| 1 | `This is a test.` |
Sie können die `concat_ws()`-Funktion verwenden, um Zeichenketten mit dem im ersten Argument angegebenen Trennzeichen zu verketten.
```
SELECT concat_ws(' ', 'This', 'is', 'a', 'test.') as Concatenated_String
```
Diese Abfrage gibt Folgendes zurück:
****
| \$1 | Concatenated\$1String |
| --- | --- |
| 1 | `This is a test.` |
Um zwei Spalten des Datentyps „Zeichenfolge“ mit einem Punkt zu verketten, verweisen Sie mit doppelten Anführungszeichen auf die beiden Spalten und schließen Sie den Punkt als hartcodierte Zeichenfolge in einfache Anführungszeichen ein. Wenn eine Spalte nicht vom Datentyp „Zeichenfolge“ ist, können Sie `CAST("column_name" as VARCHAR)` verwenden, um die Spalte zuerst umzuwandeln.
```
SELECT "col1" || '.' || "col2" as Concatenated_String
FROM my_table
```
Diese Abfrage gibt Folgendes zurück:
****
| \$1 | Concatenated\$1String |
| --- | --- |
| 1 | `col1_string_value.col2_string_value` |
## Arrays verketten
Sie können die gleichen Techniken verwenden, um Arrays zu verketten.
Verwenden Sie zum Verketten von mehreren Arrays den doppelten Pipe-Operator `||`.
```
SELECT ARRAY [4,5] || ARRAY[ ARRAY[1,2], ARRAY[3,4] ] AS items
```
Diese Abfrage gibt Folgendes zurück:
****
| \$1 | Elemente |
| --- | --- |
| 1 | `[[4, 5], [1, 2], [3, 4]]` |
Um mehrere Arrays zu einem einzigen Array zu kombinieren, verwenden Sie den Doppelpipe-Operator oder die `concat()`-Funktion.
```
WITH
dataset AS (
SELECT
ARRAY ['Hello', 'Amazon', 'Athena'] AS words,
ARRAY ['Hi', 'Alexa'] AS alexa
)
SELECT concat(words, alexa) AS welcome_msg
FROM dataset
```
Diese Abfrage gibt Folgendes zurück:
****
| \$1 | welcome\$1msg |
| --- | --- |
| 1 | `[Hello, Amazon, Athena, Hi, Alexa]` |
Weitere Informationen zum `concat()` anderer Zeichenfolgenfunktionen finden Sie unter [Zeichenfolgenfunktionen und -operatoren](https://trino.io/docs/current/functions/string.html) in der Trino-Dokumentation.
# Array-Datentypen konvertieren
Um Daten in einem Array in einen unterstützten Datentyp zu konvertieren, verwenden Sie den `CAST`-Operator als `CAST(value AS type)`. Athena unterstützt alle nativen Presto-Datentypen.
```
SELECT
ARRAY [CAST(4 AS VARCHAR), CAST(5 AS VARCHAR)]
AS items
```
Diese Abfrage gibt Folgendes zurück:
```
+-------+
| items |
+-------+
| [4,5] |
+-------+
```
Erstellen Sie zwei Arrays mit Schlüssel-Wert-Paar-Elementen, konvertieren Sie sie zu JSON und verketten Sie sie wie in diesem Beispiel:
```
SELECT
ARRAY[CAST(MAP(ARRAY['a1', 'a2', 'a3'], ARRAY[1, 2, 3]) AS JSON)] ||
ARRAY[CAST(MAP(ARRAY['b1', 'b2', 'b3'], ARRAY[4, 5, 6]) AS JSON)]
AS items
```
Diese Abfrage gibt Folgendes zurück:
```
+--------------------------------------------------+
| items |
+--------------------------------------------------+
| [{"a1":1,"a2":2,"a3":3}, {"b1":4,"b2":5,"b3":6}] |
+--------------------------------------------------+
```
# Array-Längen ermitteln
Die Funktion `cardinality` gibt die Länge eines Arrays wie in diesem Beispiel zurück:
```
SELECT cardinality(ARRAY[1,2,3,4]) AS item_count
```
Diese Abfrage gibt Folgendes zurück:
```
+------------+
| item_count |
+------------+
| 4 |
+------------+
```
# Auf Array-Elemente zugreifen
Verwenden Sie für den Zugriff auf Array-Elemente den `[]`-Operator, wobei 1 das erste Elemente bezeichnet, 2 das zweite Elemente usw., wie im folgenden Beispiel:
```
WITH dataset AS (
SELECT
ARRAY[CAST(MAP(ARRAY['a1', 'a2', 'a3'], ARRAY[1, 2, 3]) AS JSON)] ||
ARRAY[CAST(MAP(ARRAY['b1', 'b2', 'b3'], ARRAY[4, 5, 6]) AS JSON)]
AS items )
SELECT items[1] AS item FROM dataset
```
Diese Abfrage gibt Folgendes zurück:
```
+------------------------+
| item |
+------------------------+
| {"a1":1,"a2":2,"a3":3} |
+------------------------+
```
Verwenden Sie für den Zugriff auf die Array-Elemente an einer bestimmten Position (die Indexposition) die Funktion `element_at()` und geben Sie den Namen des Array und die Indexposition an:
+ Wenn der Index größer als 0 ist, gibt `element_at()` das angegebene Element zurück und zählt das Array dabei von Anfang bis Ende durch. Die Funktion verhält sich dabei wie der `[]`-Operator.
+ Wenn der Index kleiner als 0 ist, gibt `element_at()` das angegebene Element zurück und zählt das Array dabei von Ende bis Anfang durch.
In der folgenden Abfrage wird ein Array `words` erstellt und das erste Element `hello` als `first_word`, das zweite Element `amazon` (vom Ende des Arrays aus gezählt) als `middle_word` und das dritte Element `athena` als `last_word` ausgewählt.
```
WITH dataset AS (
SELECT ARRAY ['hello', 'amazon', 'athena'] AS words
)
SELECT
element_at(words, 1) AS first_word,
element_at(words, -2) AS middle_word,
element_at(words, cardinality(words)) AS last_word
FROM dataset
```
Diese Abfrage gibt Folgendes zurück:
```
+----------------------------------------+
| first_word | middle_word | last_word |
+----------------------------------------+
| hello | amazon | athena |
+----------------------------------------+
```
# Verschachtelte Arrays abflachen
Beim Arbeiten mit verschachtelten Arrays müssen Sie verschachtelte Array-Elemente oft zu einem einzelnen Array erweitern oder das Array in mehrere Zeilen erweitern.
## Abflachfunktion verwenden
Verwenden Sie die Funktion `flatten`, um die Elemente eines verschachtelten Arrays zu einem einzelnen Array mit Werten zu reduzieren. Diese Abfrage gibt eine Zeile für jedes Element im Array zurück.
```
SELECT flatten(ARRAY[ ARRAY[1,2], ARRAY[3,4] ]) AS items
```
Diese Abfrage gibt Folgendes zurück:
```
+-----------+
| items |
+-----------+
| [1,2,3,4] |
+-----------+
```
## CROSS JOIN und UNNEST verwenden
Um ein Array in mehrere Zeilen zu reduzieren, verwenden Sie `CROSS JOIN` in Verbindung mit dem `UNNEST`-Operator wie in diesem Beispiel:
```
WITH dataset AS (
SELECT
'engineering' as department,
ARRAY['Sharon', 'John', 'Bob', 'Sally'] as users
)
SELECT department, names FROM dataset
CROSS JOIN UNNEST(users) as t(names)
```
Diese Abfrage gibt Folgendes zurück:
```
+----------------------+
| department | names |
+----------------------+
| engineering | Sharon |
+----------------------|
| engineering | John |
+----------------------|
| engineering | Bob |
+----------------------|
| engineering | Sally |
+----------------------+
```
Um ein Array mit Schlüssel-Wert-Paaren zu reduzieren, verteilen Sie die ausgewählten Schlüssel wie in diesem Beispiel in Spalten:
```
WITH
dataset AS (
SELECT
'engineering' as department,
ARRAY[
MAP(ARRAY['first', 'last', 'age'],ARRAY['Bob', 'Smith', '40']),
MAP(ARRAY['first', 'last', 'age'],ARRAY['Jane', 'Doe', '30']),
MAP(ARRAY['first', 'last', 'age'],ARRAY['Billy', 'Smith', '8'])
] AS people
)
SELECT names['first'] AS
first_name,
names['last'] AS last_name,
department FROM dataset
CROSS JOIN UNNEST(people) AS t(names)
```
Diese Abfrage gibt Folgendes zurück:
```
+--------------------------------------+
| first_name | last_name | department |
+--------------------------------------+
| Bob | Smith | engineering |
| Jane | Doe | engineering |
| Billy | Smith | engineering |
+--------------------------------------+
```
Wählen Sie aus einer Liste mit Mitarbeitern den Mitarbeiter mit den höchsten kombinierten Werten aus. `UNNEST` kann in der Klausel `FROM` ohne vorangestelltes `CROSS JOIN`, da es der Standard-JOIN-Operator ist und somit vorausgesetzt wird.
```
WITH
dataset AS (
SELECT ARRAY[
CAST(ROW('Sally', 'engineering', ARRAY[1,2,3,4]) AS ROW(name VARCHAR, department VARCHAR, scores ARRAY(INTEGER))),
CAST(ROW('John', 'finance', ARRAY[7,8,9]) AS ROW(name VARCHAR, department VARCHAR, scores ARRAY(INTEGER))),
CAST(ROW('Amy', 'devops', ARRAY[12,13,14,15]) AS ROW(name VARCHAR, department VARCHAR, scores ARRAY(INTEGER)))
] AS users
),
users AS (
SELECT person, score
FROM
dataset,
UNNEST(dataset.users) AS t(person),
UNNEST(person.scores) AS t(score)
)
SELECT person.name, person.department, SUM(score) AS total_score FROM users
GROUP BY (person.name, person.department)
ORDER BY (total_score) DESC
LIMIT 1
```
Diese Abfrage gibt Folgendes zurück:
```
+---------------------------------+
| name | department | total_score |
+---------------------------------+
| Amy | devops | 54 |
+---------------------------------+
```
Wählen Sie aus einer Liste mit Mitarbeitern den Mitarbeiter mit den höchsten einzelnen Werten aus.
```
WITH
dataset AS (
SELECT ARRAY[
CAST(ROW('Sally', 'engineering', ARRAY[1,2,3,4]) AS ROW(name VARCHAR, department VARCHAR, scores ARRAY(INTEGER))),
CAST(ROW('John', 'finance', ARRAY[7,8,9]) AS ROW(name VARCHAR, department VARCHAR, scores ARRAY(INTEGER))),
CAST(ROW('Amy', 'devops', ARRAY[12,13,14,15]) AS ROW(name VARCHAR, department VARCHAR, scores ARRAY(INTEGER)))
] AS users
),
users AS (
SELECT person, score
FROM
dataset,
UNNEST(dataset.users) AS t(person),
UNNEST(person.scores) AS t(score)
)
SELECT person.name, score FROM users
ORDER BY (score) DESC
LIMIT 1
```
Diese Abfrage gibt Folgendes zurück:
```
+--------------+
| name | score |
+--------------+
| Amy | 15 |
+--------------+
```
### Überlegungen zu CROSS JOIN und UNNEST
Wenn `UNNEST` für ein oder mehrere Arrays in der Abfrage verwendet wird und eines der Arrays `NULL` ist, gibt die Abfrage keine Zeilen zurück. Wenn `UNNEST` in ein Array verwendet wird, das eine leere Zeichenfolge ist, wird die leere Zeichenfolge zurückgegeben.
In der folgenden Abfrage werden beispielsweise keine Zeilen zurückgegeben, da das zweite Array null ist.
```
SELECT
col1,
col2
FROM UNNEST (ARRAY ['apples','oranges','lemons']) AS t(col1)
CROSS JOIN UNNEST (ARRAY []) AS t(col2)
```
Im nächsten Beispiel wird das zweite Array so geändert, dass es eine leere Zeichenfolge enthält. Für jede Zeile gibt die Abfrage den Wert in `col1` und eine leere Zeichenfolge für den Wert in `col2` zurück. Die leere Zeichenfolge im zweiten Array ist erforderlich, damit die Werte im ersten Array zurückgegeben werden.
```
SELECT
col1,
col2
FROM UNNEST (ARRAY ['apples','oranges','lemons']) AS t(col1)
CROSS JOIN UNNEST (ARRAY ['']) AS t(col2)
```
# Erstellen von Arrays aus Unterabfragen
Erstellen Sie ein Array aus einer Sammlung von Zeilen.
```
WITH
dataset AS (
SELECT ARRAY[1,2,3,4,5] AS items
)
SELECT array_agg(i) AS array_items
FROM dataset
CROSS JOIN UNNEST(items) AS t(i)
```
Diese Abfrage gibt Folgendes zurück:
```
+-----------------+
| array_items |
+-----------------+
| [1, 2, 3, 4, 5] |
+-----------------+
```
Nutzen Sie das Schlüsselwort `distinct`, um ein Array, bestehend aus eindeutigen Werten, aus einer Reihe von Zeilen zu erstellen.
```
WITH
dataset AS (
SELECT ARRAY [1,2,2,3,3,4,5] AS items
)
SELECT array_agg(distinct i) AS array_items
FROM dataset
CROSS JOIN UNNEST(items) AS t(i)
```
Diese Abfrage gibt das folgende Ergebnis zurück. Beachten Sie, dass die Reihenfolge nicht garantiert ist.
```
+-----------------+
| array_items |
+-----------------+
| [1, 2, 3, 4, 5] |
+-----------------+
```
Weitere Informationen zur Verwendung der `array_agg`-Funktion siehe [Aggregate functions](https://trino.io/docs/current/functions/aggregate.html) (Aggregationsfunktionen) in der Trino-Dokumentation.
# Filtern von Arrays
Erstellen Sie ein Array aus einer Reihe von Zeilen, die den Filterkriterien entsprechen.
```
WITH
dataset AS (
SELECT ARRAY[1,2,3,4,5] AS items
)
SELECT array_agg(i) AS array_items
FROM dataset
CROSS JOIN UNNEST(items) AS t(i)
WHERE i > 3
```
Diese Abfrage gibt Folgendes zurück:
```
+-------------+
| array_items |
+-------------+
| [4, 5] |
+-------------+
```
Filtern Sie ein Array basierend darauf, ob Elemente einen bestimmten Wert (z. B. 2) enthalten, wie in diesem Beispiel:
```
WITH
dataset AS (
SELECT ARRAY
[
ARRAY[1,2,3,4],
ARRAY[5,6,7,8],
ARRAY[9,0]
] AS items
)
SELECT i AS array_items FROM dataset
CROSS JOIN UNNEST(items) AS t(i)
WHERE contains(i, 2)
```
Diese Abfrage gibt Folgendes zurück:
```
+--------------+
| array_items |
+--------------+
| [1, 2, 3, 4] |
+--------------+
```
## Funktion `filter` verwenden
```
filter(ARRAY [list_of_values], boolean_function)
```
Sie können die `filter` Funktion für einen `ARRAY` Ausdruck verwenden, um ein neues Array zu erstellen, das die Teilmenge der Elemente darstellt, *list\$1of\$1values* für die wahr *boolean\$1function* ist. Die `filter` Funktion kann in Fällen nützlich sein, in denen Sie die *UNNEST* Funktion nicht verwenden können.
Im folgenden Beispiel wird im Array `[1,0,5,-1]` nach Werten größer als Null gefiltert.
```
SELECT filter(ARRAY [1,0,5,-1], x -> x>0)
```
**Ergebnisse**
`[1,5]`
Im folgenden Beispiel wird im Array `[-1, NULL, 10, NULL]` nach Werten ungleich Null gefiltert.
```
SELECT filter(ARRAY [-1, NULL, 10, NULL], q -> q IS NOT NULL)
```
**Ergebnisse**
`[-1,10]`
# Arrays sortieren
Um ein sortiertes Array eindeutiger Werte aus einer Reihe von Zeilen zu erstellen, können Sie wie im folgenden Beispiel die Funktion [array\$1sort](https://prestodb.io/docs/current/functions/array.html#array_sort) verwenden.
```
WITH
dataset AS (
SELECT ARRAY[3,1,2,5,2,3,6,3,4,5] AS items
)
SELECT array_sort(array_agg(distinct i)) AS array_items
FROM dataset
CROSS JOIN UNNEST(items) AS t(i)
```
Diese Abfrage gibt Folgendes zurück:
```
+--------------------+
| array_items |
+--------------------+
| [1, 2, 3, 4, 5, 6] |
+--------------------+
```
Informationen zum Erweitern eines Arrays in mehrere Zeilen finden Sie unter [Verschachtelte Arrays abflachen](flattening-arrays.md).
# Aggregations-Funktionen mit Arrays verwenden
+ Fügen Sie mit `SUM` Werte zu einem Array hinzu, wie im folgenden Beispiel dargestellt.
+ Aggregieren Sie mit `array_agg` mehrere Zeilen in einem Array. Weitere Informationen finden Sie unter [Erstellen von Arrays aus Unterabfragen](creating-arrays-from-subqueries.md).
**Anmerkung**
`ORDER BY` wird für Aggregationsfunktionen unterstützt, die in Athena Engine Version 2 beginnen.
```
WITH
dataset AS (
SELECT ARRAY
[
ARRAY[1,2,3,4],
ARRAY[5,6,7,8],
ARRAY[9,0]
] AS items
),
item AS (
SELECT i AS array_items
FROM dataset, UNNEST(items) AS t(i)
)
SELECT array_items, sum(val) AS total
FROM item, UNNEST(array_items) AS t(val)
GROUP BY array_items;
```
In der letzten `SELECT`-Anweisung können Sie statt `sum()` und `UNNEST` zu verwenden, die Verarbeitungszeit und die Datenübertragung, wie im folgenden Beispiel, mit `reduce()` verkürzen.
```
WITH
dataset AS (
SELECT ARRAY
[
ARRAY[1,2,3,4],
ARRAY[5,6,7,8],
ARRAY[9,0]
] AS items
),
item AS (
SELECT i AS array_items
FROM dataset, UNNEST(items) AS t(i)
)
SELECT array_items, reduce(array_items, 0 , (s, x) -> s + x, s -> s) AS total
FROM item;
```
Jede Abfrage gibt die folgenden Ergebnisse zurück. Die Reihenfolge der zurückgegebenen Ergebnisse ist nicht gewährleistet.
```
+----------------------+
| array_items | total |
+----------------------+
| [1, 2, 3, 4] | 10 |
| [5, 6, 7, 8] | 26 |
| [9, 0] | 9 |
+----------------------+
```
# Arrays in Zeichenfolgen konvertieren
Zum Konvertieren eines Arrays in eine einzelne Zeichenfolge verwenden Sie die `array_join`-Funktion. Im folgenden eigenständigen Beispiel wird eine Tabelle namens `dataset` erstellt, die ein aliasiertes Array namens `words` enthält. Die Abfrage verwendet `array_join`, um die Array-Elemente in `words` zu verbinden, sie durch Leerzeichen zu trennen und die resultierende Zeichenfolge in einer Alias-Spalte namens `welcome_msg` zurückzugeben.
```
WITH
dataset AS (
SELECT ARRAY ['hello', 'amazon', 'athena'] AS words
)
SELECT array_join(words, ' ') AS welcome_msg
FROM dataset
```
Diese Abfrage gibt Folgendes zurück:
```
+---------------------+
| welcome_msg |
+---------------------+
| hello amazon athena |
+---------------------+
```
# Arrays zum Erstellen von Karten verwenden
Zuordnungen sind Schlüssel-Wert-Paare, die aus einem in Athena verfügbaren Datentyp bestehen. Verwenden Sie zum Erstellen von Zuordnungen den `MAP`-Operator und übergeben Sie zwei Arrays: Das erste Array enthält die Spaltennamen (Schlüssel) und das zweite Array enthält die Werte. Alle Werte in den Arrays müssen denselben Typ haben. Wenn bestimmte Zuordnungswerte im Array einen anderen Typ benötigen, können Sie sie später umwandeln.
## Beispiele
In diesem Beispiel wird ein Benutzer aus einem Dataset ausgewählt. Dem verwendeten `MAP`-Operator werden zwei Arrays übergeben. Das erste Array enthält Werte für die Spaltennamen wie "first", "last" und "age". Das zweite Array enthält die Werte für die einzelnen Spalten, z. B. "Bob", "Smith", "35".
```
WITH dataset AS (
SELECT MAP(
ARRAY['first', 'last', 'age'],
ARRAY['Bob', 'Smith', '35']
) AS user
)
SELECT user FROM dataset
```
Diese Abfrage gibt Folgendes zurück:
```
+---------------------------------+
| user |
+---------------------------------+
| {last=Smith, first=Bob, age=35} |
+---------------------------------+
```
Sie können `Map`-Werte abrufen, indem Sie den Feldnamen gefolgt von `[key_name]` wie in diesem Beispiel auswählen:
```
WITH dataset AS (
SELECT MAP(
ARRAY['first', 'last', 'age'],
ARRAY['Bob', 'Smith', '35']
) AS user
)
SELECT user['first'] AS first_name FROM dataset
```
Diese Abfrage gibt Folgendes zurück:
```
+------------+
| first_name |
+------------+
| Bob |
+------------+
```
# Abfragen von Arrays mit komplexen Typen und verschachtelten Strukturen
Quelldaten enthalten oft Arrays mit komplexen Datentypen und verschachtelten Strukturen. In den Beispielen in diesem Abschnitt wird gezeigt, wie Sie mit Athena-Abfragen den Datentyp eines Elements ändern, Elemente in einem Array finden und Schlüsselwörter finden können.
**Topics**
+ [Erstellen eines `ROW`](creating-row.md)
+ [Ändern von Feldnamen in Arrays mit `CAST`](changing-row-arrays-with-cast.md)
+ [Filtern von Arrays mit der `.`-Notation](filtering-with-dot.md)
+ [Filtern von Arrays mit verschachtelten Werten](filtering-nested-with-dot.md)
+ [Filtern von Arrays mit `UNNEST`](filtering-with-unnest.md)
+ [Suchen nach Schlüsselwörtern in Arrays mithilfe von `regexp_like`](filtering-with-regexp.md)
# Erstellen eines `ROW`
**Anmerkung**
In den Beispielen in diesem Abschnitt wird `ROW` verwendet, um Beispieldaten zu erstellen. Wenn Sie Tabellen mit Athena abfragen, müssen Sie keine `ROW`-Datentypen erstellen, da sie bereits aus Ihrer Datenquelle erstellt wurden. Wenn Sie `CREATE_TABLE` verwenden, definiert Athena eine `STRUCT` darin, füllt sie mit Daten und erstellt für jede Zeile in einem Dataset den `ROW`-Datentyp für Sie. Der zugrunde liegende `ROW`-Datentyp besteht aus benannten Feldern beliebiger unterstützter SQL-Datentypen.
```
WITH dataset AS (
SELECT
ROW('Bob', 38) AS users
)
SELECT * FROM dataset
```
Diese Abfrage gibt Folgendes zurück:
```
+-------------------------+
| users |
+-------------------------+
| {field0=Bob, field1=38} |
+-------------------------+
```
# Ändern von Feldnamen in Arrays mit `CAST`
Verwenden Sie zum Ändern des Feldnamens in einem Array, das `ROW`-Werte enthält, eine `CAST`-Anweisung für die `ROW`-Deklaration:
```
WITH dataset AS (
SELECT
CAST(
ROW('Bob', 38) AS ROW(name VARCHAR, age INTEGER)
) AS users
)
SELECT * FROM dataset
```
Diese Abfrage gibt Folgendes zurück:
```
+--------------------+
| users |
+--------------------+
| {NAME=Bob, AGE=38} |
+--------------------+
```
**Anmerkung**
Im obigen Beispiel deklarieren Sie `name` als `VARCHAR`, da dies der Datentyp in Presto ist. Wenn Sie dieses `STRUCT` innerhalb einer `CREATE TABLE`-Anweisung deklarieren, verwenden Sie den Datentyp `String`, da Hive diesen Datentyp als `String` definiert.
# Filtern von Arrays mit der `.`-Notation
Wählen Sie im folgenden Beispiel das `accountId` Feld aus der `userIdentity` Spalte einer AWS CloudTrail Protokolltabelle mithilfe der `.` Punktnotation aus. Weitere Informationen finden Sie unter [AWS CloudTrail Logs abfragen](cloudtrail-logs.md).
```
SELECT
CAST(useridentity.accountid AS bigint) as newid
FROM cloudtrail_logs
LIMIT 2;
```
Diese Abfrage gibt Folgendes zurück:
```
+--------------+
| newid |
+--------------+
| 112233445566 |
+--------------+
| 998877665544 |
+--------------+
```
Um ein Array mit Werten abzufragen, senden Sie diese Abfrage:
```
WITH dataset AS (
SELECT ARRAY[
CAST(ROW('Bob', 38) AS ROW(name VARCHAR, age INTEGER)),
CAST(ROW('Alice', 35) AS ROW(name VARCHAR, age INTEGER)),
CAST(ROW('Jane', 27) AS ROW(name VARCHAR, age INTEGER))
] AS users
)
SELECT * FROM dataset
```
Sie erhalten das folgende Ergebnis:
```
+-----------------------------------------------------------------+
| users |
+-----------------------------------------------------------------+
| [{NAME=Bob, AGE=38}, {NAME=Alice, AGE=35}, {NAME=Jane, AGE=27}] |
+-----------------------------------------------------------------+
```
# Filtern von Arrays mit verschachtelten Werten
Große Arrays enthalten oft verschachtelte Strukturen und Sie müssen die darin enthaltenen Werte filtern oder suchen können.
Um ein Dataset für ein Array mit Werten zu definieren, das einen verschachtelten `BOOLEAN`-Wert enthält, senden Sie die folgende Abfrage:
```
WITH dataset AS (
SELECT
CAST(
ROW('aws.amazon.com', ROW(true)) AS ROW(hostname VARCHAR, flaggedActivity ROW(isNew BOOLEAN))
) AS sites
)
SELECT * FROM dataset
```
Sie erhalten das folgende Ergebnis:
```
+----------------------------------------------------------+
| sites |
+----------------------------------------------------------+
| {HOSTNAME=aws.amazon.com, FLAGGEDACTIVITY={ISNEW=true}} |
+----------------------------------------------------------+
```
Verwenden Sie nun zum Filtern von und Zugreifen auf den `BOOLEAN`-Wert dieses Elements die Punkt-`.`-Notation.
```
WITH dataset AS (
SELECT
CAST(
ROW('aws.amazon.com', ROW(true)) AS ROW(hostname VARCHAR, flaggedActivity ROW(isNew BOOLEAN))
) AS sites
)
SELECT sites.hostname, sites.flaggedactivity.isnew
FROM dataset
```
Mit dieser Abfrage werden die verschachtelten Felder ausgewählt und folgendes Ergebnis zurückgegeben:
```
+------------------------+
| hostname | isnew |
+------------------------+
| aws.amazon.com | true |
+------------------------+
```
# Filtern von Arrays mit `UNNEST`
Um ein Array mit einer verschachtelten Struktur nach einem untergeordneten Element zu filtern, verwenden Sie eine Abfrage mit einem `UNNEST`-Operator. Weitere Informationen zu `UNNEST` finden Sie unter [Reduzieren von verschachtelten Arrays](flattening-arrays.md).
Diese Abfrage sucht beispielsweise Hostnamen von Websites im Datensatz.
```
WITH dataset AS (
SELECT ARRAY[
CAST(
ROW('aws.amazon.com', ROW(true)) AS ROW(hostname VARCHAR, flaggedActivity ROW(isNew BOOLEAN))
),
CAST(
ROW('news.cnn.com', ROW(false)) AS ROW(hostname VARCHAR, flaggedActivity ROW(isNew BOOLEAN))
),
CAST(
ROW('netflix.com', ROW(false)) AS ROW(hostname VARCHAR, flaggedActivity ROW(isNew BOOLEAN))
)
] as items
)
SELECT sites.hostname, sites.flaggedActivity.isNew
FROM dataset, UNNEST(items) t(sites)
WHERE sites.flaggedActivity.isNew = true
```
Folgendes wird zurückgegeben:
```
+------------------------+
| hostname | isnew |
+------------------------+
| aws.amazon.com | true |
+------------------------+
```
# Suchen nach Schlüsselwörtern in Arrays mithilfe von `regexp_like`
Die folgenden Beispiele veranschaulichen, wie Sie mit der Funktion [regexp\$1like](https://prestodb.io/docs/current/functions/regexp.html) ein Dataset nach einem Schlüsselwort innerhalb eines Elements in einem Array durchsuchen. Sie übernimmt als Eingabe ein auszuwertendes reguläres Ausdrucksmuster oder eine Liste von Begriffen, die durch einen senkrechten Strich (\$1) voneinander getrennt sind, und bestimmt, ob diese Eingabe in der angegebenen Zeichenfolge enthalten ist.
Das reguläre Ausdrucksmuster muss innerhalb der Zeichenfolge enthalten sein, braucht aber nicht genau mit ihr übereinzustimmen. Wenn es mit der gesamten Zeichenfolge übereinstimmen soll, setzen Sie das Muster zwischen ein ^ am Anfang und ein \$1 am Ende, z. B. `'^pattern$'`.
Stellen Sie sich ein Array von Websites mit deren Hostname und einem `flaggedActivity`-Element vor. Dieses Element enthält ein `ARRAY` mit mehreren `MAP`-Elementen, die jeweils beliebte Schlüsselwörter und deren Beliebtheitswert enthalten. Angenommen, Sie möchten ein bestimmtes Schlüsselwort innerhalb einer `MAP` in diesem Array finden.
Um dieses Dataset nach Websites mit einem bestimmten Schlüsselwort zu durchsuchen, verwenden Sie `regexp_like` anstelle des ähnlichen SQL-`LIKE`-Operators, da die Suche nach einer großen Anzahl von Schlüsselwörtern mit `regexp_like` effizienter ist.
**Example Beispiel 1: Verwenden von `regexp_like`**
Die Abfrage in diesem Beispiel sucht mit der Funktion `regexp_like` nach den Begriffen `'politics|bigdata'` in den Werten innerhalb des Arrays:
```
WITH dataset AS (
SELECT ARRAY[
CAST(
ROW('aws.amazon.com', ROW(ARRAY[
MAP(ARRAY['term', 'count'], ARRAY['bigdata', '10']),
MAP(ARRAY['term', 'count'], ARRAY['serverless', '50']),
MAP(ARRAY['term', 'count'], ARRAY['analytics', '82']),
MAP(ARRAY['term', 'count'], ARRAY['iot', '74'])
])
) AS ROW(hostname VARCHAR, flaggedActivity ROW(flags ARRAY(MAP(VARCHAR, VARCHAR)) ))
),
CAST(
ROW('news.cnn.com', ROW(ARRAY[
MAP(ARRAY['term', 'count'], ARRAY['politics', '241']),
MAP(ARRAY['term', 'count'], ARRAY['technology', '211']),
MAP(ARRAY['term', 'count'], ARRAY['serverless', '25']),
MAP(ARRAY['term', 'count'], ARRAY['iot', '170'])
])
) AS ROW(hostname VARCHAR, flaggedActivity ROW(flags ARRAY(MAP(VARCHAR, VARCHAR)) ))
),
CAST(
ROW('netflix.com', ROW(ARRAY[
MAP(ARRAY['term', 'count'], ARRAY['cartoons', '1020']),
MAP(ARRAY['term', 'count'], ARRAY['house of cards', '112042']),
MAP(ARRAY['term', 'count'], ARRAY['orange is the new black', '342']),
MAP(ARRAY['term', 'count'], ARRAY['iot', '4'])
])
) AS ROW(hostname VARCHAR, flaggedActivity ROW(flags ARRAY(MAP(VARCHAR, VARCHAR)) ))
)
] AS items
),
sites AS (
SELECT sites.hostname, sites.flaggedactivity
FROM dataset, UNNEST(items) t(sites)
)
SELECT hostname
FROM sites, UNNEST(sites.flaggedActivity.flags) t(flags)
WHERE regexp_like(flags['term'], 'politics|bigdata')
GROUP BY (hostname)
```
Diese Abfrage gibt zwei Websites zurück:
```
+----------------+
| hostname |
+----------------+
| aws.amazon.com |
+----------------+
| news.cnn.com |
+----------------+
```
**Example Beispiel 2: Verwenden von `regexp_like`**
Bei der Abfrage im folgenden Beispiel werden die Gesamtbeliebtheitswerte für die Websites, die mit Ihren Suchbegriffen übereinstimmen, mit der Funktion `regexp_like` addiert und dann von hoch nach niedrig sortiert.
```
WITH dataset AS (
SELECT ARRAY[
CAST(
ROW('aws.amazon.com', ROW(ARRAY[
MAP(ARRAY['term', 'count'], ARRAY['bigdata', '10']),
MAP(ARRAY['term', 'count'], ARRAY['serverless', '50']),
MAP(ARRAY['term', 'count'], ARRAY['analytics', '82']),
MAP(ARRAY['term', 'count'], ARRAY['iot', '74'])
])
) AS ROW(hostname VARCHAR, flaggedActivity ROW(flags ARRAY(MAP(VARCHAR, VARCHAR)) ))
),
CAST(
ROW('news.cnn.com', ROW(ARRAY[
MAP(ARRAY['term', 'count'], ARRAY['politics', '241']),
MAP(ARRAY['term', 'count'], ARRAY['technology', '211']),
MAP(ARRAY['term', 'count'], ARRAY['serverless', '25']),
MAP(ARRAY['term', 'count'], ARRAY['iot', '170'])
])
) AS ROW(hostname VARCHAR, flaggedActivity ROW(flags ARRAY(MAP(VARCHAR, VARCHAR)) ))
),
CAST(
ROW('netflix.com', ROW(ARRAY[
MAP(ARRAY['term', 'count'], ARRAY['cartoons', '1020']),
MAP(ARRAY['term', 'count'], ARRAY['house of cards', '112042']),
MAP(ARRAY['term', 'count'], ARRAY['orange is the new black', '342']),
MAP(ARRAY['term', 'count'], ARRAY['iot', '4'])
])
) AS ROW(hostname VARCHAR, flaggedActivity ROW(flags ARRAY(MAP(VARCHAR, VARCHAR)) ))
)
] AS items
),
sites AS (
SELECT sites.hostname, sites.flaggedactivity
FROM dataset, UNNEST(items) t(sites)
)
SELECT hostname, array_agg(flags['term']) AS terms, SUM(CAST(flags['count'] AS INTEGER)) AS total
FROM sites, UNNEST(sites.flaggedActivity.flags) t(flags)
WHERE regexp_like(flags['term'], 'politics|bigdata')
GROUP BY (hostname)
ORDER BY total DESC
```
Diese Abfrage gibt zwei Websites zurück:
```
+------------------------------------+
| hostname | terms | total |
+----------------+-------------------+
| news.cnn.com | politics | 241 |
+----------------+-------------------+
| aws.amazon.com | bigdata | 10 |
+----------------+-------------------+
```