Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Funciones de matriz
<a name="Array_Functions"></a>

En esta sección se describen las funciones de matriz de SQL admitidas en AWS Clean Rooms. 

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

# Función ARRAY
<a name="array"></a>

Crea una matriz con los elementos dados.

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

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

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

 *expr1, expr2*   
Expresiones de cualquier tipo de datos, excepto los tipos de datos de fecha y hora. Los argumentos no tienen que ser del mismo tipo de datos.

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

La función de matriz devuelve una MATRIZ con los elementos de la expresión.

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

El siguiente ejemplos muestra una matriz de valores numéricos y una matriz de diferentes tipos de datos.

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

# Función ARRAY\$1CONTAINS
<a name="array_contains"></a>

La función ARRAY\$1CONTAINS se puede utilizar para realizar comprobaciones básicas de pertenencia en estructuras de datos de matrices. La función ARRAY\$1CONTAINS es útil cuando se necesita comprobar si un valor específico está presente en una matriz.

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

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

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

 *array*  
Un ARRAY que se va a buscar.

 *value*  
Una expresión con un tipo que comparte un tipo menos común con los elementos de la matriz.

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

La función ARRAY\$1CONTAINS devuelve un BOOLEANO. 

Si el valor es NULL, el resultado es NULL. 

Si algún elemento de la matriz es NULL, el resultado es NULL si el valor no coincide con ningún otro elemento.

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

El siguiente ejemplo comprueba si la matriz `[1, 2, 3]` contiene el valor`4`. Como la matriz`[1, 2, 3`] no contiene el valor`4`, devuelve la función array\$1contains. `false` 

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

En el siguiente ejemplo, se comprueba si la matriz `[1, 2, 3]` contiene el valor. `2` Como la matriz `[1, 2, 3]` contiene el valor`2`, la función array\$1contains devuelve el valor. `true` 

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

# Función ARRAY\$1DISTINCT
<a name="array_distinct"></a>

La función ARRAY\$1DISTINCT se puede usar para eliminar valores duplicados de una matriz. La función ARRAY\$1DISTINCT es útil cuando necesita eliminar los duplicados de una matriz y trabajar solo con los elementos únicos. Esto puede resultar útil en situaciones en las que desee realizar operaciones o análisis en un conjunto de datos sin la interferencia de valores repetidos.

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

```
array_distinct(array)
```

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

 *array*  
Una expresión matricial.

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

La función ARRAY\$1DISTINCT devuelve una MATRIZ que contiene solo los elementos únicos de la matriz de entrada. 

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

En este ejemplo, la matriz de entrada `[1, 2, 3, null, 3]` contiene un valor duplicado de. `3` La `array_distinct` función elimina este valor duplicado `3` y devuelve una nueva matriz con los elementos únicos:`[1, 2, 3, null]`.

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

En este ejemplo, la matriz de entrada `[1, 2, 2, 3, 3, 3]` contiene valores duplicados de `2` y`3`. La `array_distinct` función elimina estos duplicados y devuelve una nueva matriz con los elementos únicos:`[1, 2, 3]`.

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

# Función ARRAY\$1EXCEPT
<a name="array_except"></a>

La función ARRAY\$1EXCEPT toma dos matrices como argumentos y devuelve una nueva matriz que contiene solo los elementos que están presentes en la primera matriz, pero no en la segunda.

La ARRAY\$1EXCEPT es útil cuando se necesitan encontrar los elementos que son exclusivos de una matriz en comparación con otra. Esto puede resultar útil en situaciones en las que es necesario realizar operaciones similares a las de un conjunto en matrices, como encontrar la diferencia entre dos conjuntos de datos.

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

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

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

 *matriz1*  
Un ARRAY de cualquier tipo con elementos comparables.

 *matriz (2)*  
*Un ARRAY de elementos que comparten un tipo menos común con los elementos de array1.*

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

*La función ARRAY\$1EXCEPT devuelve una MATRIZ del tipo coincidente con la matriz 1 sin duplicados.*

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

En este ejemplo, la primera matriz `[1, 2, 3]` contiene los elementos 1, 2 y 3. La segunda matriz `[2, 3, 4]` contiene los elementos 2, 3 y 4. La `array_except` función elimina los elementos 2 y 3 de la primera matriz, ya que también están presentes en la segunda matriz. La salida resultante es la matriz`[1]`.

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

En este ejemplo, la primera matriz `[1, 2, 3]` contiene los elementos 1, 2 y 3. La segunda matriz `[1, 3, 5]` contiene los elementos 1, 3 y 5. La `array_except` función elimina los elementos 1 y 3 de la primera matriz, ya que también están presentes en la segunda matriz. La salida resultante es la matriz`[2]`.

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

# Función ARRAY\$1INTERSECT
<a name="array_intersect"></a>

La función ARRAY\$1INTERSECT toma dos matrices como argumentos y devuelve una nueva matriz que contiene los elementos que están presentes en ambas matrices de entrada. Esta función resulta útil cuando se necesitan encontrar los elementos comunes entre dos matrices. Esto puede resultar útil en situaciones en las que es necesario realizar operaciones similares a las de un conjunto en matrices, como encontrar la intersección entre dos conjuntos de datos.

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

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

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

 *matriz1*  
Un ARRAY de cualquier tipo con elementos comparables.

 *matriz (2)*  
Un ARRAY de elementos que comparten un tipo menos común con los elementos de array1.

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

La función ARRAY\$1INTERSECT devuelve un ARRAY del tipo coincidente con el de matriz1, sin duplicados y con elementos contenidos tanto en matriz1 como en matriz2.

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

En este ejemplo, la primera matriz contiene los elementos 1, 2 y 3. `[1, 2, 3]` La segunda matriz `[1, 3, 5]` contiene los elementos 1, 3 y 5. La función ARRAY\$1INTERSECT identifica los elementos comunes entre las dos matrices, que son 1 y 3. La matriz de salida resultante es. `[1, 3]`

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

# Función ARRAY\$1JOIN
<a name="array_join"></a>

La función ARRAY\$1JOIN utiliza dos argumentos: el primer argumento es la matriz de entrada que se unirá. El segundo argumento es la cadena separadora que se utilizará para concatenar los elementos de la matriz. Esta función resulta útil cuando se necesita convertir una matriz de cadenas (o cualquier otro tipo de datos) en una sola cadena concatenada. Esto puede resultar útil en situaciones en las que desee presentar una matriz de valores como una sola cadena con formato, por ejemplo, con fines de visualización o para su uso en un procesamiento posterior.

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

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

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

 *array*  
Cualquier tipo de matriz, pero sus elementos se interpretan como cadenas.

 *delimiter*  
Una CADENA que se utiliza para separar los elementos de la matriz concatenados.

 *Reemplazo nulo*  
Cadena que se utiliza para expresar un valor NULO en el resultado.

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

La función ARRAY\$1JOIN devuelve una cadena en la que los elementos de la matriz se separan mediante un delimitador y se sustituyen por elementos nulos. `nullReplacement` Si `nullReplacement` se omite, `null` los elementos se filtran. Si hay algún argumento`NULL`, el resultado es`NULL`.

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

En este ejemplo, la función ARRAY\$1JOIN toma la matriz `['hello', 'world']` y une los elementos mediante el separador `' '` (un carácter de espacio). El resultado es la cadena. `'hello world'` 

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

En este ejemplo, la función ARRAY\$1JOIN toma la matriz `['hello', null, 'world']` y une los elementos mediante el separador `' '` (un carácter de espacio). El `null` valor se sustituye por la cadena de sustitución proporcionada `','` (una coma). El resultado es la cadena`'hello , world'`.

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

# Función ARRAY\$1REMOVE
<a name="array_remove"></a>

La función ARRAY\$1REMOVE utiliza dos argumentos: el primer argumento es la matriz de entrada de la que se eliminarán los elementos. El segundo argumento es el valor que se eliminará de la matriz. Esta función es útil cuando se necesitan eliminar elementos específicos de una matriz. Esto puede resultar útil en situaciones en las que es necesario realizar una limpieza de datos o un preprocesamiento de una matriz de valores.

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

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

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

 *array*  
Un ARRAY.

 *element*  
Una expresión de un tipo que comparte un tipo menos común con los elementos de una matriz.

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

La función ARRAY\$1REMOVE devuelve el tipo de resultado que coincide con el tipo de matriz. Si el elemento que se va a eliminar es`NULL`, el resultado es. `NULL`

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

En este ejemplo, la función ARRAY\$1REMOVE toma la matriz `[1, 2, 3, null, 3]` y elimina todas las apariciones del valor 3. La salida resultante es la matriz. `[1, 2, null]` 

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

# Función ARRAY\$1UNION
<a name="array_union"></a>

La función ARRAY\$1UNION toma dos matrices como argumentos y devuelve una nueva matriz que contiene los elementos únicos de ambas matrices de entrada. Esta función resulta útil cuando se necesitan combinar dos matrices y eliminar cualquier elemento duplicado. Esto puede resultar útil en situaciones en las que es necesario realizar operaciones similares a las de un conjunto en matrices, como encontrar la unión entre dos conjuntos de datos.

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

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

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

 *matriz1*  
Un ARRAY.

 *Matriz 2*  
*Un ARRAY del mismo tipo que array1.*

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

La función ARRAY\$1UNION devuelve una MATRIZ del mismo tipo que una matriz.

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

En este ejemplo, la primera matriz `[1, 2, 3]` contiene los elementos 1, 2 y 3. La segunda matriz `[1, 3, 5]` contiene los elementos 1, 3 y 5. La función ARRAY\$1UNION combina los elementos únicos de ambas matrices, lo que da como resultado la matriz de salida. `[1, 2, 3, 5]` T

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

# Función EXPLODE
<a name="explode"></a>

La función EXPLODE se utiliza para transformar una sola fila con una matriz o columna de mapa en varias filas, donde cada fila corresponde a un único elemento de la matriz o el mapa.

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

```
explode(expr)
```

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

 *expr*  
Una expresión matricial o una expresión de mapa. 

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

La función EXPLODE devuelve un conjunto de filas, donde cada fila representa un único elemento de la matriz o mapa de entrada.

El tipo de datos de las filas de salida depende del tipo de datos de los elementos de la matriz o el mapa de entrada. 

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

El siguiente ejemplo toma la matriz de una sola fila [10, 20] y la transforma en dos filas independientes, cada una de las cuales contiene uno de los elementos de la matriz (10 y 20).

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

En el primer ejemplo, la matriz de entrada se pasó directamente como argumento a`explode()`. En este ejemplo, la matriz de entrada se especifica mediante la `=>` sintaxis, donde el nombre de la columna (`collection`) se proporciona de forma explícita.

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

Ambos enfoques son válidos y permiten obtener el mismo resultado, pero la segunda sintaxis puede resultar más útil cuando se necesita desglosar una columna de un conjunto de datos más grande, en lugar de limitarse a un simple literal de matriz.

# Función FLATTEN
<a name="flatten"></a>

La función FLATTEN se utiliza para «aplanar» una estructura de matriz anidada en una sola matriz plana.

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

```
flatten(arrayOfArrays)
```

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

 *arrayOfArrays*  
Matriz de matrices.

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

La función FLATTEN devuelve una matriz.

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

En este ejemplo, la entrada es una matriz anidada con dos matrices internas y la salida es una matriz plana única que contiene todos los elementos de las matrices internas. La función FLATTEN toma la matriz anidada `[[1, 2], [3, 4]]` y combina todos los elementos en una sola matriz. `[1, 2, 3, 4]`

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