Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Fonctions de tableau
<a name="Array_Functions"></a>

Cette section décrit les fonctions de tableau pour SQL prises en charge dans AWS Clean Rooms. 

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

# Fonction ARRAY
<a name="array"></a>

Crée un tableau avec les éléments donnés.

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

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

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

 *expr1, expr2*   
Expressions de tous types de données, à l'exception des types de date et d'heure. Les arguments ne doivent pas nécessairement être du même type de données.

## Type de retour
<a name="array-return-type"></a>

La fonction array renvoie un ARRAY contenant les éléments de l'expression.

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

L'exemple suivant montre un tableau de valeurs numériques et un tableau de différents types de données.

```
--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)
```

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

La fonction ARRAY\$1CONTAINS peut être utilisée pour effectuer des vérifications d'appartenance de base sur les structures de données des tableaux. La fonction ARRAY\$1CONTAINS est utile lorsque vous devez vérifier si une valeur spécifique est présente dans un tableau.

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

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

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

 *réseau*  
Un ARRAY à rechercher.

 *valeur*  
Expression dont le type partage le type le moins courant avec les éléments du tableau.

## Type de retour
<a name="array_contains-return-type"></a>

La fonction ARRAY\$1CONTAINS renvoie une valeur BOOLEAN. 

Si la valeur est NULL, le résultat est NULL. 

Si un élément du tableau est NULL, le résultat est NULL si la valeur ne correspond à aucun autre élément.

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

L'exemple suivant vérifie si le tableau `[1, 2, 3]` contient la valeur`4`. Comme le `[1, 2, 3` [array] ne contient pas la valeur`4`, la fonction array\$1contains revient. `false` 

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

L'exemple suivant vérifie si le tableau `[1, 2, 3]` contient la valeur`2`. Comme le tableau `[1, 2, 3]` contient la valeur`2`, la fonction array\$1contains est renvoyée. `true` 

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

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

La fonction ARRAY\$1DISTINCT peut être utilisée pour supprimer les valeurs dupliquées d'un tableau. La fonction ARRAY\$1DISTINCT est utile lorsque vous devez supprimer les doublons d'un tableau et utiliser uniquement les éléments uniques. Cela peut être utile dans les scénarios où vous souhaitez effectuer des opérations ou des analyses sur un ensemble de données sans l'interférence de valeurs répétées.

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

```
array_distinct(array)
```

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

 *réseau*  
Expression ARRAY.

## Type de retour
<a name="array_distinct-return-type"></a>

La fonction ARRAY\$1DISTINCT renvoie un ARRAY contenant uniquement les éléments uniques du tableau d'entrée. 

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

Dans cet exemple, le tableau d'entrée `[1, 2, 3, null, 3]` contient une valeur dupliquée de`3`. La `array_distinct` fonction supprime cette valeur dupliquée `3` et renvoie un nouveau tableau contenant les éléments uniques :`[1, 2, 3, null]`.

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

Dans cet exemple, le tableau d'entrée `[1, 2, 2, 3, 3, 3]` contient des valeurs dupliquées de `2` et`3`. La `array_distinct` fonction supprime ces doublons et renvoie un nouveau tableau avec les éléments uniques :. `[1, 2, 3]`

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

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

La fonction ARRAY\$1EXCEPT prend deux tableaux comme arguments et renvoie un nouveau tableau contenant uniquement les éléments présents dans le premier tableau, mais pas dans le second tableau.

Le ARRAY\$1EXCEPT est utile lorsque vous devez trouver les éléments uniques d'un tableau par rapport à un autre. Cela peut être utile dans les scénarios où vous devez effectuer des opérations similaires à des ensembles sur des tableaux, telles que la recherche de la différence entre deux ensembles de données.

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

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

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

 *matrice1*  
Un ARRAY de n'importe quel type avec des éléments comparables.

 *tableau 2*  
Un TABLEAU d'éléments partageant le type le moins commun avec les éléments de *array1*.

## Type de retour
<a name="array_except-return-type"></a>

La fonction ARRAY\$1EXCEPT renvoie un ARRAY de type correspondant à *array1* sans doublons.

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

Dans cet exemple, le premier tableau `[1, 2, 3]` contient les éléments 1, 2 et 3. Le second tableau `[2, 3, 4]` contient les éléments 2, 3 et 4. La `array_except` fonction supprime les éléments 2 et 3 du premier tableau, puisqu'ils sont également présents dans le second tableau. Le résultat obtenu est le tableau`[1]`.

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

Dans cet exemple, le premier tableau `[1, 2, 3]` contient les éléments 1, 2 et 3. Le second tableau `[1, 3, 5]` contient les éléments 1, 3 et 5. La `array_except` fonction supprime les éléments 1 et 3 du premier tableau, puisqu'ils sont également présents dans le second tableau. Le résultat obtenu est le tableau`[2]`.

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

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

La fonction ARRAY\$1INTERSECT prend deux tableaux comme arguments et renvoie un nouveau tableau contenant les éléments présents dans les deux tableaux d'entrée. Cette fonction est utile lorsque vous devez trouver les éléments communs entre deux tableaux. Cela peut être utile dans les scénarios où vous devez effectuer des opérations similaires à des ensembles sur des tableaux, telles que la recherche de l'intersection entre deux ensembles de données.

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

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

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

 *matrice1*  
Un ARRAY de n'importe quel type avec des éléments comparables.

 *tableau 2*  
Un TABLEAU d'éléments partageant le type le moins commun avec les éléments de array1.

## Type de retour
<a name="array_intersect-return-type"></a>

La fonction ARRAY\$1INTERSECT renvoie un ARRAY de type correspondant à array1 sans doublons et sans éléments contenus à la fois dans array1 et array2.

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

Dans cet exemple, le premier tableau `[1, 2, 3]` contient les éléments 1, 2 et 3. Le second tableau `[1, 3, 5]` contient les éléments 1, 3 et 5. La fonction ARRAY\$1INTERSECT identifie les éléments communs entre les deux tableaux, à savoir 1 et 3. Le tableau de sortie résultant est`[1, 3]`.

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

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

La fonction ARRAY\$1JOIN prend deux arguments : le premier argument est le tableau d'entrée qui sera joint. Le deuxième argument est la chaîne de séparation qui sera utilisée pour concaténer les éléments du tableau. Cette fonction est utile lorsque vous devez convertir un tableau de chaînes (ou tout autre type de données) en une seule chaîne concaténée. Cela peut être utile dans les scénarios où vous souhaitez présenter un tableau de valeurs sous la forme d'une seule chaîne formatée, par exemple à des fins d'affichage ou pour un traitement ultérieur.

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

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

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

 *réseau*  
N'importe quel type ARRAY, mais ses éléments sont interprétés comme des chaînes.

 *delimiter*  
Une CHAÎNE utilisée pour séparer les éléments du tableau concaténé.

 *Remplacement nul*  
Chaîne utilisée pour exprimer une valeur NULL dans le résultat.

## Type de retour
<a name="array_join-return-type"></a>

La fonction ARRAY\$1JOIN renvoie une chaîne dans laquelle les éléments du tableau sont séparés par un délimiteur et les éléments nuls sont remplacés par des éléments nuls. `nullReplacement` Si `nullReplacement` ce paramètre est omis, `null` les éléments sont filtrés. Si un argument l'est`NULL`, le résultat est`NULL`.

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

Dans cet exemple, la fonction ARRAY\$1JOIN prend le tableau `['hello', 'world']` et joint les éléments à l'aide du séparateur `' '` (un espace). Le résultat obtenu est la chaîne de caractères`'hello world'`. 

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

Dans cet exemple, la fonction ARRAY\$1JOIN prend le tableau `['hello', null, 'world']` et joint les éléments à l'aide du séparateur `' '` (un espace). La `null` valeur est remplacée par la chaîne de remplacement fournie `','` (une virgule). Le résultat obtenu est la chaîne de caractères`'hello , world'`.

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

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

La fonction ARRAY\$1REMOVE accepte deux arguments : le premier argument est le tableau d'entrée dont les éléments seront supprimés. Le deuxième argument est la valeur qui sera supprimée du tableau. Cette fonction est utile lorsque vous devez supprimer des éléments spécifiques d'un tableau. Cela peut être utile dans les scénarios où vous devez effectuer un nettoyage ou un prétraitement des données sur un tableau de valeurs.

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

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

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

 *réseau*  
Un ARRAY.

 *élément*  
Expression d'un type partageant le type le moins commun avec les éléments du tableau.

## Type de retour
<a name="array_remove-return-type"></a>

La fonction ARRAY\$1REMOVE renvoie le type de résultat correspondant au type du tableau. Si l'élément à supprimer l'est`NULL`, le résultat est`NULL`.

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

Dans cet exemple, la fonction ARRAY\$1REMOVE prend le tableau `[1, 2, 3, null, 3]` et supprime toutes les occurrences de la valeur 3. Le résultat obtenu est le tableau`[1, 2, null]`. 

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

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

La fonction ARRAY\$1UNION prend deux tableaux comme arguments et renvoie un nouveau tableau contenant les éléments uniques des deux tableaux d'entrée. Cette fonction est utile lorsque vous devez combiner deux tableaux et éliminer les éléments dupliqués. Cela peut être utile dans les scénarios où vous devez effectuer des opérations similaires à des ensembles sur des tableaux, telles que la recherche de l'union entre deux ensembles de données.

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

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

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

 *matrice1*  
Un ARRAY.

 *tableau 2*  
Un ARRAY du même type que *array1*.

## Type de retour
<a name="array_union-return-type"></a>

La fonction ARRAY\$1UNION renvoie un ARRAY du même type qu'un tableau.

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

Dans cet exemple, le premier tableau `[1, 2, 3]` contient les éléments 1, 2 et 3. Le second tableau `[1, 3, 5]` contient les éléments 1, 3 et 5. La fonction ARRAY\$1UNION combine les éléments uniques des deux tableaux pour obtenir le tableau de sortie. `[1, 2, 3, 5]` T

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

# Fonction EXPLODE
<a name="explode"></a>

La fonction EXPLODE est utilisée pour transformer une seule ligne contenant un tableau ou une colonne de carte en plusieurs lignes, chaque ligne correspondant à un seul élément du tableau ou de la carte.

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

```
explode(expr)
```

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

 *expr*  
Expression matricielle ou expression cartographique. 

## Type de retour
<a name="explode-return-type"></a>

La fonction EXPLODE renvoie un ensemble de lignes, chaque ligne représentant un élément unique du tableau ou de la carte en entrée.

Le type de données des lignes de sortie dépend du type de données des éléments du tableau ou de la carte en entrée. 

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

L'exemple suivant prend le tableau à une seule ligne [10, 20] et le transforme en deux lignes distinctes, chacune contenant l'un des éléments du tableau (10 et 20).

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

Dans le premier exemple, le tableau d'entrée a été directement transmis en tant qu'argument à`explode()`. Dans cet exemple, le tableau d'entrée est spécifié à l'aide de la `=>` syntaxe, où le nom de colonne (`collection`) est explicitement fourni.

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

Les deux approches sont valides et permettent d'obtenir le même résultat, mais la seconde syntaxe peut être plus utile lorsque vous devez faire exploser une colonne d'un ensemble de données plus important, plutôt qu'un simple tableau littéral.

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

La fonction FLATTEN est utilisée pour « aplatir » une structure de tableau imbriqué en un seul tableau plat.

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

```
flatten(arrayOfArrays)
```

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

 *arrayOfArrays*  
Un tableau de tableaux.

## Type de retour
<a name="flatten-return-type"></a>

La fonction FLATTEN renvoie un tableau.

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

Dans cet exemple, l'entrée est un tableau imbriqué avec deux tableaux internes, et la sortie est un seul tableau plat contenant tous les éléments des tableaux internes. La fonction FLATTEN prend le tableau imbriqué `[[1, 2], [3, 4]]` et combine tous les éléments en un seul tableau. `[1, 2, 3, 4]`

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