> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-mintlify-3a82795f.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
> Documentación sobre las funciones de arrays
# Funciones de arrays
{/*AUTOGENERATED_START*/}
## array
Introducido en: v1.1.0
Crea un array a partir de los argumentos de la función.
Los argumentos deben ser constantes y tener tipos que compartan un supertipo común.
Debe pasarse al menos un argumento, porque de lo contrario no queda claro qué tipo de array se debe crear.
Esto significa que no se puede usar esta función para crear un array vacío. Para ello, use la función `emptyArray*`.
Use el operador `[ ]` para obtener la misma funcionalidad.
**Sintaxis**
```sql theme={null}
array(x1 [, x2, ..., xN])
```
**Argumentos**
* `x1` — Valor constante de cualquier tipo T. Si solo se proporciona este argumento, el array será de tipo T. - `[, x2, ..., xN]` — N valores constantes adicionales que comparten un supertipo común con `x1`
**Valor devuelto**
Devuelve un array, donde 'T' es el tipo común más pequeño entre los argumentos proporcionados. [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Uso válido**
```sql title=Query theme={null}
SELECT array(toInt32(1), toUInt16(2), toInt8(3)) AS a, toTypeName(a)
```
```response title=Response theme={null}
┌─a───────┬─toTypeName(a)─┐
│ [1,2,3] │ Array(Int32) │
└─────────┴───────────────┘
```
**Uso incorrecto**
```sql title=Query theme={null}
SELECT array(toInt32(5), toDateTime('1998-06-16'), toInt8(5)) AS a, toTypeName(a)
```
```response title=Response theme={null}
Received exception from server (version 25.4.3):
Code: 386. DB::Exception: Received from localhost:9000. DB::Exception:
There is no supertype for types Int32, DateTime, Int8 ...
```
## arrayAUCPR
Introducido en: v20.4.0
Calcula el área bajo la curva de precisión-exhaustividad (PR).
Una curva de precisión-exhaustividad se crea representando la precisión en el eje y y la exhaustividad en el eje x para todos los umbrales.
El valor resultante va de 0 a 1, y un valor más alto indica un mejor rendimiento del modelo.
La PR AUC es especialmente útil para conjuntos de datos desbalanceados, ya que proporciona una comparación del rendimiento más clara que la ROC AUC en esos casos.
Para obtener más detalles, consulte [aquí](https://developers.google.com/machine-learning/glossary#pr-auc-area-under-the-pr-curve), [aquí](https://developers.google.com/machine-learning/crash-course/classification/roc-and-auc#expandable-1) y [aquí](https://en.wikipedia.org/wiki/Receiver_operating_characteristic#Area_under_the_curve).
**Sintaxis**
```sql theme={null}
arrayAUCPR(scores, labels[, partial_offsets])
```
**Alias**: `arrayPRAUC`
**Argumentos**
* `cores` — Puntuaciones que genera el modelo de predicción. [`Array((U)Int*)`](/es/reference/data-types/array) o [`Array(Float*)`](/es/reference/data-types/array)
* `labels` — Etiquetas de las muestras, normalmente 1 para una muestra positiva y 0 para una muestra negativa. [`Array((U)Int*)`](/es/reference/data-types/array) o [`Array(Enum)`](/es/reference/data-types/array)
* `partial_offsets` —
* Opcional. Un [`Array(T)`](/es/reference/data-types/array) de tres enteros no negativos para calcular un área parcial bajo la curva PR (equivalente a una banda vertical del espacio PR) en lugar del AUC completo. Esta opción es útil para el cálculo distribuido del AUC PR. El array debe contener los siguientes elementos \[`higher_partitions_tp`, `higher_partitions_fp`, `total_positives`].
* `higher_partitions_tp`: El número de etiquetas positivas en las particiones con puntuaciones más altas.
* `higher_partitions_fp`: El número de etiquetas negativas en las particiones con puntuaciones más altas.
* `total_positives`: El número total de muestras positivas en todo el conjunto de datos.
Cuando se usa `arr_partial_offsets`, `arr_scores` y `arr_labels` deben ser solo una partición del conjunto de datos completo, que contenga un intervalo de puntuaciones.
El conjunto de datos debe dividirse en particiones contiguas, donde cada partición contenga el subconjunto de datos cuyas puntuaciones se encuentren dentro de un rango específico.
Por ejemplo:
* Una partición podría contener todas las puntuaciones en el rango \[0, 0.5).
* Otra partición podría contener puntuaciones en el rango \[0.5, 1.0].
**Valor devuelto**
Devuelve el área bajo la curva de precisión-recall (PR). [`Float64`](/es/reference/data-types/float)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT arrayAUCPR([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1]);
```
```response title=Response theme={null}
┌─arrayAUCPR([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1])─┐
│ 0.8333333333333333 │
└─────────────────────────────────────────────────┘
```
## arrayAll
Introducido en: v1.1.0
Devuelve `1` si la lambda `func(x [, y1, y2, ... yN])` devuelve `true` para todos los elementos. En caso contrario, devuelve `0`.
**Sintaxis**
```sql theme={null}
arrayAll(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])
```
**Argumentos**
* `func(x[, y1, ..., yN])` — Una función lambda que opera sobre los elementos del array de origen (`x`) y de los arrays de condición (`y`). [`Función lambda`](/es/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — El array de origen que se va a procesar. [`Array(T)`](/es/reference/data-types/array)
* `cond1_arr, ...` — Opcional. N arrays de condición que proporcionan argumentos adicionales a la función lambda. [`Array(T)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve `1` si la función lambda devuelve `true` para todos los elementos; en caso contrario, `0` [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Todos los elementos cumplen la condición**
```sql title=Query theme={null}
SELECT arrayAll(x, y -> x=y, [1, 2, 3], [1, 2, 3])
```
```response title=Response theme={null}
1
```
**No todos los elementos coinciden**
```sql title=Query theme={null}
SELECT arrayAll(x, y -> x=y, [1, 2, 3], [1, 1, 1])
```
```response title=Response theme={null}
0
```
## arrayAutocorrelation
Introducido en: v26.4.0
Calcula la autocorrelación de un array.
Si se proporciona `max_lag`, calcula la correlación solo para los retrasos del intervalo `[0, max_lag)`.
Si no se proporciona `max_lag`, la calcula para todos los retrasos posibles.
**Sintaxis**
```sql theme={null}
arrayAutocorrelation(arr, [max_lag])
```
**Argumentos**
* `arr` — Array de números. [`Array(T)`](/es/reference/data-types/array)
* `max_lag` — Opcional. Número máximo de retrasos que se van a calcular. Debe ser un entero no negativo. [`Integer`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve un array de Float64. Devuelve NaN si la varianza es 0. [`Array(Float64)`](/es/reference/data-types/array)
**Ejemplos**
**Lineal**
```sql title=Query theme={null}
SELECT arrayAutocorrelation([1, 2, 3, 4, 5]);
```
```response title=Response theme={null}
[1, 0.4, -0.1, -0.4, -0.4]
```
**Simétrica**
```sql title=Query theme={null}
SELECT arrayAutocorrelation([10, 20, 10]);
```
```response title=Response theme={null}
[1, -0.6666666666666669, 0.16666666666666674]
```
**Constante**
```sql title=Query theme={null}
SELECT arrayAutocorrelation([5, 5, 5]);
```
```response title=Response theme={null}
[nan, nan, nan]
```
**Limitado**
```sql title=Query theme={null}
SELECT arrayAutocorrelation([1, 2, 3, 4, 5], 2);
```
```response title=Response theme={null}
[1, 0.4]
```
## arrayAvg
Introducido en: v21.1.0
Devuelve el promedio de los elementos del array de origen.
Si se especifica una función lambda `func`, devuelve el promedio de los elementos obtenidos como resultado de la lambda.
**Sintaxis**
```sql theme={null}
arrayAvg([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])
```
**Argumentos**
* `func(x[, y1, ..., yN])` — Opcional. Una función lambda que opera sobre los elementos del array de origen (`x`) y los arrays de condición (`y`). [`Función lambda`](/es/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — El array de origen que se va a procesar. [`Array(T)`](/es/reference/data-types/array)
* `[, cond1_arr, ... , condN_arr]` — Opcional. N arrays de condición que proporcionan argumentos adicionales a la función lambda. [`Array(T)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve el promedio de los elementos del array de origen o, si se proporciona, el promedio de los elementos resultantes de la lambda. [`Float64`](/es/reference/data-types/float)
**Ejemplos**
**Ejemplo básico**
```sql title=Query theme={null}
SELECT arrayAvg([1, 2, 3, 4]);
```
```response title=Response theme={null}
2.5
```
**Uso con una función lambda**
```sql title=Query theme={null}
SELECT arrayAvg(x, y -> x*y, [2, 3], [2, 3]) AS res;
```
```response title=Response theme={null}
6.5
```
## arrayCompact
Introducido en: v20.1.0
Elimina los elementos duplicados consecutivos de un array, incluidos los valores `null`. El orden de los valores del array resultante viene determinado por el orden del array de origen.
**Sintaxis**
```sql theme={null}
arrayCompact(arr)
```
**Argumentos**
* `arr` — Un array del que se eliminarán los duplicados. [`Array(T)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve un array sin valores duplicados [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT arrayCompact([1, 1, nan, nan, 2, 3, 3, 3]);
```
```response title=Response theme={null}
[1,nan,2,3]
```
## arrayConcat
Introducido en: v1.1.0
Combina los arrays que se pasan como argumentos.
**Sintaxis**
```sql theme={null}
arrayConcat(arr1 [, arr2, ... , arrN])
```
**Argumentos**
* `arr1 [, arr2, ... , arrN]` — Número N de arrays que se concatenan. [`Array(T)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve un único array combinado a partir de los arrays proporcionados como argumentos. [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT arrayConcat([1, 2], [3, 4], [5, 6]) AS res
```
```response title=Response theme={null}
[1, 2, 3, 4, 5, 6]
```
## arrayCount
Introducido en: v1.1.0
Devuelve el número de elementos para los cuales `func(arr1[i], ..., arrN[i])` devuelve true.
Si no se especifica `func`, devuelve el número de elementos no nulos del array.
`arrayCount` es una [función de orden superior](/es/reference/functions/regular-functions/overview#higher-order-functions).
**Sintaxis**
```sql theme={null}
arrayCount([func, ] arr1, ...)
```
**Argumentos**
* `func` — Opcional. Función que se aplicará a cada elemento de los arrays. [`Función lambda`](/es/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `arr1, ..., arrN` — N arrays. [`Array(T)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve el número de elementos para los que `func` devuelve true. En caso contrario, devuelve el número de elementos no nulos del array. [`UInt32`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT arrayCount(x -> (x % 2), groupArray(number)) FROM numbers(10)
```
```response title=Response theme={null}
5
```
## arrayCumSum
Introducido en: v1.1.0
Devuelve un array con las sumas parciales (acumuladas) de los elementos del array de origen. Si se especifica una función lambda, la suma se calcula aplicando la función lambda a los elementos del array en cada posición.
**Sintaxis**
```sql theme={null}
arrayCumSum([func,] arr1[, arr2, ... , arrN])
```
**Argumentos**
* `func` — Opcional. Una función lambda que se aplica a los elementos del array en cada posición. [`Función lambda`](/es/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `arr1` — El array de origen de valores numéricos. [`Array(T)`](/es/reference/data-types/array)
* `[arr2, ..., arrN]` — Opcional. Arrays adicionales del mismo tamaño, que se pasan como argumentos a la función lambda si se especifica. [`Array(T)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve un array con las sumas parciales de los elementos del array de origen. El tipo del resultado coincide con el tipo numérico del array de entrada. [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Uso básico**
```sql title=Query theme={null}
SELECT arrayCumSum([1, 1, 1, 1]) AS res
```
```response title=Response theme={null}
[1, 2, 3, 4]
```
**Con una función lambda**
```sql title=Query theme={null}
SELECT arrayCumSum(x -> x * 2, [1, 2, 3]) AS res
```
```response title=Response theme={null}
[2, 6, 12]
```
## arrayCumSumNonNegative
Introducido en: v18.12.0
Devuelve un array de las sumas parciales acumuladas de los elementos del array de origen, reemplazando por cero cualquier suma acumulada negativa. Si se especifica una función lambda, la suma se calcula aplicando la función lambda a los elementos del array en cada posición.
**Sintaxis**
```sql theme={null}
arrayCumSumNonNegative([func,] arr1[, arr2, ... , arrN])
```
**Argumentos**
* `func` — Opcional. Una función lambda que se aplica a los elementos del array en cada posición. [`Función lambda`](/es/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `arr1` — El array de origen de valores numéricos. [`Array(T)`](/es/reference/data-types/array)
* `[arr2, ..., arrN]` — Opcional. Arrays adicionales del mismo tamaño, que se pasan como argumentos a la función lambda si se especifica. [`Array(T)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve un array con las sumas parciales de los elementos del array de origen, donde cualquier suma acumulada negativa se reemplaza por cero. El tipo del resultado coincide con el tipo numérico del array de entrada. [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Uso básico**
```sql title=Query theme={null}
SELECT arrayCumSumNonNegative([1, 1, -4, 1]) AS res
```
```response title=Response theme={null}
[1, 2, 0, 1]
```
**Con una lambda**
```sql title=Query theme={null}
SELECT arrayCumSumNonNegative(x -> x * 2, [1, -2, 3]) AS res
```
```response title=Response theme={null}
[2, 0, 6]
```
## arrayDifference
Introducido en: v1.1.0
Calcula un array de diferencias entre elementos adyacentes de un array.
El primer elemento del array resultante será 0; el segundo, `arr[1] - arr[0]`; el tercero, `arr[2] - arr[1]`; etc.
El tipo de los elementos del array resultante se determina según las reglas de inferencia de tipos para la resta (p. ej., `UInt8` - `UInt8` = `Int16`).
**Sintaxis**
```sql theme={null}
arrayDifference(arr)
```
**Argumentos**
* `arr` — Array para el que se calculan las diferencias entre elementos adyacentes. [`Array(T)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve un array con las diferencias entre elementos adyacentes del array [`UInt*`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT arrayDifference([1, 2, 3, 4]);
```
```response title=Response theme={null}
[0,1,1,1]
```
**Ejemplo de desbordamiento por el tipo de resultado Int64**
```sql title=Query theme={null}
SELECT arrayDifference([0, 10000000000000000000]);
```
```response title=Response theme={null}
┌─arrayDifference([0, 10000000000000000000])─┐
│ [0,-8446744073709551616] │
└────────────────────────────────────────────┘
```
## arrayDistinct
Introducido en: v1.1.0
Devuelve un array que contiene solo los elementos distintos de un array.
**Sintaxis**
```sql theme={null}
arrayDistinct(arr)
```
**Argumentos**
* `arr` — Array del que se extraen los elementos distintos. [`Array(T)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve un array que contiene los elementos distintos. [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT arrayDistinct([1, 2, 2, 3, 1]);
```
```response title=Response theme={null}
[1,2,3]
```
## arrayDotProduct
Introducido en: v23.5.0
Devuelve el producto escalar de dos arrays.
Los dos vectores deben tener el mismo tamaño. Los Arrays y Tuples también pueden contener elementos de distintos tipos.
**Sintaxis**
```sql theme={null}
arrayDotProduct(v1, v2)
```
**Argumentos**
* `v1` — Primer vector. [`Array((U)Int* | Float* | Decimal)`](/es/reference/data-types/array) o [`Tuple((U)Int* | Float* | Decimal)`](/es/reference/data-types/tuple)
* `v2` — Segundo vector. [`Array((U)Int* | Float* | Decimal)`](/es/reference/data-types/array) o [`Tuple((U)Int* | Float* | Decimal)`](/es/reference/data-types/tuple)
**Valor devuelto**
El producto escalar de ambos vectores.
El tipo de retorno se determina según el tipo de los argumentos. Si los Arrays o Tuples contienen tipos de elemento mixtos, el tipo del resultado será el supertipo.
[`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal)
**Ejemplos**
**Ejemplo de Array**
```sql title=Query theme={null}
SELECT arrayDotProduct([1, 2, 3], [4, 5, 6]) AS res, toTypeName(res);
```
```response title=Response theme={null}
32 UInt16
```
**Ejemplo de Tuple**
```sql title=Query theme={null}
SELECT dotProduct((1::UInt16, 2::UInt8, 3::Float32),(4::Int16, 5::Float32, 6::UInt8)) AS res, toTypeName(res);
```
```response title=Response theme={null}
32 Float64
```
## arrayElement
Introducido en: v1.1.0
Obtiene el elemento del array proporcionado con el índice `n`, donde `n` puede ser de cualquier tipo entero.
Si el índice queda fuera de los límites de un array, devuelve un valor predeterminado (0 para números, una cadena vacía para Strings, etc.),
excepto en el caso de argumentos con un array no constante y un índice constante 0. En este caso, se producirá el error `Array indices are 1-based`.
Los arrays en ClickHouse están indexados desde 1.
Se admiten índices negativos. En este caso, se selecciona el elemento correspondiente, numerado desde el final. Por ejemplo, `arr[-1]` es el último elemento del array.
El operador `[n]` proporciona la misma funcionalidad.
**Sintaxis**
```sql theme={null}
arrayElement(arr, n)
```
**Argumentos**
* `arr` — El array en el que se busca. [`Array(T)`](/es/reference/data-types/array). - `n` — Posición del elemento que se quiere obtener. [`(U)Int*`](/es/reference/data-types/int-uint).
**Valor devuelto**
Devuelve un único array combinado a partir de los argumentos de tipo array proporcionados [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT arrayElement(arr, 2) FROM (SELECT [1, 2, 3] AS arr)
```
```response title=Response theme={null}
2
```
**Indexación negativa**
```sql title=Query theme={null}
SELECT arrayElement(arr, -1) FROM (SELECT [1, 2, 3] AS arr)
```
```response title=Response theme={null}
3
```
**Uso de la notación \[n]**
```sql title=Query theme={null}
SELECT arr[2] FROM (SELECT [1, 2, 3] AS arr)
```
```response title=Response theme={null}
2
```
**Índice fuera de rango del array**
```sql title=Query theme={null}
SELECT arrayElement(arr, 4) FROM (SELECT [1, 2, 3] AS arr)
```
```response title=Response theme={null}
0
```
## arrayElementOrNull
Introducido en: v1.1.0
Obtiene el elemento del array proporcionado en el índice `n`, donde `n` puede ser de cualquier tipo entero.
Si el índice queda fuera de los límites del array, se devuelve `NULL` en lugar de un valor predeterminado.
Los arrays de ClickHouse están indexados desde 1.
Se admiten índices negativos. En este caso, se selecciona el elemento correspondiente contando desde el final. Por ejemplo, `arr[-1]` es el último elemento del array.
**Sintaxis**
```sql theme={null}
arrayElementOrNull(arrays)
```
**Argumentos**
* `arrays` — Número arbitrario de argumentos de tipo array. [`Array`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve un único array que combina los argumentos de tipo array proporcionados. [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT arrayElementOrNull(arr, 2) FROM (SELECT [1, 2, 3] AS arr)
```
```response title=Response theme={null}
2
```
**Índices negativos**
```sql title=Query theme={null}
SELECT arrayElementOrNull(arr, -1) FROM (SELECT [1, 2, 3] AS arr)
```
```response title=Response theme={null}
3
```
**Índice fuera de rango del array**
```sql title=Query theme={null}
SELECT arrayElementOrNull(arr, 4) FROM (SELECT [1, 2, 3] AS arr)
```
```response title=Response theme={null}
NULL
```
## arrayEnumerate
Introducido en: v1.1.0
Devuelve el array `[1, 2, 3, ..., length (arr)]`
Esta función se usa normalmente con la cláusula [`ARRAY JOIN`](/es/reference/statements/select/array-join). Permite contar algo solo
una vez por cada array después de aplicar `ARRAY JOIN`.
Esta función también puede usarse en funciones de orden superior. Por ejemplo, puede usarla para obtener los índices del array de los elementos que cumplen una condición.
**Sintaxis**
```sql theme={null}
arrayEnumerate(arr)
```
**Argumentos**
* `arr` — El Array que se va a enumerar. [`Array`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve el Array `[1, 2, 3, ..., length (arr)]`. [`Array(UInt32)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo básico con ARRAY JOIN**
```sql title=Query theme={null}
CREATE TABLE test
(
`id` UInt8,
`tag` Array(String),
`version` Array(String)
)
ENGINE = MergeTree
ORDER BY id;
INSERT INTO test VALUES (1, ['release-stable', 'dev', 'security'], ['2.4.0', '2.6.0-alpha', '2.4.0-sec1']);
SELECT
id,
tag,
version,
seq
FROM test
ARRAY JOIN
tag,
version,
arrayEnumerate(tag) AS seq
```
```response title=Response theme={null}
┌─id─┬─tag────────────┬─version─────┬─seq─┐
│ 1 │ release-stable │ 2.4.0 │ 1 │
│ 1 │ dev │ 2.6.0-alpha │ 2 │
│ 1 │ security │ 2.4.0-sec1 │ 3 │
└────┴────────────────┴─────────────┴─────┘
```
## arrayEnumerateDense
Introducido en: v18.12.0
Devuelve un array del mismo tamaño que el array de origen, e indica la posición de la primera aparición de cada elemento en el array de origen.
**Sintaxis**
```sql theme={null}
arrayEnumerateDense(arr)
```
**Argumentos**
* `arr` — El array que se va a enumerar. [`Array(T)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve un array del mismo tamaño que `arr`, que indica en qué posición aparece por primera vez cada elemento en el array de origen [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT arrayEnumerateDense([10, 20, 10, 30])
```
```response title=Response theme={null}
[1,2,1,3]
```
## arrayEnumerateDenseRanked
Introducido en: v20.1.0
Devuelve un array del mismo tamaño que el array de origen e indica la posición en la que aparece por primera vez cada elemento en el array de origen. Permite enumerar un array multidimensional y especificar hasta qué profundidad examinar dentro del array.
**Sintaxis**
```sql theme={null}
arrayEnumerateDenseRanked(clear_depth, arr, max_array_depth)
```
**Argumentos**
* `clear_depth` — Enumera los elementos por separado en el nivel especificado. Debe ser menor o igual que `max_arr_depth`. [`UInt*`](/es/reference/data-types/int-uint)
* `arr` — Array de N dimensiones que se va a enumerar. [`Array(T)`](/es/reference/data-types/array)
* `max_array_depth` — La profundidad efectiva máxima. Debe ser menor o igual que la profundidad de `arr`. [`UInt*`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve un array que indica dónde aparece por primera vez cada elemento en el array de origen [`Array`](/es/reference/data-types/array)
**Ejemplos**
**Uso básico**
```sql title=Query theme={null}
-- Con clear_depth=1 y max_array_depth=1, el resultado es idéntico al que daría arrayEnumerateDense.
SELECT arrayEnumerateDenseRanked(1,[10, 20, 10, 30],1);
```
```response title=Response theme={null}
[1,2,1,3]
```
**Uso con un array multidimensional**
```sql title=Query theme={null}
-- En este ejemplo, arrayEnumerateDenseRanked se utiliza para obtener un array que indica, para cada elemento del
-- array multidimensional, cuál es su posición entre los elementos del mismo valor.
-- Para la primera fila del array pasado, [10, 10, 30, 20], la primera fila correspondiente del resultado es [1, 1, 2, 3],
-- lo que indica que 10 es el primer número encontrado en las posiciones 1 y 2, 30 el segundo número encontrado en la posición 3
-- y 20 es el tercer número encontrado en la posición 4.
-- Para la segunda fila, [40, 50, 10, 30], la segunda fila correspondiente del resultado es [4,5,1,2], lo que indica que 40
-- y 50 son el cuarto y quinto números encontrados en las posiciones 1 y 2 de esa fila, que otro 10
-- (el primer número encontrado) está en la posición 3 y 30 (el segundo número encontrado) está en la última posición.
SELECT arrayEnumerateDenseRanked(1,[[10,10,30,20],[40,50,10,30]],2);
```
```response title=Response theme={null}
[[1,1,2,3],[4,5,1,2]]
```
**Ejemplo con un clear\_depth mayor**
```sql title=Query theme={null}
-- Cambiar clear_depth=2 hace que la enumeración se reinicie por separado para cada fila.
SELECT arrayEnumerateDenseRanked(2,[[10,10,30,20],[40,50,10,30]],2);
```
```response title=Response theme={null}
[[1, 1, 2, 3], [1, 2, 3, 4]]
```
## arrayEnumerateUniq
Introducido en: v1.1.0
Devuelve un array del mismo tamaño que el array de origen e indica, para cada elemento, qué posición ocupa entre los elementos con el mismo valor.
Esta función es útil al usar `ARRAY JOIN` y la agregación de elementos de array.
La función puede tomar varios arrays del mismo tamaño como argumentos. En este caso, la unicidad se considera para las tuplas de elementos situados en las mismas posiciones en todos los arrays.
**Sintaxis**
```sql theme={null}
arrayEnumerateUniq(arr1[, arr2, ... , arrN])
```
**Argumentos**
* `arr1` — Primer array que se va a procesar. [`Array(T)`](/es/reference/data-types/array)
* `arr2, ...` — Opcional. Arrays adicionales del mismo tamaño para la unicidad de las tuplas. [`Array(UInt32)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve un array en el que cada elemento es la posición entre los elementos que tienen el mismo valor o la misma tupla. [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Uso básico**
```sql title=Query theme={null}
SELECT arrayEnumerateUniq([10, 20, 10, 30]);
```
```response title=Response theme={null}
[1, 1, 2, 1]
```
**Varios arrays**
```sql title=Query theme={null}
SELECT arrayEnumerateUniq([1, 1, 1, 2, 2, 2], [1, 1, 2, 1, 1, 2]);
```
```response title=Response theme={null}
[1,2,1,1,2,1]
```
**Agregación con ARRAY JOIN**
```sql title=Query theme={null}
-- Cada ID de objetivo tiene un cálculo del número de conversiones (cada elemento en la estructura de datos anidada Goals es un objetivo alcanzado, al que nos referimos como conversión)
-- y el número de sesiones. Sin ARRAY JOIN, habríamos contado el número de sesiones como sum(Sign). Pero en este caso particular,
-- las filas se multiplicaron por la estructura anidada Goals, por lo que para contar cada sesión una sola vez, aplicamos una condición al
-- valor de la función arrayEnumerateUniq(Goals.ID).
SELECT
Goals.ID AS GoalID,
sum(Sign) AS Reaches,
sumIf(Sign, num = 1) AS Visits
FROM test.visits
ARRAY JOIN
Goals,
arrayEnumerateUniq(Goals.ID) AS num
WHERE CounterID = 160656
GROUP BY GoalID
ORDER BY Reaches DESC
LIMIT 10
```
```response title=Response theme={null}
┌──GoalID─┬─Reaches─┬─Visits─┐
│ 53225 │ 3214 │ 1097 │
│ 2825062 │ 3188 │ 1097 │
│ 56600 │ 2803 │ 488 │
│ 1989037 │ 2401 │ 365 │
│ 2830064 │ 2396 │ 910 │
│ 1113562 │ 2372 │ 373 │
│ 3270895 │ 2262 │ 812 │
│ 1084657 │ 2262 │ 345 │
│ 56599 │ 2260 │ 799 │
│ 3271094 │ 2256 │ 812 │
└─────────┴─────────┴────────┘
```
## arrayEnumerateUniqRanked
Introducido en: v20.1.0
Devuelve un Array (o un Array multidimensional) con las mismas dimensiones que el Array de origen,
e indica para cada elemento qué posición ocupa entre los elementos con el mismo valor.
Permite enumerar un Array multidimensional y especificar hasta qué profundidad buscar dentro del Array.
**Sintaxis**
```sql theme={null}
arrayEnumerateUniqRanked(clear_depth, arr, max_array_depth)
```
**Argumentos**
* `clear_depth` — Enumera los elementos por separado en el nivel especificado. Entero positivo menor o igual que `max_arr_depth`. [`UInt*`](/es/reference/data-types/int-uint)
* `arr` — Array de N dimensiones que se va a enumerar. [`Array(T)`](/es/reference/data-types/array)
* `max_array_depth` — La profundidad efectiva máxima. Entero positivo menor o igual que la profundidad de `arr`. [`UInt*`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve un array de N dimensiones del mismo tamaño que `arr`, en el que cada elemento indica la posición de ese elemento con respecto a otros elementos del mismo valor. [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo 1**
```sql title=Query theme={null}
-- Con clear_depth=1 y max_array_depth=1, el resultado de arrayEnumerateUniqRanked
-- es idéntico al que daría arrayEnumerateUniq para el mismo array.
SELECT arrayEnumerateUniqRanked(1, [1, 2, 1], 1);
```
```response title=Response theme={null}
[1, 1, 2]
```
**Ejemplo 2**
```sql title=Query theme={null}
-- con clear_depth=1 y max_array_depth=1, el resultado de arrayEnumerateUniqRanked
-- es idéntico al que daría arrayEnumerateUniq para el mismo array.
SELECT arrayEnumerateUniqRanked(1, [[1, 2, 3], [2, 2, 1], [3]], 2);", "[[1, 1, 1], [2, 3, 2], [2]]
```
```response title=Response theme={null}
[1, 1, 2]
```
**Ejemplo 3**
```sql title=Query theme={null}
-- En este ejemplo, arrayEnumerateUniqRanked se usa para obtener un array que indica,
-- para cada elemento del array multidimensional, cuál es su posición entre los elementos
-- con el mismo valor. Para la primera fila del array proporcionado, [1, 2, 3], el resultado
-- correspondiente es [1, 1, 1], lo que indica que es la primera vez que aparecen 1, 2 y 3.
-- Para la segunda fila del array proporcionado, [2, 2, 1], el resultado correspondiente es [2, 3, 3],
-- lo que indica que 2 aparece por segunda y tercera vez, y 1 aparece
-- por segunda vez. Del mismo modo, para la tercera fila del array proporcionado [3], el
-- resultado correspondiente es [2], lo que indica que 3 aparece por segunda vez.
SELECT arrayEnumerateUniqRanked(1, [[1, 2, 3], [2, 2, 1], [3]], 2);
```
```response title=Response theme={null}
[[1, 1, 1], [2, 3, 2], [2]]
```
**Ejemplo 4**
```sql title=Query theme={null}
-- Al cambiar clear_depth=2, los elementos se enumeran por separado para cada fila.
SELECT arrayEnumerateUniqRanked(2,[[1, 2, 3],[2, 2, 1],[3]], 2);
```
```response title=Response theme={null}
[[1, 1, 1], [1, 2, 1], [1]]
```
## arrayExcept
Introducida en: v25.9.0
Devuelve un array que contiene los elementos de `source` que no están presentes en `except`, conservando el orden original.
Esta función realiza una operación de diferencia de conjuntos entre dos arrays. Para cada elemento de `source`, comprueba si existe en `except` (mediante una comparación exacta). Si no es así, el elemento se incluye en el resultado.
La operación mantiene estas propiedades:
1. Se conserva el orden de los elementos de `source`
2. Los duplicados de `source` se conservan si no existen en `except`
3. NULL se trata como un valor independiente
**Sintaxis**
```sql theme={null}
arrayExcept(source, except)
```
**Argumentos**
* `source` — El array de origen que contiene los elementos que se van a filtrar. [`Array(T)`](/es/reference/data-types/array)
* `except` — El array que contiene los elementos que se excluirán del resultado. [`Array(T)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve un array del mismo tipo que el array de entrada, con los elementos de `source` que no se encontraron en `except`. [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**básico**
```sql title=Query theme={null}
SELECT arrayExcept([1, 2, 3, 2, 4], [3, 5])
```
```response title=Response theme={null}
[1, 2, 2, 4]
```
**with\_nulls1**
```sql title=Query theme={null}
SELECT arrayExcept([1, NULL, 2, NULL], [2])
```
```response title=Response theme={null}
[1, NULL, NULL]
```
**with\_nulls2**
```sql title=Query theme={null}
SELECT arrayExcept([1, NULL, 2, NULL], [NULL, 2, NULL])
```
```response title=Response theme={null}
[1]
```
**cadenas**
```sql title=Query theme={null}
SELECT arrayExcept(['apple', 'banana', 'cherry'], ['banana', 'date'])
```
```response title=Response theme={null}
['apple', 'cherry']
```
## arrayExists
Introducido en: v1.1.0
Devuelve `1` si hay al menos un elemento en el array de origen para el que `func(x[, y1, y2, ... yN])` devuelve `true`. En caso contrario, devuelve `0`.
**Sintaxis**
```sql theme={null}
arrayExists(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])
```
**Argumentos**
* `func(x[, y1, ..., yN])` — Una función lambda que opera sobre los elementos del array de origen (`x`) y los arrays de condición (`y`). [`Función lambda`](/es/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — El array de origen que se va a procesar. [`Array(T)`](/es/reference/data-types/array)
* `[, cond1_arr, ... , condN_arr]` — Opcional. N arrays de condición que proporcionan argumentos adicionales a la función lambda. [`Array(T)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve `1` si la función lambda devuelve `true` para al menos un elemento; en caso contrario, `0`. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT arrayExists(x, y -> x=y, [1, 2, 3], [0, 0, 0])
```
```response title=Response theme={null}
0
```
## arrayFill
Introducido en: v20.1.0
La función `arrayFill` procesa secuencialmente un array de origen desde el primer elemento
hasta el último, evaluando una condición lambda en cada posición mediante elementos del
array de origen y de los arrays de condición. Cuando la función lambda da como resultado false en la
posición i, la función sustituye ese elemento por el elemento de la posición i-1
del estado actual del array. El primer elemento siempre se conserva,
independientemente de cualquier condición.
**Sintaxis**
```sql theme={null}
arrayFill(func(x [, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])
```
**Argumentos**
* `func(x [, y1, ..., yN])` — Una función lambda `func(x [, y1, y2, ... yN]) → F(x [, y1, y2, ... yN])` que opera sobre los elementos del array de origen (`x`) y los arrays de condición (`y`). [`función lambda`](/es/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — El array de origen que se va a procesar. [`función lambda`](/es/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `[, cond1_arr, ... , condN_arr]` — Opcional. N arrays de condición que proporcionan argumentos adicionales a la función lambda. [`Array(T)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve un array [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo con un solo array**
```sql title=Query theme={null}
SELECT arrayFill(x -> not isNull(x), [1, null, 2, null]) AS res
```
```response title=Response theme={null}
[1, 1, 2, 2]
```
**Ejemplo con dos arrays**
```sql title=Query theme={null}
SELECT arrayFill(x, y, z -> x > y AND x < z, [5, 3, 6, 2], [4, 7, 1, 3], [10, 2, 8, 5]) AS res
```
```response title=Response theme={null}
[5, 5, 6, 6]
```
## arrayFilter
Introducido en: v1.1.0
Devuelve un array que contiene solo los elementos del array de origen para los que una función lambda devuelve true.
**Sintaxis**
```sql theme={null}
arrayFilter(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])]
```
**Argumentos**
* `func(x[, y1, ..., yN])` — Una función lambda que opera sobre los elementos del array de origen (`x`) y los arrays de condición (`y`). [`Función lambda`](/es/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — El array de origen que se va a procesar. [`Array(T)`](/es/reference/data-types/array)
* `[, cond1_arr, ... , condN_arr]` — Opcional. N arrays de condición que proporcionan argumentos adicionales a la función lambda. [`Array(T)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve un subconjunto del array de origen [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo 1**
```sql title=Query theme={null}
SELECT arrayFilter(x -> x LIKE '%World%', ['Hello', 'abc World']) AS res
```
```response title=Response theme={null}
['abc World']
```
**Ejemplo 2**
```sql title=Query theme={null}
SELECT
arrayFilter(
(i, x) -> x LIKE '%World%',
arrayEnumerate(arr),
['Hello', 'abc World'] AS arr)
AS res
```
```response title=Response theme={null}
[2]
```
## arrayFirst
Introducido en: v1.1.0
Devuelve el primer elemento del array de origen para el que `func(x[, y1, y2, ... yN])` devuelve true; en caso contrario, devuelve un valor por defecto.
**Sintaxis**
```sql theme={null}
arrayFirst(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])
```
**Argumentos**
* `func(x[, y1, ..., yN])` — Una función lambda que opera sobre los elementos del array de origen (`x`) y de los arrays de condición (`y`). [Función lambda](/es/reference/functions/regular-functions/overview#arrow-operator-and-lambda). - `source_arr` — El array de origen que se va a procesar. [`Array(T)`](/es/reference/data-types/array). - `[, cond1_arr, ... , condN_arr]` — Opcional. N arrays de condición que proporcionan argumentos adicionales para la función lambda. [`Array(T)`](/es/reference/data-types/array).
**Valor devuelto**
Devuelve el primer elemento del array de origen para el que `λ` es `true`; de lo contrario, devuelve el valor predeterminado de `T`.
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT arrayFirst(x, y -> x=y, ['a', 'b', 'c'], ['c', 'b', 'a'])
```
```response title=Response theme={null}
b
```
**No hay coincidencias**
```sql title=Query theme={null}
SELECT arrayFirst(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)
```
```response title=Response theme={null}
0 UInt8
```
## arrayFirstIndex
Introducido en: v1.1.0
Devuelve el índice del primer elemento del array de origen para el que `func(x[, y1, y2, ... yN])` devuelve `true`; de lo contrario, devuelve '0'.
**Sintaxis**
```sql theme={null}
arrayFirstIndex(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])
```
**Argumentos**
* `func(x[, y1, ..., yN])` — Una función lambda que opera sobre los elementos del array de origen (`x`) y de los arrays de condición (`y`). [Función lambda](/es/reference/functions/regular-functions/overview#arrow-operator-and-lambda). - `source_arr` — El array de origen que se va a procesar. [`Array(T)`](/es/reference/data-types/array). - `[, cond1_arr, ... , condN_arr]` — Opcional. N arrays de condición que proporcionan argumentos adicionales a la función lambda. [`Array(T)`](/es/reference/data-types/array).
**Valor devuelto**
Devuelve el índice del primer elemento del array de origen para el que `func` es true; en caso contrario, devuelve `0` [`UInt32`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT arrayFirstIndex(x, y -> x=y, ['a', 'b', 'c'], ['c', 'b', 'a'])
```
```response title=Response theme={null}
2
```
**Sin coincidencia**
```sql title=Query theme={null}
SELECT arrayFirstIndex(x, y -> x=y, ['a', 'b', 'c'], ['d', 'e', 'f'])
```
```response title=Response theme={null}
0
```
## arrayFirstOrNull
Introducido en: v1.1.0
Devuelve el primer elemento del array de origen para el que `func(x[, y1, y2, ... yN])` devuelve `true`; de lo contrario, devuelve `NULL`.
**Sintaxis**
```sql theme={null}
arrayFirstOrNull(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])
```
**Argumentos**
* `func(x[, y1, ..., yN])` — Una función lambda que opera sobre los elementos del array de origen (`x`) y los arrays de condición (`y`). [`Función lambda`](/es/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — El array de origen que se va a procesar. [`Array(T)`](/es/reference/data-types/array)
* `[, cond1_arr, ... , condN_arr]` — Opcional. N arrays de condición que proporcionan argumentos adicionales a la función lambda. [`Array(T)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve el primer elemento del array de origen para el que `func` es `true`; de lo contrario, devuelve `NULL`.
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT arrayFirstOrNull(x, y -> x=y, ['a', 'b', 'c'], ['c', 'b', 'a'])
```
```response title=Response theme={null}
b
```
**Sin coincidencias**
```sql title=Query theme={null}
SELECT arrayFirstOrNull(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)
```
```response title=Response theme={null}
NULL Nullable(UInt8)
```
## arrayFlatten
Introducido en: v20.1.0
Convierte un array de arrays en un array plano.
Función:
* Se aplica a cualquier nivel de anidamiento de arrays.
* No modifica los arrays que ya son planos.
El array aplanado contiene todos los elementos de todos los arrays de origen.
**Sintaxis**
```sql theme={null}
arrayFlatten(arr)
```
**Alias**: `flatten`
**Argumentos**
* `arr` — Un array multidimensional. [`Array(Array(T))`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve un array aplanado a partir del array multidimensional [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT arrayFlatten([[[1]], [[2], [3]]]);
```
```response title=Response theme={null}
[1, 2, 3]
```
## arrayFold
Introducido en: v23.10.0
Aplica una función lambda a uno o varios arrays del mismo tamaño y acumula el resultado en un acumulador.
**Sintaxis**
```sql theme={null}
arrayFold(λ(acc, x1 [, x2, x3, ... xN]), arr1 [, arr2, arr3, ... arrN], acc)
```
**Argumentos**
* `λ(x, x1 [, x2, x3, ... xN])` — Una función lambda `λ(acc, x1 [, x2, x3, ... xN]) → F(acc, x1 [, x2, x3, ... xN])`, donde `F` es una operación aplicada a `acc` y a los valores del array `x`, reutilizando el resultado de `acc`. [`Función lambda`](/es/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `arr1 [, arr2, arr3, ... arrN]` — N arrays sobre los que se opera. [`Array(T)`](/es/reference/data-types/array)
* `acc` — Valor acumulador con el mismo tipo que el tipo de retorno de la función lambda.
**Valor devuelto**
Devuelve el valor final de `acc`.
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT arrayFold(acc,x -> acc + x*2, [1, 2, 3, 4], 3::Int64) AS res;
```
```response title=Response theme={null}
23
```
**Sucesión de Fibonacci**
```sql title=Query theme={null}
SELECT arrayFold(acc, x -> (acc.2, acc.2 + acc.1),range(number),(1::Int64, 0::Int64)).1 AS fibonacci FROM numbers(1,10);
```
```response title=Response theme={null}
┌─fibonacci─┐
│ 0 │
│ 1 │
│ 1 │
│ 2 │
│ 3 │
│ 5 │
│ 8 │
│ 13 │
│ 21 │
│ 34 │
└───────────┘
```
**Ejemplo con varios arrays**
```sql title=Query theme={null}
SELECT arrayFold(
(acc, x, y) -> acc + (x * y),
[1, 2, 3, 4],
[10, 20, 30, 40],
0::Int64
) AS res;
```
```response title=Response theme={null}
300
```
## arrayIntersect
Introducido en: v1.1.0
Acepta varios arrays y devuelve un array con los elementos presentes en todos los arrays de origen. El resultado contiene solo valores únicos.
**Sintaxis**
```sql theme={null}
arrayIntersect(arr, arr1, ..., arrN)
```
**Argumentos**
* `arrN` — N arrays con los que crear el nuevo array. [`Array(T)`](/es/reference/data-types/array).
**Valor devuelto**
Devuelve un array con elementos distintos presentes en los N arrays [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT
arrayIntersect([1, 2], [1, 3], [2, 3]) AS empty_intersection,
arrayIntersect([1, 2], [1, 3], [1, 4]) AS non_empty_intersection
```
```response title=Response theme={null}
┌─empty_intersection─┬─non_empty_intersection─┐
│ [] │ [1] │
└────────────────────┴────────────────────────┘
```
## arrayJaccardIndex
Introducido en: v23.7.0
Devuelve el [índice de Jaccard](https://en.wikipedia.org/wiki/Jaccard_index) de dos arrays.
**Sintaxis**
```sql theme={null}
arrayJaccardIndex(arr_x, arr_y)
```
**Argumentos**
* `arr_x` — Primer array. [`Array(T)`](/es/reference/data-types/array)
* `arr_y` — Segundo array. [`Array(T)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve el índice de Jaccard entre `arr_x` y `arr_y` [`Float64`](/es/reference/data-types/float)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT arrayJaccardIndex([1, 2], [2, 3]) AS res
```
```response title=Response theme={null}
0.3333333333333333
```
## arrayJoin
Introducido en: v1.1.0
La función `arrayJoin` toma una fila que contiene un array y lo expande, generando múltiples filas: una por cada elemento del array.
Esto contrasta con las funciones regulares de ClickHouse, que asignan valores de entrada a valores de salida dentro de la misma fila,
y con las funciones de agregación, que toman un grupo de filas y las "comprimen" o "reducen" a una sola fila de resumen
(o a un único valor dentro de una fila de resumen si se usa con `GROUP BY`).
Todos los valores de las columnas se copian sin más, excepto los valores de la columna a la que se aplica esta función;
estos se sustituyen por el valor correspondiente del array.
**Sintaxis**
```sql theme={null}
arrayJoin(arr)
```
**Alias**: `unnest`
**Argumentos**
* `arr` — Un array para expandir. [`Array(T)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve un conjunto de filas obtenidas al expandir `arr`.
**Ejemplos**
**Uso básico**
```sql title=Query theme={null}
SELECT arrayJoin([1, 2, 3] AS src) AS dst, 'Hello', src
```
```response title=Response theme={null}
┌─dst─┬─\'Hello\'─┬─src─────┐
│ 1 │ Hello │ [1,2,3] │
│ 2 │ Hello │ [1,2,3] │
│ 3 │ Hello │ [1,2,3] │
└─────┴───────────┴─────────┘
```
**arrayJoin afecta a todas las partes de la consulta**
```sql title=Query theme={null}
-- La función arrayJoin afecta todas las secciones de la consulta, incluida la sección WHERE. Observe el resultado 2, aunque la subconsulta devolvió 1 fila.
SELECT sum(1) AS impressions
FROM
(
SELECT ['Istanbul', 'Berlin', 'Bobruisk'] AS cities
)
WHERE arrayJoin(cities) IN ['Istanbul', 'Berlin'];
```
```response title=Response theme={null}
┌─impressions─┐
│ 2 │
└─────────────┘
```
**Uso de varias funciones arrayJoin**
```sql title=Query theme={null}
- Una consulta puede usar múltiples funciones arrayJoin. En este caso, la transformación se realiza varias veces y las filas se multiplican.
SELECT
sum(1) AS impressions,
arrayJoin(cities) AS city,
arrayJoin(browsers) AS browser
FROM
(
SELECT
['Istanbul', 'Berlin', 'Bobruisk'] AS cities,
['Firefox', 'Chrome', 'Chrome'] AS browsers
)
GROUP BY
2,
3
```
```response title=Response theme={null}
┌─impressions─┬─city─────┬─browser─┐
│ 2 │ Istanbul │ Chrome │
│ 1 │ Istanbul │ Firefox │
│ 2 │ Berlin │ Chrome │
│ 1 │ Berlin │ Firefox │
│ 2 │ Bobruisk │ Chrome │
│ 1 │ Bobruisk │ Firefox │
└─────────────┴──────────┴─────────┘
```
**Resultados inesperados por las optimizaciones**
```sql title=Query theme={null}
-- Usar múltiples arrayJoin con la misma expresión puede no producir el resultado esperado debido a optimizaciones.
-- En estos casos, considere modificar la expresión de array repetida con operaciones adicionales que no afecten el resultado del join.
- e.g. arrayJoin(arraySort(arr)), arrayJoin(arrayConcat(arr, []))
SELECT
arrayJoin(dice) as first_throw,
/* arrayJoin(dice) as second_throw */ -- es técnicamente correcto, pero eliminará el conjunto de resultados
arrayJoin(arrayConcat(dice, [])) as second_throw -- expresión modificada intencionalmente para forzar la re-evaluación
FROM (
SELECT [1, 2, 3, 4, 5, 6] as dice
);
```
```response title=Response theme={null}
┌─first_throw─┬─second_throw─┐
│ 1 │ 1 │
│ 1 │ 2 │
│ 1 │ 3 │
│ 1 │ 4 │
│ 1 │ 5 │
│ 1 │ 6 │
│ 2 │ 1 │
│ 2 │ 2 │
│ 2 │ 3 │
│ 2 │ 4 │
│ 2 │ 5 │
│ 2 │ 6 │
│ 3 │ 1 │
│ 3 │ 2 │
│ 3 │ 3 │
│ 3 │ 4 │
│ 3 │ 5 │
│ 3 │ 6 │
│ 4 │ 1 │
│ 4 │ 2 │
│ 4 │ 3 │
│ 4 │ 4 │
│ 4 │ 5 │
│ 4 │ 6 │
│ 5 │ 1 │
│ 5 │ 2 │
│ 5 │ 3 │
│ 5 │ 4 │
│ 5 │ 5 │
│ 5 │ 6 │
│ 6 │ 1 │
│ 6 │ 2 │
│ 6 │ 3 │
│ 6 │ 4 │
│ 6 │ 5 │
│ 6 │ 6 │
└─────────────┴──────────────┘
```
**Uso de la sintaxis de ARRAY JOIN**
```sql title=Query theme={null}
-- Nótese la sintaxis ARRAY JOIN en la consulta `SELECT` a continuación, que ofrece posibilidades más amplias.
-- ARRAY JOIN permite convertir múltiples arrays con el mismo número de elementos a la vez.
SELECT
sum(1) AS impressions,
city,
browser
FROM
(
SELECT
['Istanbul', 'Berlin', 'Bobruisk'] AS cities,
['Firefox', 'Chrome', 'Chrome'] AS browsers
)
ARRAY JOIN
cities AS city,
browsers AS browser
GROUP BY
2,
3
```
```response title=Response theme={null}
┌─impressions─┬─city─────┬─browser─┐
│ 1 │ Istanbul │ Firefox │
│ 1 │ Berlin │ Chrome │
│ 1 │ Bobruisk │ Chrome │
└─────────────┴──────────┴─────────┘
```
**Uso de Tuple**
```sql title=Query theme={null}
-- También puedes usar Tuple
SELECT
sum(1) AS impressions,
(arrayJoin(arrayZip(cities, browsers)) AS t).1 AS city,
t.2 AS browser
FROM
(
SELECT
['Istanbul', 'Berlin', 'Bobruisk'] AS cities,
['Firefox', 'Chrome', 'Chrome'] AS browsers
)
GROUP BY
2,
3
```
```response title=Response theme={null}
┌─impressions─┬─city─────┬─browser─┐
│ 1 │ Istanbul │ Firefox │
│ 1 │ Berlin │ Chrome │
│ 1 │ Bobruisk │ Chrome │
└─────────────┴──────────┴─────────┘
```
## arrayLast
Introducido en: v1.1.0
Devuelve el último elemento del array de origen para el que una lambda `func(x [, y1, y2, ... yN])` devuelve true; en caso contrario, devuelve un valor predeterminado.
**Sintaxis**
```sql theme={null}
arrayLast(func(x[, y1, ..., yN]), source[, cond1, ... , condN_arr])
```
**Argumentos**
* `func(x[, y1, ..., yN])` — Una función lambda que opera sobre los elementos del array de origen (`x`) y los arrays de condición (`y`). [Función lambda](/es/reference/functions/regular-functions/overview#arrow-operator-and-lambda). - `source` — El array de origen que se va a procesar. [`Array(T)`](/es/reference/data-types/array). - `[, cond1, ... , condN]` — Opcional. N arrays de condición que proporcionan argumentos adicionales a la función lambda. [`Array(T)`](/es/reference/data-types/array).
**Valor devuelto**
Devuelve el último elemento del array de origen para el que `func` es verdadero; de lo contrario, devuelve el valor predeterminado de `T`.
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT arrayLast(x, y -> x=y, ['a', 'b', 'c'], ['a', 'b', 'c'])
```
```response title=Response theme={null}
c
```
**No hay coincidencias**
```sql title=Query theme={null}
SELECT arrayFirst(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)
```
```response title=Response theme={null}
0 UInt8
```
## arrayLastIndex
Introducido en: v1.1.0
Devuelve el índice del último elemento del array de origen para el que `func(x[, y1, y2, ... yN])` devuelve true; en caso contrario, devuelve '0'.
**Sintaxis**
```sql theme={null}
arrayLastIndex(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])
```
**Argumentos**
* `func(x[, y1, ..., yN])` — Una función lambda que opera sobre los elementos del array de origen (`x`) y de los arreglos de condición (`y`). [`Función lambda`](/es/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — El array de origen que se va a procesar. [`Array(T)`](/es/reference/data-types/array)
* `[, cond1_arr, ... , condN_arr]` — Opcional. N arreglos de condición que proporcionan argumentos adicionales a la función lambda. [`Array(T)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve el índice del último elemento del array de origen para el que `func` devuelve `true`; de lo contrario, devuelve `0` [`UInt32`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT arrayLastIndex(x, y -> x=y, ['a', 'b', 'c'], ['a', 'b', 'c']);
```
```response title=Response theme={null}
3
```
**No hay coincidencias**
```sql title=Query theme={null}
SELECT arrayLastIndex(x, y -> x=y, ['a', 'b', 'c'], ['d', 'e', 'f']);
```
```response title=Response theme={null}
0
```
## arrayLastOrNull
Introducido en: v1.1.0
Devuelve el último elemento del array de origen para el que una función lambda `func(x [, y1, y2, ... yN])` devuelve true; de lo contrario, devuelve `NULL`.
**Sintaxis**
```sql theme={null}
arrayLastOrNull(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])
```
**Argumentos**
* `func(x [, y1, ..., yN])` — Una función lambda que opera sobre los elementos del array de origen (`x`) y de los arrays de condición (`y`). [Función lambda](/es/reference/functions/regular-functions/overview#arrow-operator-and-lambda). - `source_arr` — El array de origen que se va a procesar. [`Array(T)`](/es/reference/data-types/array). - `[, cond1_arr, ... , condN_arr]` — Opcional. N arrays de condición que proporcionan argumentos adicionales a la función lambda. [`Array(T)`](/es/reference/data-types/array).
**Valor devuelto**
Devuelve el último elemento del array de origen para el que `λ` no es `true`; en caso contrario, devuelve `NULL`.
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT arrayLastOrNull(x, y -> x=y, ['a', 'b', 'c'], ['a', 'b', 'c'])
```
```response title=Response theme={null}
c
```
**Sin coincidencias**
```sql title=Query theme={null}
SELECT arrayLastOrNull(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)
```
```response title=Response theme={null}
NULL Nullable(UInt8)
```
## arrayLevenshteinDistance
Introducido en: v25.4.0
Calcula la distancia de Levenshtein entre dos arrays.
**Sintaxis**
```sql theme={null}
arrayLevenshteinDistance(from, to)
```
**Argumentos**
* `from` — El primer array. [`Array(T)`](/es/reference/data-types/array). - `to` — El segundo array. [`Array(T)`](/es/reference/data-types/array).
**Valor devuelto**
Distancia de Levenshtein entre el primer y el segundo array. [`Float64`](/es/reference/data-types/float)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT arrayLevenshteinDistance([1, 2, 4], [1, 2, 3])
```
```response title=Response theme={null}
1
```
## arrayLevenshteinDistanceWeighted
Introducido en: v25.4.0
Calcula la distancia de Levenshtein entre dos arrays con pesos personalizados para cada elemento.
El número de elementos del array y el de sus pesos deben coincidir.
**Sintaxis**
```sql theme={null}
arrayLevenshteinDistanceWeighted(from, to, from_weights, to_weights)
```
**Argumentos**
* `from` — primer array. [`Array(T)`](/es/reference/data-types/array). - `to` — segundo array. [`Array(T)`](/es/reference/data-types/array). - `from_weights` — pesos del primer array. [`Array((U)Int*|Float*)`](/es/reference/data-types/array)
* `to_weights` — pesos del segundo array. [`Array((U)Int*|Float*)`](/es/reference/data-types/array)
**Valor devuelto**
Distancia de Levenshtein entre el primer y el segundo array con pesos personalizados para cada elemento [`Float64`](/es/reference/data-types/float)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT arrayLevenshteinDistanceWeighted(['A', 'B', 'C'], ['A', 'K', 'L'], [1.0, 2, 3], [3.0, 4, 5])
```
```response title=Response theme={null}
14
```
## arrayMap
Introducido en: v1.1.0
Devuelve un array que se obtiene de los arrays originales aplicando una función lambda a cada elemento.
**Sintaxis**
```sql theme={null}
arrayMap(func, arr)
```
**Argumentos**
* `func` — Una función lambda que opera sobre los elementos del array de entrada (`x`) y los arrays de condición (`y`). [`Función lambda`](/es/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `arr` — N arrays para procesar. [`Array(T)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve un array a partir de los resultados de la función lambda [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT arrayMap(x -> (x + 2), [1, 2, 3]) as res;
```
```response title=Response theme={null}
[3, 4, 5]
```
**Crear una tupla de elementos de diferentes arrays**
```sql title=Query theme={null}
SELECT arrayMap((x, y) -> (x, y), [1, 2, 3], [4, 5, 6]) AS res
```
```response title=Response theme={null}
[(1, 4),(2, 5),(3, 6)]
```
## arrayMax
Introducido en: v21.1.0
Devuelve el elemento máximo del array de origen.
Si se especifica una `función lambda` `func`, devuelve el elemento máximo de los resultados de la lambda.
**Sintaxis**
```sql theme={null}
arrayMax([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])
```
**Argumentos**
* `func(x[, y1, ..., yN])` — Opcional. Una función lambda que opera sobre los elementos del array de origen (`x`) y de los arrays de condición (`y`). [`Función lambda`](/es/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — El array de origen que se va a procesar. [`Array(T)`](/es/reference/data-types/array)
* `[, cond1_arr, ... , condN_arr]` — Opcional. N arrays de condición que proporcionan argumentos adicionales a la función lambda. [`Array(T)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve el elemento máximo del array de origen o, si se proporciona una lambda, el valor máximo de sus resultados.
**Ejemplos**
**Ejemplo básico**
```sql title=Query theme={null}
SELECT arrayMax([5, 3, 2, 7]);
```
```response title=Response theme={null}
7
```
**Uso con una función lambda**
```sql title=Query theme={null}
SELECT arrayMax(x, y -> x/y, [4, 8, 12, 16], [1, 2, 1, 2]);
```
```response title=Response theme={null}
12
```
## arrayMin
Introducido en: v21.1.0
Devuelve el elemento mínimo del array de origen.
Si se especifica una función lambda `func`, devuelve el elemento mínimo de los resultados de la función lambda.
**Sintaxis**
```sql theme={null}
arrayMin([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])
```
**Argumentos**
* `func(x[, y1, ..., yN])` — Opcional. Una función lambda que opera sobre los elementos del array de origen (`x`) y los arrays de condición (`y`). [`Función lambda`](/es/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — El array de origen que se va a procesar. [`Array(T)`](/es/reference/data-types/array)
* `cond1_arr, ...` — Opcional. N arrays de condición que proporcionan argumentos adicionales a la función lambda. [`Array(T)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve el elemento mínimo del array de origen o, si se proporciona, el elemento mínimo de los resultados de la lambda.
**Ejemplos**
**Ejemplo básico**
```sql title=Query theme={null}
SELECT arrayMin([5, 3, 2, 7]);
```
```response title=Response theme={null}
2
```
**Uso con una función lambda**
```sql title=Query theme={null}
SELECT arrayMin(x, y -> x/y, [4, 8, 12, 16], [1, 2, 1, 2]);
```
```response title=Response theme={null}
4
```
## arrayNormalizedGini
Introducido en: v25.1.0
Calcula el coeficiente de Gini normalizado.
**Sintaxis**
```sql theme={null}
arrayNormalizedGini(predicted, label)
```
**Argumentos**
* `predicted` — El valor predicho. [`Array(T)`](/es/reference/data-types/array)
* `label` — El valor real. [`Array(T)`](/es/reference/data-types/array)
**Valor devuelto**
Una tupla que contiene los coeficientes de Gini de los valores predichos, el coeficiente de Gini de los valores normalizados y el coeficiente de Gini normalizado (= el cociente entre los dos coeficientes de Gini anteriores) [`Tuple(Float64, Float64, Float64)`](/es/reference/data-types/tuple)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT arrayNormalizedGini([0.9, 0.3, 0.8, 0.7],[6, 1, 0, 2]);
```
```response title=Response theme={null}
(0.18055555555555558, 0.2638888888888889, 0.6842105263157896)
```
## arrayPartialReverseSort
Introducido en: v23.2.0
Esta función es igual que `arrayReverseSort`, pero con un argumento adicional, `limit`, que permite una ordenación parcial.
Para conservar solo los elementos ordenados, usa `arrayResize`.
**Sintaxis**
```sql theme={null}
arrayPartialReverseSort([f,] arr [, arr1, ... ,arrN], limit)
```
**Argumentos**
* `f(arr[, arr1, ... ,arrN])` — La función lambda que se aplica a los elementos del array `x`. [`Función lambda`](/es/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `arr` — Array que se va a ordenar. [`Array(T)`](/es/reference/data-types/array)
* `arr1, ... ,arrN` — N arrays adicionales, en caso de que `f` acepte varios argumentos. [`Array(T)`](/es/reference/data-types/array)
* `limit` — Valor de índice hasta el que se realizará la ordenación. [`(U)Int*`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve un array del mismo tamaño que el array original, en el que los elementos del rango `[1..limit]` se ordenan
en orden descendente. Los elementos restantes `(limit..N]` quedan en un orden no especificado.
**Ejemplos**
**simple\_int**
```sql title=Query theme={null}
SELECT arrayPartialReverseSort(2, [5, 9, 1, 3])
```
```response title=Response theme={null}
[9, 5, 1, 3]
```
**simple\_string**
```sql title=Query theme={null}
SELECT arrayPartialReverseSort(2, ['expenses','lasso','embolism','gladly'])
```
```response title=Response theme={null}
['lasso','gladly','expenses','embolism']
```
**retain\_sorted**
```sql title=Query theme={null}
SELECT arrayResize(arrayPartialReverseSort(2, [5, 9, 1, 3]), 2)
```
```response title=Response theme={null}
[9, 5]
```
**lambda\_simple**
```sql title=Query theme={null}
SELECT arrayPartialReverseSort((x) -> -x, 2, [5, 9, 1, 3])
```
```response title=Response theme={null}
[1, 3, 5, 9]
```
**lambda\_complex**
```sql title=Query theme={null}
SELECT arrayPartialReverseSort((x, y) -> -y, 1, [0, 1, 2], [1, 2, 3]) as res
```
```response title=Response theme={null}
[0, 1, 2]
```
## arrayPartialShuffle
Introducido en: v23.2.0
Devuelve un array del mismo tamaño que el array original, en el que los elementos del rango `[1..limit]` son un subconjunto aleatorio
del array original. El resto `(limit..n]` debe contener los elementos que no están en el rango `[1..limit]`, en un orden no definido.
El valor de `limit` debe estar en el rango `[1..n]`. Los valores fuera de ese rango equivalen a realizar un `arrayShuffle` completo:
Esta función no materializará constantes.
El valor de `limit` debe estar en el rango `[1..N]`. Los valores fuera de ese rango equivalen a realizar un [`arrayShuffle`](#arrayShuffle) completo.
**Sintaxis**
```sql theme={null}
arrayPartialShuffle(arr [, limit[, seed]])
```
**Argumentos**
* `arr` — El array que se va a barajar. [`Array(T)`](/es/reference/data-types/array)
* `seed` — Opcional. La semilla que se usará para la generación de números aleatorios. Si no se proporciona, se usa una aleatoria. [`(U)Int*`](/es/reference/data-types/int-uint)
* `limit` — Opcional. El número para limitar los intercambios de elementos, en el rango `[1..N]`. [`(U)Int*`](/es/reference/data-types/int-uint)
**Valor devuelto**
Array con elementos parcialmente barajados. [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**no\_limit1**
```sql title=Query theme={null}
SELECT arrayPartialShuffle([1, 2, 3, 4], 0)
```
```response title=Response theme={null}
[2, 4, 3, 1]
```
**no\_limit2**
```sql title=Query theme={null}
SELECT arrayPartialShuffle([1, 2, 3, 4])
```
```response title=Response theme={null}
[4, 1, 3, 2]
```
**random\_seed**
```sql title=Query theme={null}
SELECT arrayPartialShuffle([1, 2, 3, 4], 2)
```
```response title=Response theme={null}
[3, 4, 1, 2]
```
**explicit\_seed**
```sql title=Query theme={null}
SELECT arrayPartialShuffle([1, 2, 3, 4], 2, 41)
```
```response title=Response theme={null}
[3, 2, 1, 4]
```
**materializar**
```sql title=Query theme={null}
SELECT arrayPartialShuffle(materialize([1, 2, 3, 4]), 2, 42), arrayPartialShuffle([1, 2, 3], 2, 42) FROM numbers(10)
```
```response title=Response theme={null}
┌─arrayPartial⋯4]), 2, 42)─┬─arrayPartial⋯ 3], 2, 42)─┐
│ [3,2,1,4] │ [3,2,1] │
│ [3,2,1,4] │ [3,2,1] │
│ [4,3,2,1] │ [3,2,1] │
│ [1,4,3,2] │ [3,2,1] │
│ [3,4,1,2] │ [3,2,1] │
│ [1,2,3,4] │ [3,2,1] │
│ [1,4,3,2] │ [3,2,1] │
│ [1,4,3,2] │ [3,2,1] │
│ [3,1,2,4] │ [3,2,1] │
│ [1,3,2,4] │ [3,2,1] │
└──────────────────────────┴──────────────────────────┘
```
## arrayPartialSort
Introducido en: v23.2.0
Esta función es igual que `arraySort`, pero con un argumento adicional, `limit`, que permite realizar una ordenación parcial.
Para conservar solo los elementos ordenados, use `arrayResize`.
**Sintaxis**
```sql theme={null}
arrayPartialSort([f,] arr [, arr1, ... ,arrN], limit)
```
**Argumentos**
* `f(arr[, arr1, ... ,arrN])` — La función lambda que se aplica a los elementos del array `x`. [`Función lambda`](/es/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `arr` — Array que se va a ordenar. [`Array(T)`](/es/reference/data-types/array)
* `arr1, ... ,arrN` — N arrays adicionales, en caso de que `f` acepte varios argumentos. [`Array(T)`](/es/reference/data-types/array)
* `limit` — Valor de índice hasta el que se realizará la ordenación. [`(U)Int*`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve un array del mismo tamaño que el array original, en el que los elementos del intervalo `[1..limit]` se ordenan
de forma ascendente. Los elementos restantes `(limit..N]` quedan en un orden no especificado.
**Ejemplos**
**simple\_int**
```sql title=Query theme={null}
SELECT arrayPartialSort(2, [5, 9, 1, 3])
```
```response title=Response theme={null}
[1, 3, 5, 9]
```
**simple\_string**
```sql title=Query theme={null}
SELECT arrayPartialSort(2, ['expenses', 'lasso', 'embolism', 'gladly'])
```
```response title=Response theme={null}
['embolism', 'expenses', 'gladly', 'lasso']
```
**retain\_sorted**
```sql title=Query theme={null}
SELECT arrayResize(arrayPartialSort(2, [5, 9, 1, 3]), 2)
```
```response title=Response theme={null}
[1, 3]
```
**lambda\_simple**
```sql title=Query theme={null}
SELECT arrayPartialSort((x) -> -x, 2, [5, 9, 1, 3])
```
```response title=Response theme={null}
[9, 5, 1, 3]
```
**lambda\_complex**
```sql title=Query theme={null}
SELECT arrayPartialSort((x, y) -> -y, 1, [0, 1, 2], [1, 2, 3]) as res
```
```response title=Response theme={null}
[2, 1, 0]
```
## arrayPopBack
Introducido en: v1.1.0
Elimina el último elemento del array.
**Sintaxis**
```sql theme={null}
arrayPopBack(arr)
```
**Argumentos**
* `arr` — El array al que se le eliminará el último elemento. [`Array(T)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve un array idéntico a `arr`, pero sin su último elemento. [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT arrayPopBack([1, 2, 3]) AS res;
```
```response title=Response theme={null}
[1, 2]
```
## arrayPopFront
Introducido en: v1.1.0
Elimina el primer elemento del array.
**Sintaxis**
```sql theme={null}
arrayPopFront(arr)
```
**Argumentos**
* `arr` — El array del que se elimina el primer elemento. [`Array(T)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve un array idéntico a `arr`, pero sin el primer elemento de `arr` [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT arrayPopFront([1, 2, 3]) AS res;
```
```response title=Response theme={null}
[2, 3]
```
## arrayProduct
Introducido en: v21.1.0
Devuelve el producto de los elementos del array de entrada.
Si se especifica una función lambda `func`, devuelve el producto de los elementos de los valores resultantes de la lambda.
**Sintaxis**
```sql theme={null}
arrayProduct([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])
```
**Argumentos**
* `func(x[, y1, ..., yN])` — Opcional. Una función lambda que opera sobre los elementos del array de origen (`x`) y los arrays de condición (`y`). [`función lambda`](/es/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — El array de origen que se va a procesar. [`Array(T)`](/es/reference/data-types/array)
* `[, cond1_arr, ... , condN_arr]` — Opcional. N arrays de condición que proporcionan argumentos adicionales a la función lambda. [`Array(T)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve el producto de los elementos del array de origen o, si se proporciona una lambda, el producto de los elementos de sus resultados. [`Float64`](/es/reference/data-types/float)
**Ejemplos**
**Ejemplo básico**
```sql title=Query theme={null}
SELECT arrayProduct([1, 2, 3, 4]);
```
```response title=Response theme={null}
24
```
**Uso con funciones lambda**
```sql title=Query theme={null}
SELECT arrayProduct(x, y -> x+y, [2, 2], [2, 2]) AS res;
```
```response title=Response theme={null}
16
```
## arrayPushBack
Introducido en: v1.1.0
Añade un elemento al final del array.
**Sintaxis**
```sql theme={null}
arrayPushBack(arr, x)
```
**Argumentos**
* `arr` — El array al que se le añade el valor `x` al final. [`Array(T)`](/es/reference/data-types/array)
* `x` —
* Valor único que se añade al final del array. [`Array(T)`](/es/reference/data-types/array).
- Solo se pueden añadir números a un array de números, y solo se pueden añadir cadenas a un array de cadenas.
- Al añadir números, ClickHouse establece automáticamente el tipo de `x` según el tipo de dato del array.
- Puede ser `NULL`. La función añade un elemento `NULL` a un array, y el tipo de los elementos del array se convierte en `Nullable`.
Para obtener más información sobre los tipos de datos en ClickHouse, consulte [Tipos de datos](/es/reference/data-types).
**Valor devuelto**
Devuelve un array idéntico a `arr`, pero con un valor adicional `x` al final del array [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT arrayPushBack(['a'], 'b') AS res;
```
```response title=Response theme={null}
['a','b']
```
## arrayPushFront
Introducido en: v1.1.0
Añade un elemento al principio del array.
**Sintaxis**
```sql theme={null}
arrayPushFront(arr, x)
```
**Argumentos**
* `arr` — El array al final del cual se añadirá el valor `x`. [`Array(T)`](/es/reference/data-types/array). - `x` —
* Valor único que se añadirá al principio del array. [`Array(T)`](/es/reference/data-types/array).
- Solo se pueden añadir números a un array de números, y solo se pueden añadir cadenas a un array de cadenas.
- Al añadir números, ClickHouse establece automáticamente el tipo de `x` según el tipo de dato del array.
- Puede ser `NULL`. La función añade un elemento `NULL` a un array, y el tipo de los elementos del array se convierte en `Nullable`.
Para obtener más información sobre los tipos de datos en ClickHouse, consulte [Tipos de datos](/es/reference/data-types).
**Valor devuelto**
Devuelve un array idéntico a `arr`, pero con un valor adicional `x` al principio del array [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT arrayPushFront(['b'], 'a') AS res;
```
```response title=Response theme={null}
['a','b']
```
## arrayROCAUC
Introducido en: v20.4.0
Calcula el área bajo la curva ROC (característica operativa del receptor).
Una curva ROC se obtiene trazando la tasa de verdaderos positivos (TPR) en el eje y y la tasa de falsos positivos (FPR) en el eje x para todos los umbrales.
El valor resultante va de cero a uno; cuanto mayor sea el valor, mejor será el rendimiento del modelo.
El ROC AUC (también conocido simplemente como AUC) es un concepto de aprendizaje automático.
Para obtener más información, consulte [aquí](https://developers.google.com/machine-learning/glossary#pr-auc-area-under-the-pr-curve), [aquí](https://developers.google.com/machine-learning/crash-course/classification/roc-and-auc#expandable-1) y [aquí](https://en.wikipedia.org/wiki/Receiver_operating_characteristic#Area_under_the_curve).
**Sintaxis**
```sql theme={null}
arrayROCAUC(scores, labels[, scale[, partial_offsets]])
```
**Alias**: `arrayAUC`
**Argumentos**
* `scores` — Puntuaciones proporcionadas por el modelo de predicción. [`Array((U)Int*)`](/es/reference/data-types/array) o [`Array(Float*)`](/es/reference/data-types/array)
* `labels` — Etiquetas de las muestras, normalmente 1 para una muestra positiva y 0 para una muestra negativa. [`Array((U)Int*)`](/es/reference/data-types/array) o [`Enum`](/es/reference/data-types/enum)
* `scale` — Opcional. Determina si se devuelve el área normalizada. Si es false, devuelve en su lugar el área bajo la curva de TP (verdaderos positivos) x FP (falsos positivos). Valor predeterminado: true. [`Bool`](/es/reference/data-types/boolean)
* `partial_offsets` —
* Un array de cuatro enteros no negativos para calcular un área parcial bajo la curva ROC (equivalente a una banda vertical del espacio ROC) en lugar del AUC completo. Esta opción es útil para el cálculo distribuido del ROC AUC. El array debe contener los siguientes elementos \[`higher_partitions_tp`, `higher_partitions_fp`, `total_positives`, `total_negatives`]. [Array](/es/reference/data-types/array) de [Enteros](/es/reference/data-types/int-uint) no negativos. Opcional.
* `higher_partitions_tp`: El número de etiquetas positivas en las particiones con puntuaciones más altas.
* `higher_partitions_fp`: El número de etiquetas negativas en las particiones con puntuaciones más altas.
* `total_positives`: El número total de muestras positivas de todo el conjunto de datos.
* `total_negatives`: El número total de muestras negativas de todo el conjunto de datos.
Cuando se usa `arr_partial_offsets`, `arr_scores` y `arr_labels` deben corresponder solo a una partición del conjunto de datos completo, que contenga un intervalo de puntuaciones.
El conjunto de datos debe dividirse en particiones contiguas, donde cada partición contenga el subconjunto de datos cuyas puntuaciones estén dentro de un rango específico.
Por ejemplo:
* Una partición podría contener todas las puntuaciones en el intervalo \[0, 0.5).
* Otra partición podría contener puntuaciones en el intervalo \[0.5, 1.0].
**Valor devuelto**
Devuelve el área bajo la curva ROC (característica operativa del receptor). [`Float64`](/es/reference/data-types/float)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT arrayROCAUC([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1]);
```
```response title=Response theme={null}
0.75
```
## arrayRandomSample
Introducido en: v23.10.0
Devuelve un subconjunto con `samples` elementos aleatorios de una matriz de entrada. Si `samples` supera el tamaño de la matriz de entrada, el tamaño de la muestra se limita al tamaño de la matriz; es decir, se devuelven todos los elementos de la matriz, pero no se garantiza su orden. La función puede manejar tanto matrices planas como matrices anidadas.
**Sintaxis**
```sql theme={null}
arrayRandomSample(arr, samples)
```
**Argumentos**
* `arr` — El array de entrada o array multidimensional del que se extraen los elementos de la muestra. [`Array(T)`](/es/reference/data-types/array)
* `samples` — El número de elementos que se incluirán en la muestra aleatoria. [`(U)Int*`](/es/reference/data-types/int-uint)
**Valor devuelto**
Un array que contiene una muestra aleatoria de elementos del array de entrada [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT arrayRandomSample(['apple', 'banana', 'cherry', 'date'], 2) as res;
```
```response title=Response theme={null}
['cherry','apple']
```
**Uso de un array multidimensional**
```sql title=Query theme={null}
SELECT arrayRandomSample([[1, 2], [3, 4], [5, 6]], 2) as res;
```
```response title=Response theme={null}
[[3,4],[5,6]]
```
## arrayReduce
Introducido en: v1.1.0
Aplica una función de agregación a los elementos del array y devuelve el resultado.
El nombre de la función de agregación se pasa como una cadena entre comillas simples: `'max'`, `'sum'`.
Al usar funciones de agregación paramétricas, el parámetro se indica después del nombre de la función, entre paréntesis: `'uniqUpTo(6)'`.
**Sintaxis**
```sql theme={null}
arrayReduce(agg_f, arr1[, arr2, ... , arrN])
```
**Argumentos**
* `agg_f` — El nombre de una función de agregación, que debe ser una constante. [`String`](/es/reference/data-types/string)
* `arr1[, arr2, ... , arrN]` — N arrays correspondientes a los argumentos de `agg_f`. [`Array(T)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve el resultado de la función de agregación
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT arrayReduce('max', [1, 2, 3]);
```
```response title=Response theme={null}
┌─arrayReduce('max', [1, 2, 3])─┐
│ 3 │
└───────────────────────────────┘
```
**Ejemplo con función de agregación que usa varios argumentos**
```sql title=Query theme={null}
--Si una función de agregación recibe múltiples argumentos, esta función debe aplicarse a múltiples arrays del mismo tamaño.
SELECT arrayReduce('maxIf', [3, 5], [1, 0]);
```
```response title=Response theme={null}
┌─arrayReduce('maxIf', [3, 5], [1, 0])─┐
│ 3 │
└──────────────────────────────────────┘
```
**Ejemplo con una función de agregación paramétrica**
```sql title=Query theme={null}
SELECT arrayReduce('uniqUpTo(3)', [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
```
```response title=Response theme={null}
┌─arrayReduce('uniqUpTo(3)', [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])─┐
│ 4 │
└─────────────────────────────────────────────────────────────┘
```
## arrayReduceInRanges
Introducido en: v20.4.0
Aplica una función de agregación a los elementos del array en los rangos especificados y devuelve un array con el resultado correspondiente a cada rango.
La función devolverá el mismo resultado que varias llamadas a `arrayReduce(agg_func, arraySlice(arr1, index, length), ...)`.
**Sintaxis**
```sql theme={null}
arrayReduceInRanges(agg_f, ranges, arr1[, arr2, ... ,arrN])
```
**Argumentos**
* `agg_f` — El nombre de la función de agregación que se va a utilizar. [`String`](/es/reference/data-types/string)
* `ranges` — El rango sobre el que se realizará la agregación. Un array de tuplas, `(i, r)`, que contiene el índice `i` a partir del cual se empieza y el rango `r` sobre el que se agrega. [`Array(T)`](/es/reference/data-types/array) o [`Tuple(T)`](/es/reference/data-types/tuple)
* `arr1[, arr2, ... ,arrN]` — N arrays como argumentos de la función de agregación. [`Array(T)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve un array que contiene los resultados de la función de agregación sobre los rangos especificados [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT arrayReduceInRanges(
'sum',
[(1, 5), (2, 3), (3, 4), (4, 4)],
[1000000, 200000, 30000, 4000, 500, 60, 7]
) AS res
```
```response title=Response theme={null}
┌─res─────────────────────────┐
│ [1234500,234000,34560,4567] │
└─────────────────────────────┘
```
## arrayRemove
Introducido en: v25.11.0
Elimina de un array todos los elementos iguales a un valor dado.
Los `NULL` se consideran iguales.
**Sintaxis**
```sql theme={null}
arrayRemove(arr, elem)
```
**Alias**: `array_remove`
**Argumentos**
* `arr` — Array(T) - `elem` — T
**Valor devuelto**
Devuelve un subconjunto del array de entrada [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo 1**
```sql title=Query theme={null}
SELECT arrayRemove([1, 2, 2, 3], 2)
```
```response title=Response theme={null}
[1, 3]
```
**Ejemplo 2**
```sql title=Query theme={null}
SELECT arrayRemove(['a', NULL, 'b', NULL], NULL)
```
```response title=Response theme={null}
['a', 'b']
```
## arrayResize
Introducido en: v1.1.0
Cambia la longitud del array.
**Sintaxis**
```sql theme={null}
arrayResize(arr, size[, extender])
```
**Argumentos**
* `arr` — Array que se va a redimensionar. [`Array(T)`](/es/reference/data-types/array)
* `size` —
-La nueva longitud del array.
Si `size` es menor que el tamaño original del array, el array se trunca por la derecha.
Si `size` es mayor que el tamaño inicial del array, el array se amplía por la derecha con valores `extender` o con los valores predeterminados del tipo de dato de los elementos del array.
* `extender` — Valor que se usará para ampliar el array. Puede ser `NULL`.
**Valor devuelto**
Un array de longitud `size`. [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo 1**
```sql title=Query theme={null}
SELECT arrayResize([1], 3);
```
```response title=Response theme={null}
[1,0,0]
```
**Ejemplo 2**
```sql title=Query theme={null}
SELECT arrayResize([1], 3, NULL);
```
```response title=Response theme={null}
[1,NULL,NULL]
```
## arrayReverse
Introducido en: v1.1.0
Invierte el orden de los elementos de un array dado.
La función `reverse(arr)` cumple la misma función, pero también funciona con otros tipos de datos,
además de Arrays.
**Sintaxis**
```sql theme={null}
arrayReverse(arr)
```
**Argumentos**
* `arr` — El array que se va a invertir. [`Array(T)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve un array del mismo tamaño que el original, con los elementos en orden inverso [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT arrayReverse([1, 2, 3])
```
```response title=Response theme={null}
[3,2,1]
```
## arrayReverseFill
Introducido en: v20.1.0
La función `arrayReverseFill` procesa secuencialmente un array de origen desde el último
elemento hasta el primero, evaluando una condición lambda en cada posición con elementos
del array de origen y de los arrays de condición. Cuando la condición resulta falsa en la
posición i, la función sustituye ese elemento por el elemento de la posición i+1
del estado actual del array. El último elemento siempre se conserva,
independientemente de la condición.
**Sintaxis**
```sql theme={null}
arrayReverseFill(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])
```
**Argumentos**
* `func(x[, y1, ..., yN])` — Una función lambda que actúa sobre los elementos del array de origen (`x`) y de los arrays de condición (`y`). [`Función lambda`](/es/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — El array de origen que se va a procesar. [`Array(T)`](/es/reference/data-types/array)
* `[, cond1_arr, ... , condN_arr]` — Opcional. N arrays de condición que proporcionan argumentos adicionales a la función lambda. [`Array(T)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve un array en el que los elementos del array de origen se sustituyen por los resultados de la lambda. [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo con un solo array**
```sql title=Query theme={null}
SELECT arrayReverseFill(x -> not isNull(x), [1, null, 2, null]) AS res
```
```response title=Response theme={null}
[1, 2, 2, NULL]
```
**Ejemplo con dos arrays**
```sql title=Query theme={null}
SELECT arrayReverseFill(x, y, z -> x > y AND x < z, [5, 3, 6, 2], [4, 7, 1, 3], [10, 2, 8, 5]) AS res;
```
```response title=Response theme={null}
[5, 6, 6, 2]
```
## arrayReverseSort
Introducido en: v1.1.0
Ordena los elementos de un array en orden descendente.
Si se especifica una función `f`, el array proporcionado se ordena según el resultado
de aplicar la función a los elementos del array, y luego se invierte el array ordenado.
Si `f` acepta varios argumentos, a la función `arrayReverseSort` se le pasan varios arrays con los que
se corresponderán los argumentos de `func`.
Si el array que se va a ordenar contiene `-Inf`, `NULL`, `NaN` o `Inf`, se ordenarán en el siguiente orden:
1. `-Inf`
2. `Inf`
3. `NaN`
4. `NULL`
`arrayReverseSort` es una [función de orden superior](/es/reference/functions/regular-functions/overview#higher-order-functions).
**Sintaxis**
```sql theme={null}
arrayReverseSort([f,] arr [, arr1, ... ,arrN)
```
**Argumentos**
* `f(y1[, y2 ... yN])` — La función lambda que se aplica a los elementos del array `x`. - `arr` — Un array que se debe ordenar. [`Array(T)`](/es/reference/data-types/array) - `arr1, ..., yN` — Opcional. N arrays adicionales, si `f` acepta varios argumentos.
**Valor devuelto**
Devuelve el array `x` ordenado en orden descendente si no se proporciona ninguna función lambda; de lo contrario,
devuelve un array ordenado según la lógica de la función lambda proporcionada y luego invertido. [`Array(T)`](/es/reference/data-types/array).
**Ejemplos**
**Ejemplo 1**
```sql title=Query theme={null}
SELECT arrayReverseSort((x, y) -> y, [4, 3, 5], ['a', 'b', 'c']) AS res;
```
```response title=Response theme={null}
[5,3,4]
```
**Ejemplo 2**
```sql title=Query theme={null}
SELECT arrayReverseSort((x, y) -> -y, [4, 3, 5], [1, 2, 3]) AS res;
```
```response title=Response theme={null}
[4,3,5]
```
## arrayReverseSplit
Introducido en: v20.1.0
Divide un array de origen en varios arrays. Cuando `func(x[, y1, ..., yN])` devuelve un valor distinto de cero, el array se dividirá a la derecha del elemento. El array no se dividirá después del último elemento.
**Sintaxis**
```sql theme={null}
arrayReverseSplit(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])
```
**Argumentos**
* `func(x[, y1, ..., yN])` — Una función lambda que opera sobre los elementos del array de origen (`x`) y los arrays de condición (`y`). [`función lambda`](/es/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — El array de origen que se va a procesar. [`función lambda`](/es/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `[, cond1_arr, ... , condN_arr]` — Opcional. N arrays de condición que proporcionan argumentos adicionales a la función lambda. [`Array(T)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve un array de arrays. [`Array(Array(T))`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT arrayReverseSplit((x, y) -> y, [1, 2, 3, 4, 5], [1, 0, 0, 1, 0]) AS res
```
```response title=Response theme={null}
[[1], [2, 3, 4], [5]]
```
## arrayRotateLeft
Introducido en: v23.8.0
Rota un array hacia la izquierda el número especificado de elementos. Los valores negativos de `n` se interpretan como una rotación hacia la derecha por el valor absoluto de `n`.
**Sintaxis**
```sql theme={null}
arrayRotateLeft(arr, n)
```
**Argumentos**
* `arr` — El array cuyos elementos se van a rotar.[`Array(T)`](/es/reference/data-types/array). - `n` — Número de elementos que se van a rotar. [`(U)Int8/16/32/64`](/es/reference/data-types/int-uint).
**Valor devuelto**
Un array rotado a la izquierda en el número de elementos especificado [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT arrayRotateLeft([1,2,3,4,5,6], 2) as res;
```
```response title=Response theme={null}
[3,4,5,6,1,2]
```
**Valor negativo de n**
```sql title=Query theme={null}
SELECT arrayRotateLeft([1,2,3,4,5,6], -2) as res;
```
```response title=Response theme={null}
[5,6,1,2,3,4]
```
## arrayRotateRight
Introducido en: v23.8.0
Rota un array hacia la derecha el número de elementos especificado. Los valores negativos de `n` se tratan como una rotación hacia la izquierda por el valor absoluto de `n`.
**Sintaxis**
```sql theme={null}
arrayRotateRight(arr, n)
```
**Argumentos**
* `arr` — El array cuyos elementos se rotan.[`Array(T)`](/es/reference/data-types/array). - `n` — Número de elementos que se rotan. [`(U)Int8/16/32/64`](/es/reference/data-types/int-uint).
**Valor devuelto**
Un array rotado a la derecha en el número de elementos especificado [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT arrayRotateRight([1,2,3,4,5,6], 2) as res;
```
```response title=Response theme={null}
[5,6,1,2,3,4]
```
**Valor negativo para n**
```sql title=Query theme={null}
SELECT arrayRotateRight([1,2,3,4,5,6], -2) as res;
```
```response title=Response theme={null}
[3,4,5,6,1,2]
```
## arrayShiftLeft
Introducido en: v23.8.0
Desplaza un array hacia la izquierda el número de elementos especificado.
Los nuevos elementos se rellenan con el argumento proporcionado o con el valor predeterminado del tipo de elemento del array.
Si el número de elementos es negativo, el array se desplaza hacia la derecha.
**Sintaxis**
```sql theme={null}
arrayShiftLeft(arr, n[, default])
```
**Argumentos**
* `arr` — El array cuyos elementos se desplazarán.[`Array(T)`](/es/reference/data-types/array). - `n` — Número de elementos que se desplazarán.[`(U)Int8/16/32/64`](/es/reference/data-types/int-uint). - `default` — Opcional. Valor predeterminado para los elementos nuevos.
**Valor devuelto**
Un array desplazado a la izquierda el número especificado de elementos [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT arrayShiftLeft([1,2,3,4,5,6], 2) as res;
```
```response title=Response theme={null}
[3,4,5,6,0,0]
```
**Cuando n es negativo**
```sql title=Query theme={null}
SELECT arrayShiftLeft([1,2,3,4,5,6], -2) as res;
```
```response title=Response theme={null}
[0,0,1,2,3,4]
```
**Usar un valor predeterminado**
```sql title=Query theme={null}
SELECT arrayShiftLeft([1,2,3,4,5,6], 2, 42) as res;
```
```response title=Response theme={null}
[3,4,5,6,42,42]
```
## arrayShiftRight
Introducido en: v23.8.0
Desplaza un array hacia la derecha el número de elementos especificado.
Los nuevos elementos se rellenan con el argumento proporcionado o con el valor predeterminado del tipo de elemento del array.
Si el número de elementos es negativo, el array se desplaza hacia la izquierda.
**Sintaxis**
```sql theme={null}
arrayShiftRight(arr, n[, default])
```
**Argumentos**
* `arr` — El array cuyos elementos se desplazarán. [`Array(T)`](/es/reference/data-types/array)
* `n` — Número de elementos que se desplazarán. [`(U)Int8/16/32/64`](/es/reference/data-types/int-uint)
* `default` — Opcional. Valor predeterminado de los elementos nuevos.
**Valor devuelto**
Un array desplazado a la derecha el número de elementos especificado [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT arrayShiftRight([1, 2, 3, 4, 5, 6], 2) as res;
```
```response title=Response theme={null}
[0, 0, 1, 2, 3, 4]
```
**Valor negativo de n**
```sql title=Query theme={null}
SELECT arrayShiftRight([1, 2, 3, 4, 5, 6], -2) as res;
```
```response title=Response theme={null}
[3, 4, 5, 6, 0, 0]
```
**Usar un valor predeterminado**
```sql title=Query theme={null}
SELECT arrayShiftRight([1, 2, 3, 4, 5, 6], 2, 42) as res;
```
```response title=Response theme={null}
[42, 42, 1, 2, 3, 4]
```
## arrayShingles
Introducido en: v24.1.0
Genera un array de shingles (similares a los ngrams en cadenas), es decir, subarrays consecutivos de una longitud especificada del array de entrada.
**Sintaxis**
```sql theme={null}
arrayShingles(arr, l)
```
**Argumentos**
* `arr` — Array a partir del cual se genera un array de shingles. [`Array(T)`](/es/reference/data-types/array)
* `l` — La longitud de cada shingle. [`(U)Int*`](/es/reference/data-types/int-uint)
**Valor devuelto**
Un array de shingles generados [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT arrayShingles([1, 2, 3, 4], 3) as res;
```
```response title=Response theme={null}
[[1, 2, 3], [2, 3, 4]]
```
## arrayShuffle
Introducido en: v23.2.0
Devuelve un array del mismo tamaño que el array original, con los elementos en orden aleatorio.
Los elementos se reordenan de modo que cada posible permutación tenga la misma probabilidad de aparecer.
Esta función no materializará las constantes.
**Sintaxis**
```sql theme={null}
arrayShuffle(arr [, seed])
```
**Argumentos**
* `arr` — El array que se va a barajar. [`Array(T)`](/es/reference/data-types/array)
* `seed (optional)` — Opcional. La semilla que se usará para la generación de números aleatorios. Si no se proporciona, se usa una aleatoria. [`(U)Int*`](/es/reference/data-types/int-uint)
**Valor devuelto**
Array con los elementos barajados [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo sin semilla (resultados inestables)**
```sql title=Query theme={null}
SELECT arrayShuffle([1, 2, 3, 4]);
```
```response title=Response theme={null}
[1,4,2,3]
```
**Ejemplo sin semilla (resultados estables)**
```sql title=Query theme={null}
SELECT arrayShuffle([1, 2, 3, 4], 41);
```
```response title=Response theme={null}
[3,2,1,4]
```
## arraySimilarity
Introducido en: v25.4.0
Calcula la similitud entre dos arrays de `0` a `1` según la distancia de Levenshtein ponderada.
**Sintaxis**
```sql theme={null}
arraySimilarity(from, to, from_weights, to_weights)
```
**Argumentos**
* `from` — primer array [`Array(T)`](/es/reference/data-types/array)
* `to` — segundo array [`Array(T)`](/es/reference/data-types/array)
* `from_weights` — pesos del primer array. [`Array((U)Int*|Float*)`](/es/reference/data-types/array)
* `to_weights` — pesos del segundo array. [`Array((U)Int*|Float*)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve un valor de similitud entre `0` y `1` para los dos arrays, calculado a partir de la distancia de Levenshtein ponderada [`Float64`](/es/reference/data-types/float)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT arraySimilarity(['A', 'B', 'C'], ['A', 'K', 'L'], [1.0, 2, 3], [3.0, 4, 5]);
```
```response title=Response theme={null}
0.2222222222222222
```
## arraySlice
Introducido en: v1.1.0
Devuelve una porción del array, incluidos los elementos `NULL`.
**Sintaxis**
```sql theme={null}
arraySlice(arr, offset [, length])
```
**Argumentos**
* `arr` — Array que se va a segmentar. [`Array(T)`](/es/reference/data-types/array)
* `offset` — Desplazamiento desde el borde del array. Un valor positivo indica un desplazamiento desde la izquierda y un valor negativo indica un desplazamiento desde la derecha. La numeración de los elementos del array comienza en `1`. [`(U)Int*`](/es/reference/data-types/int-uint)
* `length` — La longitud del segmento requerido. Si especifica un valor negativo, la función devuelve un segmento abierto `[offset, array_length - length]`. Si omite el valor, la función devuelve el segmento `[offset, the_end_of_array]`. [`(U)Int*`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve un segmento del array con `length` elementos a partir del `offset` especificado [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT arraySlice([1, 2, NULL, 4, 5], 2, 3) AS res;
```
```response title=Response theme={null}
[2, NULL, 4]
```
## arraySort
Introducido en: v1.1.0
Ordena los elementos del array proporcionado en orden ascendente.
Si se especifica una función lambda `f`, el orden de clasificación viene determinado por el resultado de
la lambda aplicada a cada elemento del array.
Si la lambda acepta varios argumentos, a la función `arraySort` se le pasan varios
arrays a los que corresponderán los argumentos de `f`.
Si el array que se va a ordenar contiene `-Inf`, `NULL`, `NaN` o `Inf`, se ordenarán en el siguiente orden:
1. `-Inf`
2. `Inf`
3. `NaN`
4. `NULL`
`arraySort` es una [función de orden superior](/es/reference/functions/regular-functions/overview#higher-order-functions).
**Sintaxis**
```sql theme={null}
arraySort([f,] arr [, arr1, ... ,arrN])
```
**Argumentos**
* `f(y1[, y2 ... yN])` — La función lambda que se aplicará a los elementos del array `x`. - `arr` — Un array que se ordenará. [`Array(T)`](/es/reference/data-types/array) - `arr1, ..., yN` — Opcional. N arrays adicionales si `f` acepta varios argumentos.
**Valor devuelto**
Devuelve el array `arr` ordenado de forma ascendente si no se proporciona ninguna función lambda; en caso contrario,
devuelve un array ordenado según la lógica de la función lambda proporcionada. [`Array(T)`](/es/reference/data-types/array).
**Ejemplos**
**Ejemplo 1**
```sql title=Query theme={null}
SELECT arraySort([1, 3, 3, 0]);
```
```response title=Response theme={null}
[0,1,3,3]
```
**Ejemplo 2**
```sql title=Query theme={null}
SELECT arraySort(['hello', 'world', '!']);
```
```response title=Response theme={null}
['!','hello','world']
```
**Ejemplo 3**
```sql title=Query theme={null}
SELECT arraySort([1, nan, 2, NULL, 3, nan, -4, NULL, inf, -inf]);
```
```response title=Response theme={null}
[-inf,-4,1,2,3,inf,nan,nan,NULL,NULL]
```
## arraySplit
Introducido en: v20.1.0
Divide un array de origen en varios arrays. Cuando `func(x [, y1, ..., yN])` devuelve un valor distinto de cero, el array se dividirá antes del elemento. El array no se dividirá antes del primer elemento.
**Sintaxis**
```sql theme={null}
arraySplit(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])
```
**Argumentos**
* `func(x[, y1, ..., yN])` — Una función lambda que opera sobre los elementos del array de origen (`x`) y de los arrays de condición (`y`).[Función lambda](/es/reference/functions/regular-functions/overview#arrow-operator-and-lambda). - `source_arr` — El array de origen que se va a dividir [`Array(T)`](/es/reference/data-types/array). - `[, cond1_arr, ... , condN_arr]` — Opcional. N arrays de condición que proporcionan argumentos adicionales a la función lambda. [`Array(T)`](/es/reference/data-types/array).
**Valor devuelto**
Devuelve un array de arrays [`Array(Array(T))`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT arraySplit((x, y) -> y, [1, 2, 3, 4, 5], [1, 0, 0, 1, 0]) AS res
```
```response title=Response theme={null}
[[1, 2, 3], [4, 5]]
```
## arraySum
Introducido en: v21.1.0
Devuelve la suma de los elementos del array de origen.
Si se especifica una función lambda `func`, devuelve la suma de los elementos resultantes de la lambda.
**Sintaxis**
```sql theme={null}
arraySum([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])
```
**Argumentos**
* `func(x[, y1, ..., yN])` — Opcional. Una función lambda que opera sobre los elementos del array de origen (`x`) y los arrays de condición (`y`). [`función lambda`](/es/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — El array de origen que se va a procesar. [`Array(T)`](/es/reference/data-types/array)
* `, cond1_arr, ... , condN_arr]` — Opcional. N arrays de condición que proporcionan argumentos adicionales a la función lambda. [`Array(T)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve la suma de los elementos del array de origen o, si se proporciona, la suma de los elementos resultantes de la función lambda.
**Ejemplos**
**Ejemplo básico**
```sql title=Query theme={null}
SELECT arraySum([1, 2, 3, 4]);
```
```response title=Response theme={null}
10
```
**Uso con una función lambda**
```sql title=Query theme={null}
SELECT arraySum(x, y -> x+y, [1, 1, 1, 1], [1, 1, 1, 1]);
```
```response title=Response theme={null}
8
```
## arraySymmetricDifference
Introducida en: v25.4.0
Toma varios arrays y devuelve un array con los elementos que no están presentes en todos los arrays de origen. El resultado contiene solo valores únicos.
La diferencia simétrica de *más de dos conjuntos* se [define matemáticamente](https://en.wikipedia.org/wiki/Symmetric_difference#n-ary_symmetric_difference)
como el conjunto de todos los elementos de entrada que aparecen en un número impar de conjuntos de entrada.
En cambio, la función `arraySymmetricDifference` simplemente devuelve el conjunto de elementos de entrada que no aparecen en todos los conjuntos de entrada.
**Sintaxis**
```sql theme={null}
arraySymmetricDifference(arr1, arr2, ... , arrN)
```
**Argumentos**
* `arrN` — N arrays a partir de las cuales se crea el nuevo array. [`Array(T)`](/es/reference/data-types/array).
**Valor devuelto**
Devuelve un array de elementos distintos que no están presentes en todos los arrays de origen [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT
arraySymmetricDifference([1, 2], [1, 2], [1, 2]) AS empty_symmetric_difference,
arraySymmetricDifference([1, 2], [1, 2], [1, 3]) AS non_empty_symmetric_difference;
```
```response title=Response theme={null}
┌─empty_symmetric_difference─┬─non_empty_symmetric_difference─┐
│ [] │ [3,2] │
└────────────────────────────┴────────────────────────────────┘
```
## arrayTranspose
Introducido en: v26.4.0
Traspone un array bidimensional.
Todos los arrays internos deben tener la misma longitud.
**Sintaxis**
```sql theme={null}
arrayTranspose(arr)
```
**Argumentos**
* `arr` — Un array bidimensional para transponer. Todos los arrays internos deben tener la misma longitud. [`Array(Array(T))`](/es/reference/data-types/array)
**Valor devuelto**
Un array bidimensional transpuesto en el que el elemento `[i][j]` del resultado es igual al elemento `[j][i]` de la entrada. [`Array(Array(T))`](/es/reference/data-types/array)
**Ejemplos**
**Matriz cuadrada**
```sql title=Query theme={null}
SELECT arrayTranspose([[1, 2], [3, 4]])
```
```response title=Response theme={null}
[[1, 3], [2, 4]]
```
**Matriz no cuadrada**
```sql title=Query theme={null}
SELECT arrayTranspose([[1, 2, 3], [4, 5, 6]])
```
```response title=Response theme={null}
[[1, 4], [2, 5], [3, 6]]
```
**Elementos de tipo String**
```sql title=Query theme={null}
SELECT arrayTranspose([['a', 'b'], ['c', 'd']])
```
```response title=Response theme={null}
[['a', 'c'], ['b', 'd']]
```
## arrayUnion
Introducido en: v24.10.0
Toma varios arrays y devuelve un array que contiene todos los elementos que están presentes en alguno de los arrays de origen. El resultado contiene solo valores únicos.
**Sintaxis**
```sql theme={null}
arrayUnion(arr1, arr2, ..., arrN)
```
**Argumentos**
* `arrN` — N arrays a partir de las cuales se crea el nuevo array. [`Array(T)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve un array con elementos distintos de los arrays de entrada [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT
arrayUnion([-2, 1], [10, 1], [-2], []) as num_example,
arrayUnion(['hi'], [], ['hello', 'hi']) as str_example,
arrayUnion([1, 3, NULL], [2, 3, NULL]) as null_example
```
```response title=Response theme={null}
┌─num_example─┬─str_example────┬─null_example─┐
│ [10,-2,1] │ ['hello','hi'] │ [3,2,1,NULL] │
└─────────────┴────────────────┴──────────────┘
```
## arrayUniq
Introducido en: v1.1.0
Cuando se pasa un solo argumento, cuenta el número de elementos distintos del array.
Cuando se pasan varios argumentos, cuenta el número de **tuplas** distintas formadas por elementos en las mismas posiciones de varios arrays.
Por ejemplo, `SELECT arrayUniq([1,2], [3,4], [5,6])` formará las siguientes tuplas:
* Posición 1: (1,3,5)
* Posición 2: (2,4,6)
A continuación, contará el número de tuplas únicas. En este caso, `2`.
Todos los arrays pasados deben tener la misma longitud.
Si quieres obtener una lista de elementos únicos de un array, puedes usar `arrayReduce('groupUniqArray', arr)`.
**Sintaxis**
```sql theme={null}
arrayUniq(arr1[, arr2, ..., arrN])
```
**Argumentos**
* `arr1` — Array cuyo número de elementos únicos se va a contar. [`Array(T)`](/es/reference/data-types/array)
* `[, arr2, ..., arrN]` — Opcional. Arrays adicionales que se utilizan para contar el número de tuplas únicas de elementos en las posiciones correspondientes de varios arrays. [`Array(T)`](/es/reference/data-types/array)
**Valor devuelto**
Para un solo argumento, devuelve el número de
elementos únicos. Para varios argumentos, devuelve el número de tuplas únicas formadas por
elementos en las posiciones correspondientes de los arrays.
[`UInt32`](/es/reference/data-types/int-uint)
**Ejemplos**
**Argumento único**
```sql title=Query theme={null}
SELECT arrayUniq([1, 1, 2, 2])
```
```response title=Response theme={null}
2
```
**Varios argumentos**
```sql title=Query theme={null}
SELECT arrayUniq([1, 2, 3, 1], [4, 5, 6, 4])
```
```response title=Response theme={null}
3
```
## arrayWithConstant
Introducido en: v20.1.0
Crea un array de longitud `length` relleno con la constante `x`.
**Sintaxis**
```sql theme={null}
arrayWithConstant(N, x)
```
**Argumentos**
* `length` — Número de elementos del array. [`(U)Int*`](/es/reference/data-types/int-uint)
* `x` — El valor de cada uno de los `N` elementos del array, de cualquier tipo.
**Valor devuelto**
Devuelve un Array con `N` elementos con valor `x`. [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT arrayWithConstant(3, 1)
```
```response title=Response theme={null}
[1, 1, 1]
```
## arrayZip
Introducido en: v20.1.0
Combina varios arrays en un único array. El array resultante contiene los elementos correspondientes de los arrays de origen, agrupados en tuplas en el orden de los argumentos indicado.
**Sintaxis**
```sql theme={null}
arrayZip(arr1, arr2, ... , arrN)
```
**Argumentos**
* `arr1, arr2, ... , arrN` — N arrays para combinar en un único array. [`Array(T)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve un array con elementos de los arrays de origen agrupados en tuplas. Los tipos de datos de la tupla son los mismos que los de los arrays de entrada y están en el mismo orden en que se pasan los arrays [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT arrayZip(['a', 'b', 'c'], [5, 2, 1]);
```
```response title=Response theme={null}
[('a', 5), ('b', 2), ('c', 1)]
```
## arrayZipUnaligned
Introducido en: v20.1.0
Combina varios arrays en un único array, lo que permite arrays no alineados (de distinta longitud). El array resultante contiene los elementos correspondientes de los arrays de origen agrupados en tuplas en el orden en que aparecen los argumentos.
**Sintaxis**
```sql theme={null}
arrayZipUnaligned(arr1, arr2, ..., arrN)
```
**Argumentos**
* `arr1, arr2, ..., arrN` — N arrays para combinar en un solo array. [`Array(T)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve un array con elementos de los arrays de origen agrupados en tuplas. Los tipos de datos de la tupla son los mismos que los de los arrays de entrada y en el mismo orden en que se pasan los arrays. [`Array(T)`](/es/reference/data-types/array) o [`Tuple(T1, T2, ...)`](/es/reference/data-types/tuple)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT arrayZipUnaligned(['a'], [1, 2, 3]);
```
```response title=Response theme={null}
[('a', 1),(NULL, 2),(NULL, 3)]
```
## countEqual
Introducido en: v1.1.0
Devuelve la cantidad de elementos del array que son iguales a `x`. Equivale a `arrayCount(elem -> elem = x, arr)`.
Los elementos `NULL` se consideran valores distintos.
**Sintaxis**
```sql theme={null}
countEqual(arr, x)
```
**Argumentos**
* `arr` — Array en el que buscar. [`Array(T)`](/es/reference/data-types/array)
* `x` — Valor del array cuyas apariciones se deben contar. Cualquier tipo.
**Valor devuelto**
Devuelve el número de elementos del array que son iguales a `x` [`UInt64`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT countEqual([1, 2, NULL, NULL], NULL)
```
```response title=Response theme={null}
2
```
## empty
Introducido en: v1.1.0
Comprueba si el array de entrada está vacío.
Un array se considera vacío si no contiene ningún elemento.
Puede optimizarse habilitando el ajuste [`optimize_functions_to_subcolumns`](/es/reference/settings/session-settings#optimize_functions_to_subcolumns). Con `optimize_functions_to_subcolumns = 1`, la función lee solo la subcolumna [size0](/es/reference/data-types/array#array-size) en lugar de leer y procesar toda la columna de array. La consulta `SELECT empty(arr) FROM TABLE;` se transforma en `SELECT arr.size0 = 0 FROM TABLE;`.
La función también funciona con Strings o UUIDs.
**Sintaxis**
```sql theme={null}
empty(arr)
```
**Argumentos**
* `arr` — Array de entrada. [`Array(T)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve `1` para un array vacío o `0` para un array no vacío [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT empty([]);
```
```response title=Response theme={null}
1
```
## emptyArrayDate
Introducido en: v1.1.0
Devuelve un array vacío de Date
**Sintaxis**
```sql theme={null}
emptyArrayDate()
```
**Argumentos**
* Ninguno.
**Valor devuelto**
Un array de Date vacío. [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT emptyArrayDate
```
```response title=Response theme={null}
[]
```
## emptyArrayDateTime
Introducido en: v1.1.0
Devuelve un array DateTime vacío
**Sintaxis**
```sql theme={null}
emptyArrayDateTime()
```
**Argumentos**
* Ninguno.
**Valor devuelto**
Un array de DateTime vacío. [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT emptyArrayDateTime
```
```response title=Response theme={null}
[]
```
## emptyArrayFloat32
Introducido en: v1.1.0
Devuelve un Array(Float32) vacío
**Sintaxis**
```sql theme={null}
emptyArrayFloat32()
```
**Argumentos**
* Ninguno.
**Valor devuelto**
Un array vacío de Float32. [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT emptyArrayFloat32
```
```response title=Response theme={null}
[]
```
## emptyArrayFloat64
Introducido en: v1.1.0
Devuelve un Array(Float64) vacío
**Sintaxis**
```sql theme={null}
emptyArrayFloat64()
```
**Argumentos**
* Ninguno.
**Valor devuelto**
Un array vacío de Float64. [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT emptyArrayFloat64
```
```response title=Response theme={null}
[]
```
## emptyArrayInt16
Introducido en: v1.1.0
Devuelve un array vacío de Int16
**Sintaxis**
```sql theme={null}
emptyArrayInt16()
```
**Argumentos**
* Ninguno.
**Valor devuelto**
Un array vacío de Int16. [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT emptyArrayInt16
```
```response title=Response theme={null}
[]
```
## emptyArrayInt32
Introducido en: v1.1.0
Devuelve un array Int32 vacío
**Sintaxis**
```sql theme={null}
emptyArrayInt32()
```
**Argumentos**
* Ninguno.
**Valor devuelto**
Un array vacío de Int32. [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT emptyArrayInt32
```
```response title=Response theme={null}
[]
```
## emptyArrayInt64
Introducido en: v1.1.0
Devuelve un array Int64 vacío
**Sintaxis**
```sql theme={null}
emptyArrayInt64()
```
**Argumentos**
* Ninguno.
**Valor devuelto**
Un array Int64 vacío. [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT emptyArrayInt64
```
```response title=Response theme={null}
[]
```
## emptyArrayInt8
Introducido en: v1.1.0
Devuelve un array Int8 vacío
**Sintaxis**
```sql theme={null}
emptyArrayInt8()
```
**Argumentos**
* Ninguno.
**Valor devuelto**
Un array de Int8 vacío. [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT emptyArrayInt8
```
```response title=Response theme={null}
[]
```
## emptyArrayString
Introducido en: v1.1.0
Devuelve un array de String vacío
**Sintaxis**
```sql theme={null}
emptyArrayString()
```
**Argumentos**
* Ninguno.
**Valor devuelto**
Un array vacío de String. [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT emptyArrayString
```
```response title=Response theme={null}
[]
```
## emptyArrayToSingle
Introducido en: v1.1.0
Acepta un array vacío y devuelve un array de un solo elemento igual al valor predeterminado.
**Sintaxis**
```sql theme={null}
emptyArrayToSingle(arr)
```
**Argumentos**
* `arr` — Un array vacío. [`Array(T)`](/es/reference/data-types/array)
**Valor devuelto**
Un array con un único valor del tipo predeterminado del Array. [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo básico**
```sql title=Query theme={null}
CREATE TABLE test (
a Array(Int32),
b Array(String),
c Array(DateTime)
)
ENGINE = MergeTree
ORDER BY tuple();
INSERT INTO test VALUES ([], [], []);
SELECT emptyArrayToSingle(a), emptyArrayToSingle(b), emptyArrayToSingle(c) FROM test;
```
```response title=Response theme={null}
┌─emptyArrayToSingle(a)─┬─emptyArrayToSingle(b)─┬─emptyArrayToSingle(c)───┐
│ [0] │ [''] │ ['1970-01-01 01:00:00'] │
└───────────────────────┴───────────────────────┴─────────────────────────┘
```
## emptyArrayUInt16
Introducido en: v1.1.0
Devuelve un Array de UInt16 vacío
**Sintaxis**
```sql theme={null}
emptyArrayUInt16()
```
**Argumentos**
* Ninguno.
**Valor devuelto**
Un array vacío de UInt16. [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT emptyArrayUInt16
```
```response title=Response theme={null}
[]
```
## emptyArrayUInt32
Introducido en: v1.1.0
Devuelve un array vacío de UInt32
**Sintaxis**
```sql theme={null}
emptyArrayUInt32()
```
**Argumentos**
* Ninguno.
**Valor devuelto**
Un array de UInt32 vacío. [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT emptyArrayUInt32
```
```response title=Response theme={null}
[]
```
## emptyArrayUInt64
Introducido en: v1.1.0
Devuelve un Array de UInt64 vacío
**Sintaxis**
```sql theme={null}
emptyArrayUInt64()
```
**Argumentos**
* Ninguno.
**Valor devuelto**
Un array vacío de UInt64. [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT emptyArrayUInt64
```
```response title=Response theme={null}
[]
```
## emptyArrayUInt8
Introducido en: v1.1.0
Devuelve un Array vacío de UInt8
**Sintaxis**
```sql theme={null}
emptyArrayUInt8()
```
**Argumentos**
* Ninguno.
**Valor devuelto**
Un array vacío de UInt8. [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT emptyArrayUInt8
```
```response title=Response theme={null}
[]
```
## has
Introducido en: v1.1.0
Indica si el array contiene el elemento especificado, si el mapa contiene la clave especificada o si el objeto JSON contiene la ruta especificada.
Para JSON, se admiten rutas anidadas mediante notación de puntos (p. ej., 'a.b.c').
Cuando el primer argumento es un array constante y el segundo es una columna o una expresión, `has(constant_array, column)` se comporta como `column IN (constant_array)` y puede usar la clave primaria y los índices de omisión de datos para optimizarse. Por ejemplo, `has([1, 10, 100], id)` puede aprovechar el índice de clave primaria si `id` forma parte de la `PRIMARY KEY`.
Esta optimización también se aplica cuando la columna se envuelve en funciones monótonas (p. ej., `has([...], toDate(ts))`).
**Sintaxis**
```sql theme={null}
has(haystack, needle)
```
**Argumentos**
* `haystack` — El array, mapa o JSON de origen. [`Array`](/es/reference/data-types/array) o [`Map`](/es/reference/data-types/map) o [`JSON`](/es/reference/data-types/newjson)
* `needle` — El valor que se va a buscar (un elemento en un array, una clave en un mapa o una cadena de ruta en JSON).
**Valor devuelto**
Devuelve `1` si `haystack` contiene el `needle` especificado; de lo contrario, `0`. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Uso básico de mapa**
```sql title=Query theme={null}
SELECT has([1, 2, 3], 2)
```
```response title=Response theme={null}
1
```
**Array no encontrado**
```sql title=Query theme={null}
SELECT has([1, 2, 3], 4)
```
```response title=Response theme={null}
0
```
**Uso básico de mapa**
```sql title=Query theme={null}
SELECT has(map('a', 1, 'b', 2), 'b')
```
```response title=Response theme={null}
1
```
**Ruta JSON**
```sql title=Query theme={null}
SELECT has('{"a": {"b": 1}}'::JSON, 'a.b')
```
```response title=Response theme={null}
1
```
## hasAll
Introducido en: v1.1.0
Comprueba si un array es un subconjunto de otro.
* Un array vacío es un subconjunto de cualquier array.
* `Null` se trata como un valor.
* El orden de los valores en ambos arrays no importa.
**Sintaxis**
```sql theme={null}
hasAll(set, subset)
```
**Argumentos**
* `set` — Array de cualquier tipo con elementos. [`Array(T)`](/es/reference/data-types/array)
* `subset` — Array de cualquier tipo que comparte un supertipo común con `set` y contiene elementos cuya condición de subconjunto de `set` debe comprobarse. [`Array(T)`](/es/reference/data-types/array)
**Valor devuelto**
* `1`, si `set` contiene todos los elementos de `subset`.
* `0`, en caso contrario.
Genera una excepción `NO_COMMON_TYPE` si los elementos de `set` y `subset` no comparten un supertipo común.
**Ejemplos**
**Arrays vacíos**
```sql title=Query theme={null}
SELECT hasAll([], [])
```
```response title=Response theme={null}
1
```
**Arrays con valores NULL**
```sql title=Query theme={null}
SELECT hasAll([1, Null], [Null])
```
```response title=Response theme={null}
1
```
**Arrays que contienen valores de distinto tipo**
```sql title=Query theme={null}
SELECT hasAll([1.0, 2, 3, 4], [1, 3])
```
```response title=Response theme={null}
1
```
**Arrays que contienen valores String**
```sql title=Query theme={null}
SELECT hasAll(['a', 'b'], ['a'])
```
```response title=Response theme={null}
1
```
**Arrays sin tipo común**
```sql title=Query theme={null}
SELECT hasAll([1], ['a'])
```
```response title=Response theme={null}
Lanza una excepción NO_COMMON_TYPE
```
**Array de arrays**
```sql title=Query theme={null}
SELECT hasAll([[1, 2], [3, 4]], [[1, 2], [3, 5]])
```
```response title=Response theme={null}
0
```
## hasAny
Introducido en: v1.1.0
Comprueba si dos arrays se intersecan en alguno de sus elementos.
* `Null` se procesa como un valor.
* El orden de los valores en ambos arrays no importa.
**Sintaxis**
```sql theme={null}
hasAny(arr_x, arr_y)
```
**Argumentos**
* `arr_x` — Array de cualquier tipo que contiene un conjunto de elementos. [`Array(T)`](/es/reference/data-types/array)
* `arr_y` — Array de cualquier tipo que comparte un supertipo común con el array `arr_x`. [`Array(T)`](/es/reference/data-types/array)
**Valor devuelto**
* `1`, si `arr_x` y `arr_y` tienen al menos un elemento en común.
* `0`, en caso contrario.
Genera una excepción `NO_COMMON_TYPE` si alguno de los elementos de los dos arrays no comparte un supertipo común.
**Ejemplos**
**Un array está vacío**
```sql title=Query theme={null}
SELECT hasAny([1], [])
```
```response title=Response theme={null}
0
```
**Arrays con valores NULL**
```sql title=Query theme={null}
SELECT hasAny([Null], [Null, 1])
```
```response title=Response theme={null}
1
```
**Arrays con valores de distinto tipo**
```sql title=Query theme={null}
SELECT hasAny([-128, 1., 512], [1])
```
```response title=Response theme={null}
1
```
**Arrays sin un tipo común**
```sql title=Query theme={null}
SELECT hasAny([[1, 2], [3, 4]], ['a', 'c'])
```
```response title=Response theme={null}
Lanza una excepción `NO_COMMON_TYPE`
```
**Array de Array**
```sql title=Query theme={null}
SELECT hasAll([[1, 2], [3, 4]], [[1, 2], [1, 2]])
```
```response title=Response theme={null}
1
```
## hasSubstr
Introducido en: v20.6.0
Comprueba si todos los elementos de array2 aparecen en array1 en el mismo orden exacto.
Por lo tanto, la función devolverá `1` si y solo si array1 = prefijo + array2 + sufijo.
En otras palabras, la función comprueba si todos los elementos de array2 están contenidos en array1, como hace la función `hasAll`.
Además, comprueba que los elementos aparezcan en el mismo orden tanto en array1 como en array2.
* La función devolverá `1` si array2 está vacío.
* `NULL` se procesa como un valor. En otras palabras, `hasSubstr([1, 2, NULL, 3, 4], [2,3])` devolverá `0`. Sin embargo, `hasSubstr([1, 2, NULL, 3, 4], [2,NULL,3])` devolverá `1`
* El orden de los valores en ambos arrays sí importa.
Genera una excepción `NO_COMMON_TYPE` si alguno de los elementos de los dos arrays no comparte un supertipo común.
**Sintaxis**
```sql theme={null}
hasSubstr(arr1, arr2)
```
**Argumentos**
* `arr1` — Array de cualquier tipo con un conjunto de elementos. [`Array(T)`](/es/reference/data-types/array)
* `arr2` — Array de cualquier tipo con un conjunto de elementos. [`Array(T)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve `1` si `arr1` contiene `arr2`. De lo contrario, devuelve `0`. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ambos arrays están vacíos**
```sql title=Query theme={null}
SELECT hasSubstr([], [])
```
```response title=Response theme={null}
1
```
**Arrays con valores NULL**
```sql title=Query theme={null}
SELECT hasSubstr([1, Null], [Null])
```
```response title=Response theme={null}
1
```
**Arrays con valores de distinto tipo**
```sql title=Query theme={null}
SELECT hasSubstr([1.0, 2, 3, 4], [1, 3])
```
```response title=Response theme={null}
0
```
**Arrays de cadenas**
```sql title=Query theme={null}
SELECT hasSubstr(['a', 'b'], ['a'])
```
```response title=Response theme={null}
1
```
**Arrays con orden válido**
```sql title=Query theme={null}
SELECT hasSubstr(['a', 'b' , 'c'], ['a', 'b'])
```
```response title=Response theme={null}
1
```
**Arrays con un orden no válido**
```sql title=Query theme={null}
SELECT hasSubstr(['a', 'b' , 'c'], ['a', 'c'])
```
```response title=Response theme={null}
0
```
**Array de arrays**
```sql title=Query theme={null}
SELECT hasSubstr([[1, 2], [3, 4], [5, 6]], [[1, 2], [3, 4]])
```
```response title=Response theme={null}
1
```
**Arrays sin tipo común**
```sql title=Query theme={null}
SELECT hasSubstr([1, 2, NULL, 3, 4], ['a'])
```
```response title=Response theme={null}
Lanza una excepción `NO_COMMON_TYPE`
```
## indexOf
Introducido en: v1.1.0
Devuelve el índice del primer elemento con el valor 'x' (a partir de 1) si está en el array.
Si el array no contiene el valor buscado, la función devuelve `0`.
Los elementos con valor `NULL` se tratan como valores normales.
**Sintaxis**
```sql theme={null}
indexOf(arr, x)
```
**Argumentos**
* `arr` — Un array en el que buscar `x`. [`Array(T)`](/es/reference/data-types/array)
* `x` — Valor del primer elemento coincidente de `arr` cuyo índice se debe devolver. [`UInt64`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve el índice (empezando por uno) de la primera aparición de `x` en `arr`, si existe. En caso contrario, devuelve `0`. [`UInt64`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo básico**
```sql title=Query theme={null}
SELECT indexOf([5, 4, 1, 3], 3)
```
```response title=Response theme={null}
4
```
**Array con NULL**
```sql title=Query theme={null}
SELECT indexOf([1, 3, NULL, NULL], NULL)
```
```response title=Response theme={null}
3
```
## indexOfAssumeSorted
Introducido en: v24.12.0
Devuelve el índice del primer elemento con el valor 'x' (empezando en `1`) si está en el array.
Si el array no contiene el valor buscado, la función devuelve `0`.
A diferencia de la función `indexOf`, esta función asume que el array está ordenado en
orden ascendente. Si el array no está ordenado, el resultado no está definido.
**Sintaxis**
```sql theme={null}
indexOfAssumeSorted(arr, x)
```
**Argumentos**
* `arr` — Un array ordenado en el que buscar. [`Array(T)`](/es/reference/data-types/array)
* `x` — Valor del primer elemento coincidente de `arr` ordenado cuyo índice se debe devolver. [`UInt64`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve el índice (contado desde uno) de la primera aparición de `x` en `arr`, si existe. En caso contrario, devuelve `0`. [`UInt64`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo básico**
```sql title=Query theme={null}
SELECT indexOfAssumeSorted([1, 3, 3, 3, 4, 4, 5], 4)
```
```response title=Response theme={null}
5
```
## kql\_array\_sort\_asc
Introducido en: v23.10.0
Ordena uno o varios arrays en orden ascendente. El primer array se ordena y los arrays posteriores se reordenan para coincidir con el orden resultante del primero. Los valores NULL se colocan al final. Esta es una función de compatibilidad con KQL (Kusto Query Language).
**Sintaxis**
```sql theme={null}
kql_array_sort_asc(array1[, array2, ..., nulls_last])
```
**Argumentos**
* `array1` — El array que se va a ordenar. [`Array(T)`](/es/reference/data-types/array)
* `array2` — Opcional. Arrays adicionales que se reordenarán según el orden de `array1`. [`Array(T)`](/es/reference/data-types/array)
* `nulls_last` — Opcional. Un valor booleano que indica si los valores nulos deben aparecer al final. El valor predeterminado es true. [`UInt8`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve una tupla de arrays ordenados en orden ascendente. [`Tuple(Array, ...)`](/es/reference/data-types/tuple)
**Ejemplos**
**Uso básico**
```sql title=Query theme={null}
SELECT kql_array_sort_asc([3, 1, 2])
```
```response title=Response theme={null}
([1, 2, 3])
```
## kql\_array\_sort\_desc
Introducido en: v23.10.0
Ordena uno o varios arrays en orden descendente. El primer array se ordena y los siguientes se reordenan para que coincidan con el orden resultante del primero. Los valores NULL se colocan al final. Esta es una función de compatibilidad con KQL (Kusto Query Language).
**Sintaxis**
```sql theme={null}
kql_array_sort_desc(array1[, array2, ..., nulls_last])
```
**Argumentos**
* `array1` — El array que se va a ordenar. [`Array(T)`](/es/reference/data-types/array)
* `array2` — Arrays adicionales opcionales que se reordenan según el orden de clasificación de `array1`. [`Array(T)`](/es/reference/data-types/array)
* `nulls_last` — Booleano opcional que indica si los valores NULL deben aparecer al final. El valor predeterminado es true. [`UInt8`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve una tupla de arrays ordenados en orden descendente. [`Tuple(Array, ...)`](/es/reference/data-types/tuple)
**Ejemplos**
**Uso básico**
```sql title=Query theme={null}
SELECT kql_array_sort_desc([3, 1, 2])
```
```response title=Response theme={null}
([3, 2, 1])
```
## length
Introducido en: v1.1.0
Calcula la longitud de una cadena o un Array.
* Para argumentos String o FixedString: calcula el número de bytes de la cadena.
* Para argumentos Array: calcula el número de elementos del Array.
* Si se aplica a un argumento FixedString, la función es una expresión constante.
Tenga en cuenta que el número de bytes de una cadena no es lo mismo que el número de
puntos de código Unicode ni que el número de "grupos de grafemas" de Unicode
(lo que normalmente llamamos "caracteres"), ni tampoco que el ancho visible de la cadena.
Se permite incluir bytes NULL ASCII en las cadenas, y también se contabilizarán.
**Sintaxis**
```sql theme={null}
length(x)
```
**Aliases**: `OCTET_LENGTH`
**Argumentos**
* `x` — Valor para el que se calcula el número de bytes (para String/FixedString) o de elementos (para Array). [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring) o [`Array(T)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve el número de bytes de la String/FixedString `x` / el número de elementos del Array `x` [`UInt64`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de String**
```sql title=Query theme={null}
SELECT length('Hello, world!')
```
```response title=Response theme={null}
13
```
**Ejemplo de Array**
```sql title=Query theme={null}
SELECT length(['Hello', 'world'])
```
```response title=Response theme={null}
2
```
**ejemplo de constexpr**
```sql title=Query theme={null}
WITH 'hello' || toString(number) AS str
SELECT str,
isConstant(length(str)) AS str_length_is_constant,
isConstant(length(str::FixedString(6))) AS fixed_str_length_is_constant
FROM numbers(3)
```
```response title=Response theme={null}
┌─str────┬─str_length_is_constant─┬─fixed_str_length_is_constant─┐
│ hello0 │ 0 │ 1 │
│ hello1 │ 0 │ 1 │
│ hello2 │ 0 │ 1 │
└────────┴────────────────────────┴──────────────────────────────┘
```
**ejemplo de Unicode**
```sql title=Query theme={null}
SELECT 'ёлка' AS str1, length(str1), lengthUTF8(str1), normalizeUTF8NFKD(str1) AS str2, length(str2), lengthUTF8(str2)
```
```response title=Response theme={null}
┌─str1─┬─length(str1)─┬─lengthUTF8(str1)─┬─str2─┬─length(str2)─┬─lengthUTF8(str2)─┐
│ ёлка │ 8 │ 4 │ ёлка │ 10 │ 5 │
└──────┴──────────────┴──────────────────┴──────┴──────────────┴──────────────────┘
```
**Ejemplo de ascii\_vs\_utf8**
```sql title=Query theme={null}
SELECT 'ábc' AS str, length(str), lengthUTF8(str)
```
```response title=Response theme={null}
┌─str─┬─length(str)──┬─lengthUTF8(str)─┐
│ ábc │ 4 │ 3 │
└─────┴──────────────┴─────────────────┘
```
## notEmpty
Introducido en: v1.1.0
Comprueba si el array de entrada no está vacío.
Un array se considera no vacío si contiene al menos un elemento.
Se puede optimizar habilitando la opción [`optimize_functions_to_subcolumns`](/es/reference/settings/session-settings#optimize_functions_to_subcolumns). Con `optimize_functions_to_subcolumns = 1`, la función lee solo la subcolumna [size0](/es/reference/data-types/array#array-size) en lugar de leer y procesar toda la columna de tipo Array. La consulta `SELECT notEmpty(arr) FROM table` se transforma en `SELECT arr.size0 != 0 FROM TABLE`.
La función también funciona con Strings o UUIDs.
**Sintaxis**
```sql theme={null}
notEmpty(arr)
```
**Argumentos**
* `arr` — Array de entrada. [`Array(T)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve `1` para un array no vacío o `0` para un array vacío [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT notEmpty([1,2]);
```
```response title=Response theme={null}
1
```
## range
Introducido en: v1.1.0
Devuelve un Array de números desde `start` hasta `end - 1`, en incrementos de `step`.
Los tipos admitidos son:
* `UInt8/16/32/64`
* `Int8/16/32/64]`
* Todos los argumentos `start`, `end` y `step` deben ser de uno de los tipos admitidos anteriores. Los elementos del Array devuelto serán de un supertipo de los argumentos.
* Se genera una excepción si la función devuelve un Array con una longitud total mayor que el número de elementos especificado por la configuración [`function_range_max_elements_in_block`](/es/reference/settings/session-settings#function_range_max_elements_in_block).
* Devuelve `NULL` si algún argumento tiene el tipo Nullable(nothing). Se genera una excepción si algún argumento tiene el valor `NULL` (tipo Nullable(T)).
**Sintaxis**
```sql theme={null}
range([start, ] end [, step])
```
**Argumentos**
* `start` — Opcional. El primer elemento del array. Obligatorio si se usa `step`. Valor predeterminado: `0`. - `end` — Obligatorio. El número antes del cual se construye el array. - `step` — Opcional. Determina el paso incremental entre cada elemento del array. Valor predeterminado: `1`.
**Valor devuelto**
Array de números desde `start` hasta `end - 1` con incrementos de `step`. [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT range(5), range(1, 5), range(1, 5, 2), range(-1, 5, 2);
```
```response title=Response theme={null}
┌─range(5)────┬─range(1, 5)─┬─range(1, 5, 2)─┬─range(-1, 5, 2)─┐
│ [0,1,2,3,4] │ [1,2,3,4] │ [1,3] │ [-1,1,3] │
└─────────────┴─────────────┴────────────────┴─────────────────┘
```
## replicate
Introducido en: v1.1.0
Crea un array con un único valor.
**Sintaxis**
```sql theme={null}
replicate(x, arr)
```
**Argumentos**
* `x` — El valor con el que rellenar el array de resultados. [`Any`](/es/reference/data-types)
* `arr` — Un array. [`Array(T)`](/es/reference/data-types/array)
**Valor devuelto**
Devuelve un array de la misma longitud que `arr`, relleno con el valor `x`. [`Array(T)`](/es/reference/data-types/array)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT replicate(1, ['a', 'b', 'c']);
```
```response title=Response theme={null}
┌─replicate(1, ['a', 'b', 'c'])───┐
│ [1, 1, 1] │
└─────────────────────────────────┘
```
## reverse
Introducido en: v1.1.0
Invierte el orden de los elementos del array de entrada o de los caracteres de la cadena de entrada.
**Sintaxis**
```sql theme={null}
reverse(arr | str)
```
**Argumentos**
* `arr | str` — El array o la cadena de entrada. [`Array(T)`](/es/reference/data-types/array) o [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve un array o una cadena con el orden de los elementos o los caracteres invertido.
**Ejemplos**
**Invertir un array**
```sql title=Query theme={null}
SELECT reverse([1, 2, 3, 4]);
```
```response title=Response theme={null}
[4, 3, 2, 1]
```
**Invertir una cadena**
```sql title=Query theme={null}
SELECT reverse('abcd');
```
```response title=Response theme={null}
'dcba'
```
## Funciones de distancia
Todas las funciones compatibles se describen en la [documentación sobre funciones de distancia](/es/reference/functions/regular-functions/distance-functions).