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.

# Array-Funktionen
<a name="Array_Functions"></a>

In diesem Abschnitt werden die Array-Funktionen für SQL beschrieben, die in AWS Clean Rooms unterstützt werden. 

**Topics**
+ [ARRAY-Funktion](array.md)
+ [Funktion ARRAY\$1CONTAINS](array_contains.md)
+ [ARRAY\$1DISTINCT-Funktion](array_distinct.md)
+ [ARRAY\$1EXCEPT-Funktion](array_except.md)
+ [Funktion ARRAY\$1INTERSECT](array_intersect.md)
+ [ARRAY\$1JOIN-Funktion](array_join.md)
+ [Funktion ARRAY\$1REMOVE](array_remove.md)
+ [ARRAY\$1UNION-Funktion](array_union.md)
+ [EXPLODE-Funktion](explode.md)
+ [Funktion FLATTEN](flatten.md)

# ARRAY-Funktion
<a name="array"></a>

Erzeugt ein Array mit den angegebenen Elementen.

## Syntax
<a name="array-synopsis"></a>

```
ARRAY( [ expr1 ] [ , expr2 [ , ... ] ] )
```

## Argument
<a name="array-argument"></a>

 *expr1, expr2*   
Ausdrücke aller Datentypen außer Datums- und Uhrzeittypen. Die Argumente müssen nicht denselben Datentyp haben.

## Rückgabetyp
<a name="array-return-type"></a>

Die Array-Funktion gibt ein ARRAY mit den Elementen im Ausdruck zurück.

## Beispiel
<a name="array-example"></a>

Das folgende Beispiel zeigt ein Array mit numerischen Werten und ein Array mit verschiedenen Datentypen.

```
--an array of numeric values
select array(1,50,null,100);
      array
------------------
 [1,50,null,100]
(1 row)

--an array of different data types
select array(1,'abc',true,3.14);
        array
-----------------------
 [1,"abc",true,3.14]
(1 row)
```

# Funktion ARRAY\$1CONTAINS
<a name="array_contains"></a>

Die Funktion ARRAY\$1CONTAINS kann verwendet werden, um grundlegende Mitgliedschaftsprüfungen für Array-Datenstrukturen durchzuführen. Die Funktion ARRAY\$1CONTAINS ist nützlich, wenn Sie überprüfen müssen, ob ein bestimmter Wert in einem Array vorhanden ist.

## Syntax
<a name="array_contains-syntax"></a>

```
array_contains(array, value)
```

## Argumente
<a name="array_contains-arguments"></a>

 *Array*  
Ein zu durchsuchendes ARRAY.

 *Wert*  
Ein Ausdruck mit einem Typ, der den Typ, der den Array-Elementen am wenigsten gemeinsam ist.

## Rückgabetyp
<a name="array_contains-return-type"></a>

Die Funktion ARRAY\$1CONTAINS gibt einen Wert vom Typ BOOLEAN zurück. 

Wenn der Wert NULL ist, ist das Ergebnis NULL. 

Wenn ein Element im Array NULL ist, ist das Ergebnis NULL, wenn der Wert keinem anderen Element zugeordnet ist.

## Beispiele
<a name="array_contains-example"></a>

Im folgenden Beispiel wird geprüft, ob das Array den Wert `[1, 2, 3]` enthält`4`. Da das `[1, 2, 3` [Array] den Wert nicht enthält`4`, gibt die Funktion array\$1contains zurück. `false` 

```
SELECT array_contains(array(1, 2, 3), 4)
false
```

Im folgenden Beispiel wird geprüft, ob das Array den Wert `[1, 2, 3]` enthält. `2` Da das Array den Wert `[1, 2, 3]` enthält`2`, gibt die Funktion array\$1contains zurück. `true` 

```
SELECT array_contains(array(1, 2, 3), 2);
 true
```

# ARRAY\$1DISTINCT-Funktion
<a name="array_distinct"></a>

Die Funktion ARRAY\$1DISTINCT kann verwendet werden, um doppelte Werte aus einem Array zu entfernen. Die Funktion ARRAY\$1DISTINCT ist nützlich, wenn Sie Duplikate aus einem Array entfernen und nur mit den eindeutigen Elementen arbeiten müssen. Dies kann in Szenarien hilfreich sein, in denen Sie Operationen oder Analysen an einem Datensatz durchführen möchten, ohne dass sich wiederholte Werte gegenseitig beeinflussen.

## Syntax
<a name="array_distinct-syntax"></a>

```
array_distinct(array)
```

## Argumente
<a name="array_distinct-arguments"></a>

 *Array*  
Ein ARRAY-Ausdruck.

## Rückgabetyp
<a name="array_distinct-return-type"></a>

Die Funktion ARRAY\$1DISTINCT gibt ein ARRAY zurück, das nur die eindeutigen Elemente aus dem Eingabearray enthält. 

## Beispiele
<a name="array_distinct-example"></a>

In diesem Beispiel `[1, 2, 3, null, 3]` enthält das Eingabearray einen doppelten Wert von. `3` Die `array_distinct` Funktion entfernt diesen doppelten Wert `3` und gibt ein neues Array mit den eindeutigen Elementen zurück:`[1, 2, 3, null]`.

```
SELECT array_distinct(array(1, 2, 3, null, 3));
 [1,2,3,null]
```

In diesem Beispiel `[1, 2, 2, 3, 3, 3]` enthält das Eingabearray doppelte Werte von `2` und`3`. Die `array_distinct` Funktion entfernt diese Duplikate und gibt ein neues Array mit den eindeutigen Elementen zurück:`[1, 2, 3]`.

```
SELECT array_distinct(array(1, 2, 2, 3, 3, 3))
  [1,2,3]
```

# ARRAY\$1EXCEPT-Funktion
<a name="array_except"></a>

Die Funktion ARRAY\$1EXCEPT verwendet zwei Arrays als Argumente und gibt ein neues Array zurück, das nur die Elemente enthält, die im ersten Array vorhanden sind, aber nicht im zweiten Array.

Die ARRAY\$1EXCEPT ist nützlich, wenn Sie die Elemente finden müssen, die für ein Array im Vergleich zu einem anderen einzigartig sind. Dies kann in Szenarien hilfreich sein, in denen Sie mengenähnliche Operationen an Arrays ausführen müssen, z. B. um den Unterschied zwischen zwei Datensätzen zu ermitteln.

## Syntax
<a name="array_except-syntax"></a>

```
array_except(array1, array2)
```

## Argumente
<a name="array_except-arguments"></a>

 *Matrix1*  
Ein ARRAY beliebigen Typs mit vergleichbaren Elementen.

 *array2*  
*Ein ARRAY von Elementen, deren Typ mit den Elementen von array1 am wenigsten gemeinsam ist.*

## Rückgabetyp
<a name="array_except-return-type"></a>

*Die Funktion ARRAY\$1EXCEPT gibt ein ARRAY zurück, dessen Typ mit Array1 übereinstimmt, ohne Duplikate.*

## Beispiele
<a name="array_except-example"></a>

In diesem Beispiel `[1, 2, 3]` enthält das erste Array die Elemente 1, 2 und 3. Das zweite Array `[2, 3, 4]` enthält die Elemente 2, 3 und 4. Die `array_except` Funktion entfernt die Elemente 2 und 3 aus dem ersten Array, da sie auch im zweiten Array vorhanden sind. Die resultierende Ausgabe ist das Array`[1]`.

```
SELECT array_except(array(1, 2, 3), array(2, 3, 4))
  [1]
```

In diesem Beispiel `[1, 2, 3]` enthält das erste Array die Elemente 1, 2 und 3. Das zweite Array `[1, 3, 5]` enthält die Elemente 1, 3 und 5. Die `array_except` Funktion entfernt die Elemente 1 und 3 aus dem ersten Array, da sie auch im zweiten Array vorhanden sind. Die resultierende Ausgabe ist das Array`[2]`.

```
SELECT array_except(array(1, 2, 3), array(1, 3, 5));
 [2]
```

# Funktion ARRAY\$1INTERSECT
<a name="array_intersect"></a>

Die Funktion ARRAY\$1INTERSECT verwendet zwei Arrays als Argumente und gibt ein neues Array zurück, das die Elemente enthält, die in beiden Eingabearrays vorhanden sind. Diese Funktion ist nützlich, wenn Sie die gemeinsamen Elemente zwischen zwei Arrays suchen müssen. Dies kann in Szenarien hilfreich sein, in denen Sie mengenähnliche Operationen an Arrays ausführen müssen, z. B. um die Schnittmenge zwischen zwei Datensätzen zu ermitteln.

## Syntax
<a name="array_intersect-syntax"></a>

```
array_intersect(array1, array2)
```

## Argumente
<a name="array_intersect-arguments"></a>

 *Matrix1*  
Ein ARRAY beliebigen Typs mit vergleichbaren Elementen.

 *array2*  
Ein ARRAY von Elementen, deren Typ mit den Elementen von array1 am wenigsten gemeinsam ist.

## Rückgabetyp
<a name="array_intersect-return-type"></a>

Die Funktion ARRAY\$1INTERSECT gibt ein ARRAY zurück, dessen Typ mit Array1 übereinstimmt, ohne Duplikate und ohne Elemente, die sowohl in array1 als auch array2 enthalten sind.

## Beispiele
<a name="array_intersect-example"></a>

In diesem Beispiel enthält das erste Array die Elemente 1, 2 und 3. `[1, 2, 3]` Das zweite Array `[1, 3, 5]` enthält die Elemente 1, 3 und 5. Die Funktion ARRAY\$1INTERSECT identifiziert die gemeinsamen Elemente zwischen den beiden Arrays, nämlich 1 und 3. Das resultierende Ausgabearray ist. `[1, 3]`

```
SELECT array_intersect(array(1, 2, 3), array(1, 3, 5));
 [1,3]
```

# ARRAY\$1JOIN-Funktion
<a name="array_join"></a>

Die ARRAY\$1JOIN-Funktion benötigt zwei Argumente: Das erste Argument ist das Eingabearray, das verknüpft werden soll. Das zweite Argument ist die Trennzeichenfolge, die verwendet wird, um die Array-Elemente zu verketten. Diese Funktion ist nützlich, wenn Sie ein Array von Zeichenketten (oder einen anderen Datentyp) in eine einzelne verkettete Zeichenfolge konvertieren müssen. Dies kann in Szenarien hilfreich sein, in denen Sie ein Array von Werten als einzelne formatierte Zeichenfolge darstellen möchten, z. B. zu Anzeigezwecken oder zur Verwendung bei der weiteren Verarbeitung.

## Syntax
<a name="array_join-syntax"></a>

```
array_join(array, delimiter[, nullReplacement])
```

## Argumente
<a name="array_join-arguments"></a>

 *Array*  
Jeder ARRAY-Typ, aber seine Elemente werden als Zeichenketten interpretiert.

 *delimiter*  
Ein STRING, der verwendet wird, um die verketteten Array-Elemente zu trennen.

 *Ersatz durch Null*  
Ein STRING, der verwendet wird, um einen NULL-Wert im Ergebnis auszudrücken.

## Rückgabetyp
<a name="array_join-return-type"></a>

Die Funktion ARRAY\$1JOIN gibt einen STRING zurück, bei dem die Elemente des Arrays durch ein Trennzeichen getrennt sind und Nullelemente ersetzt werden. `nullReplacement` Wenn nicht angegeben`nullReplacement`, werden Elemente herausgefiltert`null`. Wenn ein Argument ja ist`NULL`, ist das Ergebnis`NULL`.

## Beispiele
<a name="array_join-example"></a>

In diesem Beispiel verwendet die Funktion ARRAY\$1JOIN das Array `['hello', 'world']` und verbindet die Elemente mithilfe des Trennzeichens `' '` (eines Leerzeichens). Die resultierende Ausgabe ist die Zeichenfolge. `'hello world'` 

```
SELECT array_join(array('hello', 'world'), ' ');
 hello world
```

In diesem Beispiel verwendet die ARRAY\$1JOIN-Funktion das Array `['hello', null, 'world']` und verbindet die Elemente mithilfe des Trennzeichens `' '` (eines Leerzeichens). Der `null` Wert wird durch die angegebene Ersatzzeichenfolge `','` (ein Komma) ersetzt. Die resultierende Ausgabe ist die Zeichenfolge`'hello , world'`.

```
SELECT array_join(array('hello', null ,'world'), ' ', ',');
 hello , world
```

# Funktion ARRAY\$1REMOVE
<a name="array_remove"></a>

Die Funktion ARRAY\$1REMOVE benötigt zwei Argumente: Das erste Argument ist das Eingabearray, aus dem die Elemente entfernt werden. Das zweite Argument ist der Wert, der aus dem Array entfernt wird. Diese Funktion ist nützlich, wenn Sie bestimmte Elemente aus einem Array entfernen müssen. Dies kann in Szenarien hilfreich sein, in denen Sie eine Datenbereinigung oder Vorverarbeitung für ein Array von Werten durchführen müssen.

## Syntax
<a name="array_remove-syntax"></a>

```
array_remove(array, element)
```

## Argumente
<a name="array_remove-arguments"></a>

 *Array*  
Ein ARRAY.

 *element*  
Ein Ausdruck eines Typs, der den seltensten Typ mit den Elementen eines Arrays gemeinsam hat.

## Rückgabetyp
<a name="array_remove-return-type"></a>

Die Funktion ARRAY\$1REMOVE gibt den Ergebnistyp zurück, der dem Typ des Arrays entspricht. Wenn das zu entfernende Element ist`NULL`, ist das Ergebnis. `NULL`

## Beispiele
<a name="array_remove-example"></a>

In diesem Beispiel verwendet die Funktion ARRAY\$1REMOVE das Array `[1, 2, 3, null, 3]` und entfernt alle Vorkommen des Werts 3. Die resultierende Ausgabe ist das Array. `[1, 2, null]` 

```
SELECT array_remove(array(1, 2, 3, null, 3), 3);
 [1,2,null]
```

# ARRAY\$1UNION-Funktion
<a name="array_union"></a>

Die Funktion ARRAY\$1UNION verwendet zwei Arrays als Argumente und gibt ein neues Array zurück, das die eindeutigen Elemente aus beiden Eingabearrays enthält. Diese Funktion ist nützlich, wenn Sie zwei Arrays kombinieren und alle doppelten Elemente entfernen müssen. Dies kann in Szenarien hilfreich sein, in denen Sie mengenähnliche Operationen an Arrays ausführen müssen, z. B. um die Verbindung zwischen zwei Datensätzen zu ermitteln.

## Syntax
<a name="array_union-syntax"></a>

```
array_union(array1, array2)
```

## Argumente
<a name="array_union-arguments"></a>

 *Matrix1*  
Ein ARRAY.

 *Array 2*  
*Ein ARRAY desselben Typs wie array1.*

## Rückgabetyp
<a name="array_union-return-type"></a>

Die Funktion ARRAY\$1UNION gibt ein ARRAY desselben Typs wie ein Array zurück.

## Beispiel
<a name="array_union-example"></a>

In diesem Beispiel `[1, 2, 3]` enthält das erste Array die Elemente 1, 2 und 3. Das zweite Array `[1, 3, 5]` enthält die Elemente 1, 3 und 5. Die Funktion ARRAY\$1UNION kombiniert die eindeutigen Elemente aus beiden Arrays, sodass das Ausgabe-Array entsteht. `[1, 2, 3, 5]` T

```
SELECT array_union(array(1, 2, 3), array(1, 3, 5));
 [1,2,3,5]
```

# EXPLODE-Funktion
<a name="explode"></a>

Die EXPLODE-Funktion wird verwendet, um eine einzelne Zeile mit einem Array oder einer Zuordnungsspalte in mehrere Zeilen umzuwandeln, wobei jede Zeile einem einzelnen Element aus dem Array oder der Map entspricht.

## Syntax
<a name="explode-syntax"></a>

```
explode(expr)
```

## Argumente
<a name="explode-arguments"></a>

 *expr*  
Ein Array-Ausdruck oder ein Map-Ausdruck. 

## Rückgabetyp
<a name="explode-return-type"></a>

Die EXPLODE-Funktion gibt eine Reihe von Zeilen zurück, wobei jede Zeile ein einzelnes Element aus dem Eingabe-Array oder der Eingabe-Map darstellt.

Der Datentyp der Ausgabezeilen hängt vom Datentyp der Elemente im Eingabe-Array oder der Eingabe-Map ab. 

## Beispiele
<a name="explode-example"></a>

Im folgenden Beispiel wird das einzeilige Array [10, 20] in zwei separate Zeilen umgewandelt, die jeweils eines der Array-Elemente (10 und 20) enthalten.

```
SELECT explode(array(10, 20));
```

Im ersten Beispiel wurde das Eingabe-Array direkt als Argument an übergeben. `explode()` In diesem Beispiel wird das Eingabearray mithilfe der `=>` Syntax angegeben, wobei der Spaltenname (`collection`) explizit angegeben wird.

```
SELECT explode(array(10, 20));
```

Beide Ansätze sind gültig und führen zu demselben Ergebnis, aber die zweite Syntax kann nützlicher sein, wenn Sie eine Spalte aus einem größeren Datensatz auflösen müssen, als nur ein einfaches Array-Literal.

# Funktion FLATTEN
<a name="flatten"></a>

Die FLATTEN-Funktion wird verwendet, um eine verschachtelte Array-Struktur zu einem einzigen flachen Array zu „glätten“.

## Syntax
<a name="flatten-syntax"></a>

```
flatten(arrayOfArrays)
```

## Argumente
<a name="flatten-arguments"></a>

 *arrayOfArrays*  
Ein Array von Arrays.

## Rückgabetyp
<a name="flatten-return-type"></a>

Die FLATTEN-Funktion gibt ein Array zurück.

## Beispiel
<a name="flatten-example"></a>

In diesem Beispiel ist die Eingabe ein verschachteltes Array mit zwei inneren Arrays, und die Ausgabe ist ein einzelnes flaches Array, das alle Elemente aus den inneren Arrays enthält. Die FLATTEN-Funktion verwendet das verschachtelte Array `[[1, 2], [3, 4]]` und kombiniert alle Elemente zu einem einzigen Array. `[1, 2, 3, 4]`

```
SELECT flatten(array(array(1, 2), array(3, 4)));
 [1,2,3,4]
```