Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Funzioni di array
<a name="Array_Functions"></a>

Questa sezione descrive le funzioni di array per SQL supportate in. AWS Clean Rooms

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

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

Crea un array con gli elementi dati.

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

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

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

 *expr1, expr2*   
Espressioni di qualsiasi tipo di dati ad eccezione dei tipi di data e ora. Non è necessario che gli argomenti siano dello stesso tipo di dati.

## Tipo restituito
<a name="array-return-type"></a>

La funzione array restituisce un ARRAY con gli elementi dell'espressione.

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

L'esempio seguente mostra una matrice di valori numerici e una matrice di diversi tipi di dati.

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

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

La funzione ARRAY\$1CONTAINS può essere utilizzata per eseguire controlli di appartenenza di base sulle strutture di dati degli array. La funzione ARRAY\$1CONTAINS è utile quando è necessario verificare se un valore specifico è presente all'interno di un array.

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

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

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

 *matrice*  
Un ARRAY da cercare.

 *value*  
Un'espressione con un tipo che condivide un tipo meno comune con gli elementi dell'array.

## Tipo restituito
<a name="array_contains-return-type"></a>

La funzione ARRAY\$1CONTAINS restituisce un valore BOOLEAN. 

Se il valore è NULL, il risultato è NULL. 

Se un elemento dell'array è NULL, il risultato è NULL se il valore non corrisponde a nessun altro elemento.

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

L'esempio seguente verifica se l'array `[1, 2, 3]` contiene il valore. `4` Poiché l'array`[1, 2, 3`] non contiene il valore`4`, viene restituita la funzione array\$1contains. `false` 

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

L'esempio seguente verifica se l'array `[1, 2, 3]` contiene il valore. `2` Poiché l'array `[1, 2, 3]` contiene il valore`2`, viene restituita la funzione array\$1contains. `true` 

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

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

La funzione ARRAY\$1DISTINCT può essere utilizzata per rimuovere valori duplicati da un array. La funzione ARRAY\$1DISTINCT è utile quando è necessario rimuovere i duplicati da un array e lavorare solo con gli elementi unici. Ciò può essere utile in scenari in cui si desidera eseguire operazioni o analisi su un set di dati senza l'interferenza di valori ripetuti.

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

```
array_distinct(array)
```

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

 *matrice*  
Un'espressione ARRAY.

## Tipo restituito
<a name="array_distinct-return-type"></a>

La funzione ARRAY\$1DISTINCT restituisce un ARRAY che contiene solo gli elementi unici dell'array di input. 

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

In questo esempio, l'array di input `[1, 2, 3, null, 3]` contiene un valore duplicato di. `3` La `array_distinct` funzione rimuove questo valore duplicato `3` e restituisce un nuovo array con gli elementi unici:. `[1, 2, 3, null]`

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

In questo esempio, la matrice di input `[1, 2, 2, 3, 3, 3]` contiene valori duplicati di `2` e. `3` La `array_distinct` funzione rimuove questi duplicati e restituisce un nuovo array con gli elementi unici:. `[1, 2, 3]`

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

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

La funzione ARRAY\$1EXCEPT accetta due array come argomenti e restituisce un nuovo array che contiene solo gli elementi presenti nel primo array ma non nel secondo array.

ARRAY\$1EXCEPT è utile quando è necessario trovare gli elementi che sono unici per un array rispetto a un altro. Questo può essere utile in scenari in cui è necessario eseguire operazioni simili a set sugli array, come trovare la differenza tra due set di dati.

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

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

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

 *matrice 1*  
Un ARRAY di qualsiasi tipo con elementi comparabili.

 *matrice 2*  
*Un ARRAY di elementi che condividono un tipo meno comune con gli elementi di array1.*

## Tipo restituito
<a name="array_except-return-type"></a>

*La funzione ARRAY\$1EXCEPT restituisce un ARRAY di tipo corrispondente a array1 senza duplicati.*

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

In questo esempio, il primo array `[1, 2, 3]` contiene gli elementi 1, 2 e 3. Il secondo array `[2, 3, 4]` contiene gli elementi 2, 3 e 4. La `array_except` funzione rimuove gli elementi 2 e 3 dal primo array, poiché sono presenti anche nel secondo array. L'output risultante è l'array`[1]`.

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

In questo esempio, il primo array `[1, 2, 3]` contiene gli elementi 1, 2 e 3. Il secondo array `[1, 3, 5]` contiene gli elementi 1, 3 e 5. La `array_except` funzione rimuove gli elementi 1 e 3 dal primo array, poiché sono presenti anche nel secondo array. L'output risultante è l'array`[2]`.

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

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

La funzione ARRAY\$1INTERSECT accetta due array come argomenti e restituisce un nuovo array che contiene gli elementi presenti in entrambi gli array di input. Questa funzione è utile quando è necessario trovare gli elementi comuni tra due array. Ciò può essere utile in scenari in cui è necessario eseguire operazioni simili a set sugli array, ad esempio trovare l'intersezione tra due set di dati.

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

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

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

 *matrice 1*  
Un ARRAY di qualsiasi tipo con elementi comparabili.

 *matrice 2*  
Un ARRAY di elementi che condividono un tipo meno comune con gli elementi di array1.

## Tipo restituito
<a name="array_intersect-return-type"></a>

La funzione ARRAY\$1INTERSECT restituisce un ARRAY di tipo corrispondente a array1 senza duplicati ed elementi contenuti sia in array1 che in array2.

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

In questo esempio, il primo array contiene gli elementi 1, 2 e 3. `[1, 2, 3]` Il secondo array `[1, 3, 5]` contiene gli elementi 1, 3 e 5. La funzione ARRAY\$1INTERSECT identifica gli elementi comuni tra i due array, che sono 1 e 3. L'array `[1, 3]` di output risultante è.

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

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

La funzione ARRAY\$1JOIN accetta due argomenti: il primo argomento è l'array di input che verrà unito. Il secondo argomento è la stringa separatrice che verrà utilizzata per concatenare gli elementi dell'array. Questa funzione è utile quando è necessario convertire una matrice di stringhe (o qualsiasi altro tipo di dati) in un'unica stringa concatenata. Ciò può essere utile negli scenari in cui si desidera presentare una matrice di valori come una singola stringa formattata, ad esempio per scopi di visualizzazione o per l'utilizzo in ulteriori elaborazioni.

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

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

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

 *matrice*  
Qualsiasi tipo di ARRAY, ma i relativi elementi vengono interpretati come stringhe.

 *delimiter*  
Una STRINGA utilizzata per separare gli elementi dell'array concatenati.

 *Sostituzione nulla*  
Una STRINGA usata per esprimere un valore NULL nel risultato.

## Tipo restituito
<a name="array_join-return-type"></a>

La funzione ARRAY\$1JOIN restituisce una STRING in cui gli elementi dell'array sono separati da un delimitatore e vengono sostituiti gli elementi nulli. `nullReplacement` Se `nullReplacement` viene omesso, gli elementi vengono filtrati. `null` Se un argomento è`NULL`, il risultato è. `NULL`

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

In questo esempio, la funzione ARRAY\$1JOIN prende l'array `['hello', 'world']` e unisce gli elementi utilizzando il separatore `' '` (un carattere di spazio). L'output risultante è la stringa. `'hello world'` 

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

In questo esempio, la funzione ARRAY\$1JOIN prende l'array `['hello', null, 'world']` e unisce gli elementi utilizzando il separatore `' '` (un carattere di spazio). Il `null` valore viene sostituito con la stringa `','` sostitutiva fornita (una virgola). L'output risultante è la stringa`'hello , world'`.

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

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

La funzione ARRAY\$1REMOVE accetta due argomenti: il primo argomento è l'array di input da cui verranno rimossi gli elementi. Il secondo argomento è il valore che verrà rimosso dall'array. Questa funzione è utile quando è necessario rimuovere elementi specifici da un array. Ciò può essere utile in scenari in cui è necessario eseguire la pulizia o la preelaborazione dei dati su una matrice di valori.

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

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

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

 *matrice*  
Un ARRAY.

 *elemento*  
Un'espressione di un tipo che condivide un tipo meno comune con gli elementi dell'array.

## Tipo restituito
<a name="array_remove-return-type"></a>

La funzione ARRAY\$1REMOVE restituisce il tipo di risultato corrispondente al tipo dell'array. Se l'elemento da rimuovere è`NULL`, il risultato è. `NULL`

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

In questo esempio, la funzione ARRAY\$1REMOVE prende l'array `[1, 2, 3, null, 3]` e rimuove tutte le occorrenze del valore 3. L'output risultante è l'array. `[1, 2, null]` 

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

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

La funzione ARRAY\$1UNION accetta due array come argomenti e restituisce un nuovo array che contiene gli elementi unici di entrambi gli array di input. Questa funzione è utile quando è necessario combinare due array ed eliminare eventuali elementi duplicati. Ciò può essere utile in scenari in cui è necessario eseguire operazioni simili a set sugli array, ad esempio trovare l'unione tra due set di dati.

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

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

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

 *matrice 1*  
Un ARRAY.

 *matrice 2*  
*Un ARRAY dello stesso tipo di array1.*

## Tipo restituito
<a name="array_union-return-type"></a>

La funzione ARRAY\$1UNION restituisce un ARRAY dello stesso tipo di array.

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

In questo esempio, il primo array `[1, 2, 3]` contiene gli elementi 1, 2 e 3. Il secondo array `[1, 3, 5]` contiene gli elementi 1, 3 e 5. La funzione ARRAY\$1UNION combina gli elementi unici di entrambi gli array, dando origine all'array di output. `[1, 2, 3, 5]` T

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

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

La funzione EXPLODE viene utilizzata per trasformare una singola riga con una matrice o una colonna di mappa in più righe, in cui ogni riga corrisponde a un singolo elemento dell'array o della mappa.

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

```
explode(expr)
```

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

 *expr*  
Un'espressione di matrice o un'espressione cartografica. 

## Tipo restituito
<a name="explode-return-type"></a>

La funzione EXPLODE restituisce un set di righe, in cui ogni riga rappresenta un singolo elemento della matrice o della mappa di input.

Il tipo di dati delle righe di output dipende dal tipo di dati degli elementi nella matrice o nella mappa di input. 

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

L'esempio seguente prende l'array a riga singola [10, 20] e lo trasforma in due righe separate, ciascuna contenente uno degli elementi dell'array (10 e 20).

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

Nel primo esempio, l'array di input è stato passato direttamente come argomento a. `explode()` In questo esempio, l'array di input viene specificato utilizzando la `=>` sintassi, in cui viene fornito esplicitamente il nome della colonna (`collection`).

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

Entrambi gli approcci sono validi e consentono di ottenere lo stesso risultato, ma la seconda sintassi può essere più utile quando è necessario esplodere una colonna da un set di dati più grande, anziché un semplice array letterale.

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

La funzione FLATTEN viene utilizzata per «appiattire» una struttura a matrice annidata in una singola matrice piatta.

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

```
flatten(arrayOfArrays)
```

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

 *arrayOfArrays*  
Una serie di array.

## Tipo restituito
<a name="flatten-return-type"></a>

La funzione FLATTEN restituisce un array.

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

In questo esempio, l'input è un array annidato con due array interni e l'output è un singolo array flat contenente tutti gli elementi degli array interni. La funzione FLATTEN prende l'array annidato `[[1, 2], [3, 4]]` e combina tutti gli elementi in un unico array. `[1, 2, 3, 4]`

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