As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Funções de array
<a name="Array_Functions"></a>

Esta seção descreve as funções de matriz para SQL suportadas no AWS Clean Rooms. 

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

# Função ARRAY
<a name="array"></a>

Cria uma matriz com os elementos fornecidos.

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

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

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

 *expr1, expr2*   
Expressões de qualquer tipo de dados, exceto tipos de data e hora. Os argumentos não precisam ser do mesmo tipo de dado.

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

A função de matriz retorna uma MATRIZ com os elementos na expressão.

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

O exemplo a seguir mostra uma matriz de valores numéricos e uma matriz de diferentes tipos de dados.

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

# função ARRAY\$1CONTAINS
<a name="array_contains"></a>

A função ARRAY\$1CONTAINS pode ser usada para realizar verificações básicas de associação em estruturas de dados de matriz. A função ARRAY\$1CONTAINS é útil quando você precisa verificar se um valor específico está presente em uma matriz.

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

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

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

 *array*  
Uma MATRIZ a ser pesquisada.

 *value*  
Uma expressão com um tipo que compartilha um tipo menos comum com os elementos da matriz.

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

A função ARRAY\$1CONTAINS retorna um BOOLEAN. 

Se o valor for NULL, o resultado será NULL. 

Se algum elemento na matriz for NULL, o resultado será NULL se o valor não corresponder a nenhum outro elemento.

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

O exemplo a seguir verifica se a matriz `[1, 2, 3]` contém o valor`4`. Como a matriz`[1, 2, 3`] não contém o valor`4`, a função array\$1contains retorna. `false` 

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

O exemplo a seguir verifica se a matriz `[1, 2, 3]` contém o valor`2`. Como a matriz `[1, 2, 3]` contém o valor`2`, a função array\$1contains retorna. `true` 

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

# função ARRAY\$1DISTINCT
<a name="array_distinct"></a>

A função ARRAY\$1DISTINCT pode ser usada para remover valores duplicados de uma matriz. A função ARRAY\$1DISTINCT é útil quando você precisa remover duplicatas de uma matriz e trabalhar somente com os elementos exclusivos. Isso pode ser útil em cenários em que você deseja realizar operações ou análises em um conjunto de dados sem a interferência de valores repetidos.

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

```
array_distinct(array)
```

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

 *array*  
Uma expressão ARRAY.

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

A função ARRAY\$1DISTINCT retorna uma MATRIZ que contém somente os elementos exclusivos da matriz de entrada. 

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

Neste exemplo, a matriz de entrada `[1, 2, 3, null, 3]` contém um valor duplicado de`3`. A `array_distinct` função remove esse valor duplicado `3` e retorna uma nova matriz com os elementos exclusivos:`[1, 2, 3, null]`.

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

Neste exemplo, a matriz de entrada `[1, 2, 2, 3, 3, 3]` contém valores duplicados de `2` e. `3` A `array_distinct` função remove essas duplicatas e retorna uma nova matriz com os elementos exclusivos:`[1, 2, 3]`.

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

# função ARRAY\$1EXCEPT
<a name="array_except"></a>

A função ARRAY\$1EXCEPT usa duas matrizes como argumentos e retorna uma nova matriz que contém somente os elementos presentes na primeira matriz, mas não na segunda matriz.

O ARRAY\$1EXCEPT é útil quando você precisa encontrar os elementos que são exclusivos de uma matriz em comparação com outra. Isso pode ser útil em cenários em que você precisa realizar operações semelhantes a conjuntos em matrizes, como encontrar a diferença entre dois conjuntos de dados.

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

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

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

 *matriz1*  
Uma MATRIZ de qualquer tipo com elementos comparáveis.

 *matriz2*  
Uma MATRIZ de elementos que compartilham um tipo menos comum com os elementos de *array1*.

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

A função ARRAY\$1EXCEPT retorna um ARRAY do tipo correspondente ao *array1* sem duplicatas.

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

Neste exemplo, a primeira matriz `[1, 2, 3]` contém os elementos 1, 2 e 3. A segunda matriz `[2, 3, 4]` contém os elementos 2, 3 e 4. A `array_except` função remove os elementos 2 e 3 da primeira matriz, pois eles também estão presentes na segunda matriz. A saída resultante é a matriz`[1]`.

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

Neste exemplo, a primeira matriz `[1, 2, 3]` contém os elementos 1, 2 e 3. A segunda matriz `[1, 3, 5]` contém os elementos 1, 3 e 5. A `array_except` função remove os elementos 1 e 3 da primeira matriz, pois eles também estão presentes na segunda matriz. A saída resultante é a matriz`[2]`.

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

# função ARRAY\$1INTERSECT
<a name="array_intersect"></a>

A função ARRAY\$1INTERSECT usa duas matrizes como argumentos e retorna uma nova matriz que contém os elementos presentes nas duas matrizes de entrada. Essa função é útil quando você precisa encontrar os elementos comuns entre duas matrizes. Isso pode ser útil em cenários em que você precisa realizar operações semelhantes a conjuntos em matrizes, como encontrar a interseção entre dois conjuntos de dados.

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

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

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

 *matriz1*  
Uma MATRIZ de qualquer tipo com elementos comparáveis.

 *matriz2*  
Uma MATRIZ de elementos que compartilham um tipo menos comum com os elementos de array1.

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

A função ARRAY\$1INTERSECT retorna uma MATRIZ do tipo correspondente à matriz1 sem duplicatas e elementos contidos na matriz1 e na matriz2.

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

Neste exemplo, a primeira matriz `[1, 2, 3]` contém os elementos 1, 2 e 3. A segunda matriz `[1, 3, 5]` contém os elementos 1, 3 e 5. A função ARRAY\$1INTERSECT identifica os elementos comuns entre as duas matrizes, que são 1 e 3. A matriz de saída resultante é`[1, 3]`.

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

# função ARRAY\$1JOIN
<a name="array_join"></a>

A função ARRAY\$1JOIN usa dois argumentos: o primeiro argumento é a matriz de entrada que será unida. O segundo argumento é a string separadora que será usada para concatenar os elementos da matriz. Essa função é útil quando você precisa converter uma matriz de strings (ou qualquer outro tipo de dados) em uma única string concatenada. Isso pode ser útil em cenários em que você deseja apresentar uma matriz de valores como uma única string formatada, por exemplo, para fins de exibição ou para uso em processamento posterior.

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

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

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

 *array*  
Qualquer tipo de ARRAY, mas seus elementos são interpretados como strings.

 *delimitador*  
Uma STRING usada para separar os elementos concatenados da matriz.

 *Substituição nula*  
Uma STRING usada para expressar um valor NULL no resultado.

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

A função ARRAY\$1JOIN retorna uma STRING em que os elementos da matriz são separados por delimitador e os elementos nulos são substituídos. `nullReplacement` Se `nullReplacement` for omitido, os `null` elementos serão filtrados. Se houver algum argumento`NULL`, o resultado é`NULL`.

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

Neste exemplo, a função ARRAY\$1JOIN pega a matriz `['hello', 'world']` e une os elementos usando o separador `' '` (um caractere de espaço). A saída resultante é a string`'hello world'`. 

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

Neste exemplo, a função ARRAY\$1JOIN pega a matriz `['hello', null, 'world']` e une os elementos usando o separador `' '` (um caractere de espaço). O `null` valor é substituído pela string de substituição fornecida `','` (uma vírgula). A saída resultante é a string`'hello , world'`.

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

# função ARRAY\$1REMOVE
<a name="array_remove"></a>

A função ARRAY\$1REMOVE usa dois argumentos: o primeiro argumento é a matriz de entrada da qual os elementos serão removidos. O segundo argumento é o valor que será removido da matriz. Essa função é útil quando você precisa remover elementos específicos de uma matriz. Isso pode ser útil em cenários em que você precisa realizar a limpeza ou o pré-processamento de dados em uma matriz de valores.

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

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

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

 *array*  
Um ARRAY.

 *Elemento*  
Uma expressão de um tipo que compartilha um tipo menos comum com os elementos da matriz.

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

A função ARRAY\$1REMOVE retorna o tipo de resultado correspondente ao tipo da matriz. Se o elemento a ser removido for`NULL`, o resultado será`NULL`.

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

Neste exemplo, a função ARRAY\$1REMOVE pega a matriz `[1, 2, 3, null, 3]` e remove todas as ocorrências do valor 3. A saída resultante é a matriz`[1, 2, null]`. 

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

# função ARRAY\$1UNION
<a name="array_union"></a>

A função ARRAY\$1UNION usa duas matrizes como argumentos e retorna uma nova matriz que contém os elementos exclusivos de ambas as matrizes de entrada. Essa função é útil quando você precisa combinar duas matrizes e eliminar quaisquer elementos duplicados. Isso pode ser útil em cenários em que você precisa realizar operações semelhantes a conjuntos em matrizes, como encontrar a união entre dois conjuntos de dados.

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

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

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

 *matriz1*  
Um ARRAY.

 *matriz2*  
Um ARRAY do mesmo tipo que *array1*.

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

A função ARRAY\$1UNION retorna uma MATRIZ do mesmo tipo da matriz.

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

Neste exemplo, a primeira matriz `[1, 2, 3]` contém os elementos 1, 2 e 3. A segunda matriz `[1, 3, 5]` contém os elementos 1, 3 e 5. A função ARRAY\$1UNION combina os elementos exclusivos de ambas as matrizes, resultando na matriz de saída. `[1, 2, 3, 5]` T

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

# Função EXPLODE
<a name="explode"></a>

A função EXPLODE é usada para transformar uma única linha com uma matriz ou coluna de mapa em várias linhas, onde cada linha corresponde a um único elemento da matriz ou do mapa.

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

```
explode(expr)
```

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

 *expr*  
Uma expressão de matriz ou uma expressão de mapa. 

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

A função EXPLODE retorna um conjunto de linhas, em que cada linha representa um único elemento da matriz ou mapa de entrada.

O tipo de dados das linhas de saída depende do tipo de dados dos elementos na matriz de entrada ou no mapa. 

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

O exemplo a seguir pega a matriz de linha única [10, 20] e a transforma em duas linhas separadas, cada uma contendo um dos elementos da matriz (10 e 20).

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

No primeiro exemplo, a matriz de entrada foi passada diretamente como argumento para`explode()`. Neste exemplo, a matriz de entrada é especificada usando a `=>` sintaxe, em que o nome da coluna (`collection`) é fornecido explicitamente.

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

Ambas as abordagens são válidas e alcançam o mesmo resultado, mas a segunda sintaxe pode ser mais útil quando você precisa explodir uma coluna de um conjunto de dados maior, em vez de apenas uma simples matriz literal.

# Função FLATTEN
<a name="flatten"></a>

A função FLATTEN é usada para “nivelar” uma estrutura de matriz aninhada em uma única matriz plana.

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

```
flatten(arrayOfArrays)
```

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

 *arrayOfArrays*  
Uma matriz de matrizes.

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

A função FLATTEN retorna uma matriz.

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

Neste exemplo, a entrada é uma matriz aninhada com duas matrizes internas e a saída é uma única matriz plana contendo todos os elementos das matrizes internas. A função FLATTEN pega a matriz aninhada `[[1, 2], [3, 4]]` e combina todos os elementos em uma única matriz. `[1, 2, 3, 4]`

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