Saltar al contenido principal

​
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 
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) Ejemplos Uso válido
Query
SELECT array(toInt32(1), toUInt16(2), toInt8(3)) AS a, toTypeName(a)
Response
┌─a───────┬─toTypeName(a)─┐
│ [1,2,3] │ Array(Int32)  │
└─────────┴───────────────┘
Uso incorrecto
Query
SELECT array(toInt32(5), toDateTime('1998-06-16'), toInt8(5)) AS a, toTypeName(a)
Response
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í, aquí y aquí. Sintaxis 
arrayAUCPR(scores, labels[, partial_offsets])
Alias: arrayPRAUC Argumentos
  • cores — Puntuaciones que genera el modelo de predicción. Array((U)Int*) o Array(Float*)
  • labels — Etiquetas de las muestras, normalmente 1 para una muestra positiva y 0 para una muestra negativa. Array((U)Int*) o Array(Enum)
  • partial_offsets —
  • Opcional. Un Array(T) 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 Ejemplos Ejemplo de uso
Query
SELECT arrayAUCPR([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1]);
Response
┌─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 
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
  • source_arr — El array de origen que se va a procesar. Array(T)
  • cond1_arr, ... — Opcional. N arrays de condición que proporcionan argumentos adicionales a la función lambda. Array(T)
Valor devuelto Devuelve 1 si la función lambda devuelve true para todos los elementos; en caso contrario, 0 UInt8 Ejemplos Todos los elementos cumplen la condición
Query
SELECT arrayAll(x, y -> x=y, [1, 2, 3], [1, 2, 3])
Response
1
No todos los elementos coinciden
Query
SELECT arrayAll(x, y -> x=y, [1, 2, 3], [1, 1, 1])
Response
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 
arrayAutocorrelation(arr, [max_lag])
Argumentos
  • arr — Array de números. Array(T)
  • max_lag — Opcional. Número máximo de retrasos que se van a calcular. Debe ser un entero no negativo. Integer
Valor devuelto Devuelve un array de Float64. Devuelve NaN si la varianza es 0. Array(Float64) Ejemplos Lineal
Query
SELECT arrayAutocorrelation([1, 2, 3, 4, 5]);
Response
[1, 0.4, -0.1, -0.4, -0.4]
Simétrica
Query
SELECT arrayAutocorrelation([10, 20, 10]);
Response
[1, -0.6666666666666669, 0.16666666666666674]
Constante
Query
SELECT arrayAutocorrelation([5, 5, 5]);
Response
[nan, nan, nan]
Limitado
Query
SELECT arrayAutocorrelation([1, 2, 3, 4, 5], 2);
Response
[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 
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
  • source_arr — El array de origen que se va a procesar. Array(T)
  • [, cond1_arr, ... , condN_arr] — Opcional. N arrays de condición que proporcionan argumentos adicionales a la función lambda. Array(T)
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 Ejemplos Ejemplo básico
Query
SELECT arrayAvg([1, 2, 3, 4]);
Response
2.5
Uso con una función lambda
Query
SELECT arrayAvg(x, y -> x*y, [2, 3], [2, 3]) AS res;
Response
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 
arrayCompact(arr)
Argumentos
  • arr — Un array del que se eliminarán los duplicados. Array(T)
Valor devuelto Devuelve un array sin valores duplicados Array(T) Ejemplos Ejemplo de uso
Query
SELECT arrayCompact([1, 1, nan, nan, 2, 3, 3, 3]);
Response
[1,nan,2,3]

​
arrayConcat

Introducido en: v1.1.0 Combina los arrays que se pasan como argumentos. Sintaxis 
arrayConcat(arr1 [, arr2, ... , arrN])
Argumentos
  • arr1 [, arr2, ... , arrN] — Número N de arrays que se concatenan. Array(T)
Valor devuelto Devuelve un único array combinado a partir de los arrays proporcionados como argumentos. Array(T) Ejemplos Ejemplo de uso
Query
SELECT arrayConcat([1, 2], [3, 4], [5, 6]) AS res
Response
[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. Sintaxis 
arrayCount([func, ] arr1, ...)
Argumentos
  • func — Opcional. Función que se aplicará a cada elemento de los arrays. Función lambda
  • arr1, ..., arrN — N arrays. Array(T)
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 Ejemplos Ejemplo de uso
Query
SELECT arrayCount(x -> (x % 2), groupArray(number)) FROM numbers(10)
Response
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 
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
  • arr1 — El array de origen de valores numéricos. Array(T)
  • [arr2, ..., arrN] — Opcional. Arrays adicionales del mismo tamaño, que se pasan como argumentos a la función lambda si se especifica. Array(T)
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) Ejemplos Uso básico
Query
SELECT arrayCumSum([1, 1, 1, 1]) AS res
Response
[1, 2, 3, 4]
Con una función lambda
Query
SELECT arrayCumSum(x -> x * 2, [1, 2, 3]) AS res
Response
[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 
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
  • arr1 — El array de origen de valores numéricos. Array(T)
  • [arr2, ..., arrN] — Opcional. Arrays adicionales del mismo tamaño, que se pasan como argumentos a la función lambda si se especifica. Array(T)
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) Ejemplos Uso básico
Query
SELECT arrayCumSumNonNegative([1, 1, -4, 1]) AS res
Response
[1, 2, 0, 1]
Con una lambda
Query
SELECT arrayCumSumNonNegative(x -> x * 2, [1, -2, 3]) AS res
Response
[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 
arrayDifference(arr)
Argumentos
  • arr — Array para el que se calculan las diferencias entre elementos adyacentes. Array(T)
Valor devuelto Devuelve un array con las diferencias entre elementos adyacentes del array UInt* Ejemplos Ejemplo de uso
Query
SELECT arrayDifference([1, 2, 3, 4]);
Response
[0,1,1,1]
Ejemplo de desbordamiento por el tipo de resultado Int64
Query
SELECT arrayDifference([0, 10000000000000000000]);
Response
┌─arrayDifference([0, 10000000000000000000])─┐
│ [0,-8446744073709551616]                   │
└────────────────────────────────────────────┘

​
arrayDistinct

Introducido en: v1.1.0 Devuelve un array que contiene solo los elementos distintos de un array. Sintaxis 
arrayDistinct(arr)
Argumentos
  • arr — Array del que se extraen los elementos distintos. Array(T)
Valor devuelto Devuelve un array que contiene los elementos distintos. Array(T) Ejemplos Ejemplo de uso
Query
SELECT arrayDistinct([1, 2, 2, 3, 1]);
Response
[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 
arrayDotProduct(v1, v2)
Argumentos 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* o Float* o Decimal Ejemplos Ejemplo de Array
Query
SELECT arrayDotProduct([1, 2, 3], [4, 5, 6]) AS res, toTypeName(res);
Response
32    UInt16
Ejemplo de Tuple
Query
SELECT dotProduct((1::UInt16, 2::UInt8, 3::Float32),(4::Int16, 5::Float32, 6::UInt8)) AS res, toTypeName(res);
Response
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 
arrayElement(arr, n)
Argumentos
  • arr — El array en el que se busca. Array(T). - n — Posición del elemento que se quiere obtener. (U)Int*.
Valor devuelto Devuelve un único array combinado a partir de los argumentos de tipo array proporcionados Array(T) Ejemplos Ejemplo de uso
Query
SELECT arrayElement(arr, 2) FROM (SELECT [1, 2, 3] AS arr)
Response
2
Indexación negativa
Query
SELECT arrayElement(arr, -1) FROM (SELECT [1, 2, 3] AS arr)
Response
3
Uso de la notación [n]
Query
SELECT arr[2] FROM (SELECT [1, 2, 3] AS arr)
Response
2
Índice fuera de rango del array
Query
SELECT arrayElement(arr, 4) FROM (SELECT [1, 2, 3] AS arr)
Response
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 
arrayElementOrNull(arrays)
Argumentos
  • arrays — Número arbitrario de argumentos de tipo array. Array
Valor devuelto Devuelve un único array que combina los argumentos de tipo array proporcionados. Array(T) Ejemplos Ejemplo de uso
Query
SELECT arrayElementOrNull(arr, 2) FROM (SELECT [1, 2, 3] AS arr)
Response
2
Índices negativos
Query
SELECT arrayElementOrNull(arr, -1) FROM (SELECT [1, 2, 3] AS arr)
Response
3
Índice fuera de rango del array
Query
SELECT arrayElementOrNull(arr, 4) FROM (SELECT [1, 2, 3] AS arr)
Response
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. 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 
arrayEnumerate(arr)
Argumentos
  • arr — El Array que se va a enumerar. Array
Valor devuelto Devuelve el Array [1, 2, 3, ..., length (arr)]. Array(UInt32) Ejemplos Ejemplo básico con ARRAY JOIN
Query
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
┌─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 
arrayEnumerateDense(arr)
Argumentos
  • arr — El array que se va a enumerar. Array(T)
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) Ejemplos Ejemplo de uso
Query
SELECT arrayEnumerateDense([10, 20, 10, 30])
Response
[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 
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*
  • arr — Array de N dimensiones que se va a enumerar. Array(T)
  • max_array_depth — La profundidad efectiva máxima. Debe ser menor o igual que la profundidad de arr. UInt*
Valor devuelto Devuelve un array que indica dónde aparece por primera vez cada elemento en el array de origen Array Ejemplos Uso básico
Query
-- 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
[1,2,1,3]
Uso con un array multidimensional
Query
-- 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
[[1,1,2,3],[4,5,1,2]]
Ejemplo con un clear_depth mayor
Query
-- 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
[[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 
arrayEnumerateUniq(arr1[, arr2, ... , arrN])
Argumentos
  • arr1 — Primer array que se va a procesar. Array(T)
  • arr2, ... — Opcional. Arrays adicionales del mismo tamaño para la unicidad de las tuplas. Array(UInt32)
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) Ejemplos Uso básico
Query
SELECT arrayEnumerateUniq([10, 20, 10, 30]);
Response
[1, 1, 2, 1]
Varios arrays
Query
SELECT arrayEnumerateUniq([1, 1, 1, 2, 2, 2], [1, 1, 2, 1, 1, 2]);
Response
[1,2,1,1,2,1]
Agregación con ARRAY JOIN
Query
-- 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
┌──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 
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*
  • arr — Array de N dimensiones que se va a enumerar. Array(T)
  • max_array_depth — La profundidad efectiva máxima. Entero positivo menor o igual que la profundidad de arr. 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) Ejemplos Ejemplo 1
Query
-- 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
[1, 1, 2]
Ejemplo 2
Query
-- 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
[1, 1, 2]
Ejemplo 3
Query
-- 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
[[1, 1, 1], [2, 3, 2], [2]]
Ejemplo 4
Query
-- 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
[[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 
arrayExcept(source, except)
Argumentos
  • source — El array de origen que contiene los elementos que se van a filtrar. Array(T)
  • except — El array que contiene los elementos que se excluirán del resultado. Array(T)
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) Ejemplos básico
Query
SELECT arrayExcept([1, 2, 3, 2, 4], [3, 5])
Response
[1, 2, 2, 4]
with_nulls1
Query
SELECT arrayExcept([1, NULL, 2, NULL], [2])
Response
[1, NULL, NULL]
with_nulls2
Query
SELECT arrayExcept([1, NULL, 2, NULL], [NULL, 2, NULL])
Response
[1]
cadenas
Query
SELECT arrayExcept(['apple', 'banana', 'cherry'], ['banana', 'date'])
Response
['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 
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
  • source_arr — El array de origen que se va a procesar. Array(T)
  • [, cond1_arr, ... , condN_arr] — Opcional. N arrays de condición que proporcionan argumentos adicionales a la función lambda. Array(T)
Valor devuelto Devuelve 1 si la función lambda devuelve true para al menos un elemento; en caso contrario, 0. UInt8 Ejemplos Ejemplo de uso
Query
SELECT arrayExists(x, y -> x=y, [1, 2, 3], [0, 0, 0])
Response
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 
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
  • source_arr — El array de origen que se va a procesar. función lambda
  • [, cond1_arr, ... , condN_arr] — Opcional. N arrays de condición que proporcionan argumentos adicionales a la función lambda. Array(T)
Valor devuelto Devuelve un array Array(T) Ejemplos Ejemplo con un solo array
Query
SELECT arrayFill(x -> not isNull(x), [1, null, 2, null]) AS res
Response
[1, 1, 2, 2]
Ejemplo con dos arrays
Query
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
[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 
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
  • source_arr — El array de origen que se va a procesar. Array(T)
  • [, cond1_arr, ... , condN_arr] — Opcional. N arrays de condición que proporcionan argumentos adicionales a la función lambda. Array(T)
Valor devuelto Devuelve un subconjunto del array de origen Array(T) Ejemplos Ejemplo 1
Query
SELECT arrayFilter(x -> x LIKE '%World%', ['Hello', 'abc World']) AS res
Response
['abc World']
Ejemplo 2
Query
SELECT
    arrayFilter(
        (i, x) -> x LIKE '%World%',
        arrayEnumerate(arr),
        ['Hello', 'abc World'] AS arr)
    AS res
Response
[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 
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. - source_arr — El array de origen que se va a procesar. Array(T). - [, cond1_arr, ... , condN_arr] — Opcional. N arrays de condición que proporcionan argumentos adicionales para la función lambda. Array(T).
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
Query
SELECT arrayFirst(x, y -> x=y, ['a', 'b', 'c'], ['c', 'b', 'a'])
Response
b
No hay coincidencias
Query
SELECT arrayFirst(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)
Response
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 
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. - source_arr — El array de origen que se va a procesar. Array(T). - [, cond1_arr, ... , condN_arr] — Opcional. N arrays de condición que proporcionan argumentos adicionales a la función lambda. Array(T).
Valor devuelto Devuelve el índice del primer elemento del array de origen para el que func es true; en caso contrario, devuelve 0 UInt32 Ejemplos Ejemplo de uso
Query
SELECT arrayFirstIndex(x, y -> x=y, ['a', 'b', 'c'], ['c', 'b', 'a'])
Response
2
Sin coincidencia
Query
SELECT arrayFirstIndex(x, y -> x=y, ['a', 'b', 'c'], ['d', 'e', 'f'])
Response
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 
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
  • source_arr — El array de origen que se va a procesar. Array(T)
  • [, cond1_arr, ... , condN_arr] — Opcional. N arrays de condición que proporcionan argumentos adicionales a la función lambda. Array(T)
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
Query
SELECT arrayFirstOrNull(x, y -> x=y, ['a', 'b', 'c'], ['c', 'b', 'a'])
Response
b
Sin coincidencias
Query
SELECT arrayFirstOrNull(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)
Response
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 
arrayFlatten(arr)
Alias: flatten Argumentos Valor devuelto Devuelve un array aplanado a partir del array multidimensional Array(T) Ejemplos Ejemplo de uso
Query
SELECT arrayFlatten([[[1]], [[2], [3]]]);
Response
[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 
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
  • arr1 [, arr2, arr3, ... arrN] — N arrays sobre los que se opera. Array(T)
  • 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
Query
SELECT arrayFold(acc,x -> acc + x*2, [1, 2, 3, 4], 3::Int64) AS res;
Response
23
Sucesión de Fibonacci
Query
SELECT arrayFold(acc, x -> (acc.2, acc.2 + acc.1),range(number),(1::Int64, 0::Int64)).1 AS fibonacci FROM numbers(1,10);
Response
┌─fibonacci─┐
│         0 │
│         1 │
│         1 │
│         2 │
│         3 │
│         5 │
│         8 │
│        13 │
│        21 │
│        34 │
└───────────┘
Ejemplo con varios arrays
Query
SELECT arrayFold(
(acc, x, y) -> acc + (x * y),
[1, 2, 3, 4],
[10, 20, 30, 40],
0::Int64
) AS res;
Response
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 
arrayIntersect(arr, arr1, ..., arrN)
Argumentos
  • arrN — N arrays con los que crear el nuevo array. Array(T).
Valor devuelto Devuelve un array con elementos distintos presentes en los N arrays Array(T) Ejemplos Ejemplo de uso
Query
SELECT
arrayIntersect([1, 2], [1, 3], [2, 3]) AS empty_intersection,
arrayIntersect([1, 2], [1, 3], [1, 4]) AS non_empty_intersection
Response
┌─empty_intersection─┬─non_empty_intersection─┐
│ []                 │ [1]                    │
└────────────────────┴────────────────────────┘

​
arrayJaccardIndex

Introducido en: v23.7.0 Devuelve el índice de Jaccard de dos arrays. Sintaxis 
arrayJaccardIndex(arr_x, arr_y)
Argumentos Valor devuelto Devuelve el índice de Jaccard entre arr_x y arr_y Float64 Ejemplos Ejemplo de uso
Query
SELECT arrayJaccardIndex([1, 2], [2, 3]) AS res
Response
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 
arrayJoin(arr)
Alias: unnest Argumentos
  • arr — Un array para expandir. Array(T)
Valor devuelto Devuelve un conjunto de filas obtenidas al expandir arr. Ejemplos Uso básico
Query
SELECT arrayJoin([1, 2, 3] AS src) AS dst, 'Hello', src
Response
┌─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
Query
-- 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
┌─impressions─┐
│           2 │
└─────────────┘
Uso de varias funciones arrayJoin
Query
- 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
┌─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
Query
-- 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
┌─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
Query
-- 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
┌─impressions─┬─city─────┬─browser─┐
│           1 │ Istanbul │ Firefox │
│           1 │ Berlin   │ Chrome  │
│           1 │ Bobruisk │ Chrome  │
└─────────────┴──────────┴─────────┘
Uso de Tuple
Query
-- 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
┌─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 
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. - source — El array de origen que se va a procesar. Array(T). - [, cond1, ... , condN] — Opcional. N arrays de condición que proporcionan argumentos adicionales a la función lambda. Array(T).
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
Query
SELECT arrayLast(x, y -> x=y, ['a', 'b', 'c'], ['a', 'b', 'c'])
Response
c
No hay coincidencias
Query
SELECT arrayFirst(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)
Response
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 
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
  • source_arr — El array de origen que se va a procesar. Array(T)
  • [, cond1_arr, ... , condN_arr] — Opcional. N arreglos de condición que proporcionan argumentos adicionales a la función lambda. Array(T)
Valor devuelto Devuelve el índice del último elemento del array de origen para el que func devuelve true; de lo contrario, devuelve 0 UInt32 Ejemplos Ejemplo de uso
Query
SELECT arrayLastIndex(x, y -> x=y, ['a', 'b', 'c'], ['a', 'b', 'c']);
Response
3
No hay coincidencias
Query
SELECT arrayLastIndex(x, y -> x=y, ['a', 'b', 'c'], ['d', 'e', 'f']);
Response
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 
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. - source_arr — El array de origen que se va a procesar. Array(T). - [, cond1_arr, ... , condN_arr] — Opcional. N arrays de condición que proporcionan argumentos adicionales a la función lambda. Array(T).
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
Query
SELECT arrayLastOrNull(x, y -> x=y, ['a', 'b', 'c'], ['a', 'b', 'c'])
Response
c
Sin coincidencias
Query
SELECT arrayLastOrNull(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)
Response
NULL Nullable(UInt8)

​
arrayLevenshteinDistance

Introducido en: v25.4.0 Calcula la distancia de Levenshtein entre dos arrays. Sintaxis 
arrayLevenshteinDistance(from, to)
Argumentos Valor devuelto Distancia de Levenshtein entre el primer y el segundo array. Float64 Ejemplos Ejemplo de uso
Query
SELECT arrayLevenshteinDistance([1, 2, 4], [1, 2, 3])
Response
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 
arrayLevenshteinDistanceWeighted(from, to, from_weights, to_weights)
Argumentos Valor devuelto Distancia de Levenshtein entre el primer y el segundo array con pesos personalizados para cada elemento Float64 Ejemplos Ejemplo de uso
Query
SELECT arrayLevenshteinDistanceWeighted(['A', 'B', 'C'], ['A', 'K', 'L'], [1.0, 2, 3], [3.0, 4, 5])
Response
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 
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
  • arr — N arrays para procesar. Array(T)
Valor devuelto Devuelve un array a partir de los resultados de la función lambda Array(T) Ejemplos Ejemplo de uso
Query
SELECT arrayMap(x -> (x + 2), [1, 2, 3]) as res;
Response
[3, 4, 5]
Crear una tupla de elementos de diferentes arrays
Query
SELECT arrayMap((x, y) -> (x, y), [1, 2, 3], [4, 5, 6]) AS res
Response
[(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 
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
  • source_arr — El array de origen que se va a procesar. Array(T)
  • [, cond1_arr, ... , condN_arr] — Opcional. N arrays de condición que proporcionan argumentos adicionales a la función lambda. Array(T)
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
Query
SELECT arrayMax([5, 3, 2, 7]);
Response
7
Uso con una función lambda
Query
SELECT arrayMax(x, y -> x/y, [4, 8, 12, 16], [1, 2, 1, 2]);
Response
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 
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
  • source_arr — El array de origen que se va a procesar. Array(T)
  • cond1_arr, ... — Opcional. N arrays de condición que proporcionan argumentos adicionales a la función lambda. Array(T)
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
Query
SELECT arrayMin([5, 3, 2, 7]);
Response
2
Uso con una función lambda
Query
SELECT arrayMin(x, y -> x/y, [4, 8, 12, 16], [1, 2, 1, 2]);
Response
4

​
arrayNormalizedGini

Introducido en: v25.1.0 Calcula el coeficiente de Gini normalizado. Sintaxis 
arrayNormalizedGini(predicted, label)
Argumentos 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) Ejemplos Ejemplo de uso
Query
SELECT arrayNormalizedGini([0.9, 0.3, 0.8, 0.7],[6, 1, 0, 2]);
Response
(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 
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
  • arr — Array que se va a ordenar. Array(T)
  • arr1, ... ,arrN — N arrays adicionales, en caso de que f acepte varios argumentos. Array(T)
  • limit — Valor de índice hasta el que se realizará la ordenación. (U)Int*
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
Query
SELECT arrayPartialReverseSort(2, [5, 9, 1, 3])
Response
[9, 5, 1, 3]
simple_string
Query
SELECT arrayPartialReverseSort(2, ['expenses','lasso','embolism','gladly'])
Response
['lasso','gladly','expenses','embolism']
retain_sorted
Query
SELECT arrayResize(arrayPartialReverseSort(2, [5, 9, 1, 3]), 2)
Response
[9, 5]
lambda_simple
Query
SELECT arrayPartialReverseSort((x) -> -x, 2, [5, 9, 1, 3])
Response
[1, 3, 5, 9]
lambda_complex
Query
SELECT arrayPartialReverseSort((x, y) -> -y, 1, [0, 1, 2], [1, 2, 3]) as res
Response
[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 completo.
Sintaxis 
arrayPartialShuffle(arr [, limit[, seed]])
Argumentos
  • arr — El array que se va a barajar. Array(T)
  • 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*
  • limit — Opcional. El número para limitar los intercambios de elementos, en el rango [1..N]. (U)Int*
Valor devuelto Array con elementos parcialmente barajados. Array(T) Ejemplos no_limit1
Query
SELECT arrayPartialShuffle([1, 2, 3, 4], 0)
Response
[2, 4, 3, 1]
no_limit2
Query
SELECT arrayPartialShuffle([1, 2, 3, 4])
Response
[4, 1, 3, 2]
random_seed
Query
SELECT arrayPartialShuffle([1, 2, 3, 4], 2)
Response
[3, 4, 1, 2]
explicit_seed
Query
SELECT arrayPartialShuffle([1, 2, 3, 4], 2, 41)
Response
[3, 2, 1, 4]
materializar
Query
SELECT arrayPartialShuffle(materialize([1, 2, 3, 4]), 2, 42), arrayPartialShuffle([1, 2, 3], 2, 42) FROM numbers(10)
Response
┌─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 
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
  • arr — Array que se va a ordenar. Array(T)
  • arr1, ... ,arrN — N arrays adicionales, en caso de que f acepte varios argumentos. Array(T)
  • limit — Valor de índice hasta el que se realizará la ordenación. (U)Int*
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
Query
SELECT arrayPartialSort(2, [5, 9, 1, 3])
Response
[1, 3, 5, 9]
simple_string
Query
SELECT arrayPartialSort(2, ['expenses', 'lasso', 'embolism', 'gladly'])
Response
['embolism', 'expenses', 'gladly', 'lasso']
retain_sorted
Query
SELECT arrayResize(arrayPartialSort(2, [5, 9, 1, 3]), 2)
Response
[1, 3]
lambda_simple
Query
SELECT arrayPartialSort((x) -> -x, 2, [5, 9, 1, 3])
Response
[9, 5, 1, 3]
lambda_complex
Query
SELECT arrayPartialSort((x, y) -> -y, 1, [0, 1, 2], [1, 2, 3]) as res
Response
[2, 1, 0]

​
arrayPopBack

Introducido en: v1.1.0 Elimina el último elemento del array. Sintaxis 
arrayPopBack(arr)
Argumentos
  • arr — El array al que se le eliminará el último elemento. Array(T)
Valor devuelto Devuelve un array idéntico a arr, pero sin su último elemento. Array(T) Ejemplos Ejemplo de uso
Query
SELECT arrayPopBack([1, 2, 3]) AS res;
Response
[1, 2]

​
arrayPopFront

Introducido en: v1.1.0 Elimina el primer elemento del array. Sintaxis 
arrayPopFront(arr)
Argumentos
  • arr — El array del que se elimina el primer elemento. Array(T)
Valor devuelto Devuelve un array idéntico a arr, pero sin el primer elemento de arr Array(T) Ejemplos Ejemplo de uso
Query
SELECT arrayPopFront([1, 2, 3]) AS res;
Response
[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 
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
  • source_arr — El array de origen que se va a procesar. Array(T)
  • [, cond1_arr, ... , condN_arr] — Opcional. N arrays de condición que proporcionan argumentos adicionales a la función lambda. Array(T)
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 Ejemplos Ejemplo básico
Query
SELECT arrayProduct([1, 2, 3, 4]);
Response
24
Uso con funciones lambda
Query
SELECT arrayProduct(x, y -> x+y, [2, 2], [2, 2]) AS res;
Response
16

​
arrayPushBack

Introducido en: v1.1.0 Añade un elemento al final del array. Sintaxis 
arrayPushBack(arr, x)
Argumentos
  • arr — El array al que se le añade el valor x al final. Array(T)
  • x —
  • Valor único que se añade al final del array. Array(T).
  • 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.
Valor devuelto Devuelve un array idéntico a arr, pero con un valor adicional x al final del array Array(T) Ejemplos Ejemplo de uso
Query
SELECT arrayPushBack(['a'], 'b') AS res;
Response
['a','b']

​
arrayPushFront

Introducido en: v1.1.0 Añade un elemento al principio del array. Sintaxis 
arrayPushFront(arr, x)
Argumentos
  • arr — El array al final del cual se añadirá el valor x. Array(T). - x —
  • Valor único que se añadirá al principio del array. Array(T).
  • 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.
Valor devuelto Devuelve un array idéntico a arr, pero con un valor adicional x al principio del array Array(T) Ejemplos Ejemplo de uso
Query
SELECT arrayPushFront(['b'], 'a') AS res;
Response
['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í, aquí y aquí. Sintaxis 
arrayROCAUC(scores, labels[, scale[, partial_offsets]])
Alias: arrayAUC Argumentos
  • scores — Puntuaciones proporcionadas por el modelo de predicción. Array((U)Int*) o Array(Float*)
  • labels — Etiquetas de las muestras, normalmente 1 para una muestra positiva y 0 para una muestra negativa. Array((U)Int*) o 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
  • 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 de Enteros 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 Ejemplos Ejemplo de uso
Query
SELECT arrayROCAUC([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1]);
Response
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 
arrayRandomSample(arr, samples)
Argumentos
  • arr — El array de entrada o array multidimensional del que se extraen los elementos de la muestra. Array(T)
  • samples — El número de elementos que se incluirán en la muestra aleatoria. (U)Int*
Valor devuelto Un array que contiene una muestra aleatoria de elementos del array de entrada Array(T) Ejemplos Ejemplo de uso
Query
SELECT arrayRandomSample(['apple', 'banana', 'cherry', 'date'], 2) as res;
Response
['cherry','apple']
Uso de un array multidimensional
Query
SELECT arrayRandomSample([[1, 2], [3, 4], [5, 6]], 2) as res;
Response
[[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 
arrayReduce(agg_f, arr1[, arr2, ... , arrN])
Argumentos
  • agg_f — El nombre de una función de agregación, que debe ser una constante. String
  • arr1[, arr2, ... , arrN] — N arrays correspondientes a los argumentos de agg_f. Array(T)
Valor devuelto Devuelve el resultado de la función de agregación Ejemplos Ejemplo de uso
Query
SELECT arrayReduce('max', [1, 2, 3]);
Response
┌─arrayReduce('max', [1, 2, 3])─┐
│                             3 │
└───────────────────────────────┘
Ejemplo con función de agregación que usa varios argumentos
Query
--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
┌─arrayReduce('maxIf', [3, 5], [1, 0])─┐
│                                    3 │
└──────────────────────────────────────┘
Ejemplo con una función de agregación paramétrica
Query
SELECT arrayReduce('uniqUpTo(3)', [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
Response
┌─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 
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
  • 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) o Tuple(T)
  • arr1[, arr2, ... ,arrN] — N arrays como argumentos de la función de agregación. Array(T)
Valor devuelto Devuelve un array que contiene los resultados de la función de agregación sobre los rangos especificados Array(T) Ejemplos Ejemplo de uso
Query
SELECT arrayReduceInRanges(
    'sum',
    [(1, 5), (2, 3), (3, 4), (4, 4)],
    [1000000, 200000, 30000, 4000, 500, 60, 7]
) AS res
Response
┌─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 
arrayRemove(arr, elem)
Alias: array_remove Argumentos
  • arr — Array(T) - elem — T
Valor devuelto Devuelve un subconjunto del array de entrada Array(T) Ejemplos Ejemplo 1
Query
SELECT arrayRemove([1, 2, 2, 3], 2)
Response
[1, 3]
Ejemplo 2
Query
SELECT arrayRemove(['a', NULL, 'b', NULL], NULL)
Response
['a', 'b']

​
arrayResize

Introducido en: v1.1.0 Cambia la longitud del array. Sintaxis 
arrayResize(arr, size[, extender])
Argumentos
  • arr — Array que se va a redimensionar. Array(T)
  • 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) Ejemplos Ejemplo 1
Query
SELECT arrayResize([1], 3);
Response
[1,0,0]
Ejemplo 2
Query
SELECT arrayResize([1], 3, NULL);
Response
[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 
arrayReverse(arr)
Argumentos
  • arr — El array que se va a invertir. Array(T)
Valor devuelto Devuelve un array del mismo tamaño que el original, con los elementos en orden inverso Array(T) Ejemplos Ejemplo de uso
Query
SELECT arrayReverse([1, 2, 3])
Response
[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 
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
  • source_arr — El array de origen que se va a procesar. Array(T)
  • [, cond1_arr, ... , condN_arr] — Opcional. N arrays de condición que proporcionan argumentos adicionales a la función lambda. Array(T)
Valor devuelto Devuelve un array en el que los elementos del array de origen se sustituyen por los resultados de la lambda. Array(T) Ejemplos Ejemplo con un solo array
Query
SELECT arrayReverseFill(x -> not isNull(x), [1, null, 2, null]) AS res
Response
[1, 2, 2, NULL]
Ejemplo con dos arrays
Query
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
[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. Sintaxis 
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) - 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). Ejemplos Ejemplo 1
Query
SELECT arrayReverseSort((x, y) -> y, [4, 3, 5], ['a', 'b', 'c']) AS res;
Response
[5,3,4]
Ejemplo 2
Query
SELECT arrayReverseSort((x, y) -> -y, [4, 3, 5], [1, 2, 3]) AS res;
Response
[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 
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
  • source_arr — El array de origen que se va a procesar. función lambda
  • [, cond1_arr, ... , condN_arr] — Opcional. N arrays de condición que proporcionan argumentos adicionales a la función lambda. Array(T)
Valor devuelto Devuelve un array de arrays. Array(Array(T)) Ejemplos Ejemplo de uso
Query
SELECT arrayReverseSplit((x, y) -> y, [1, 2, 3, 4, 5], [1, 0, 0, 1, 0]) AS res
Response
[[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 
arrayRotateLeft(arr, n)
Argumentos
  • arr — El array cuyos elementos se van a rotar.Array(T). - n — Número de elementos que se van a rotar. (U)Int8/16/32/64.
Valor devuelto Un array rotado a la izquierda en el número de elementos especificado Array(T) Ejemplos Ejemplo de uso
Query
SELECT arrayRotateLeft([1,2,3,4,5,6], 2) as res;
Response
[3,4,5,6,1,2]
Valor negativo de n
Query
SELECT arrayRotateLeft([1,2,3,4,5,6], -2) as res;
Response
[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 
arrayRotateRight(arr, n)
Argumentos Valor devuelto Un array rotado a la derecha en el número de elementos especificado Array(T) Ejemplos Ejemplo de uso
Query
SELECT arrayRotateRight([1,2,3,4,5,6], 2) as res;
Response
[5,6,1,2,3,4]
Valor negativo para n
Query
SELECT arrayRotateRight([1,2,3,4,5,6], -2) as res;
Response
[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 
arrayShiftLeft(arr, n[, default])
Argumentos
  • arr — El array cuyos elementos se desplazarán.Array(T). - n — Número de elementos que se desplazarán.(U)Int8/16/32/64. - default — Opcional. Valor predeterminado para los elementos nuevos.
Valor devuelto Un array desplazado a la izquierda el número especificado de elementos Array(T) Ejemplos Ejemplo de uso
Query
SELECT arrayShiftLeft([1,2,3,4,5,6], 2) as res;
Response
[3,4,5,6,0,0]
Cuando n es negativo
Query
SELECT arrayShiftLeft([1,2,3,4,5,6], -2) as res;
Response
[0,0,1,2,3,4]
Usar un valor predeterminado
Query
SELECT arrayShiftLeft([1,2,3,4,5,6], 2, 42) as res;
Response
[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 
arrayShiftRight(arr, n[, default])
Argumentos
  • arr — El array cuyos elementos se desplazarán. Array(T)
  • n — Número de elementos que se desplazarán. (U)Int8/16/32/64
  • default — Opcional. Valor predeterminado de los elementos nuevos.
Valor devuelto Un array desplazado a la derecha el número de elementos especificado Array(T) Ejemplos Ejemplo de uso
Query
SELECT arrayShiftRight([1, 2, 3, 4, 5, 6], 2) as res;
Response
[0, 0, 1, 2, 3, 4]
Valor negativo de n
Query
SELECT arrayShiftRight([1, 2, 3, 4, 5, 6], -2) as res;
Response
[3, 4, 5, 6, 0, 0]
Usar un valor predeterminado
Query
SELECT arrayShiftRight([1, 2, 3, 4, 5, 6], 2, 42) as res;
Response
[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 
arrayShingles(arr, l)
Argumentos
  • arr — Array a partir del cual se genera un array de shingles. Array(T)
  • l — La longitud de cada shingle. (U)Int*
Valor devuelto Un array de shingles generados Array(T) Ejemplos Ejemplo de uso
Query
SELECT arrayShingles([1, 2, 3, 4], 3) as res;
Response
[[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 
arrayShuffle(arr [, seed])
Argumentos
  • arr — El array que se va a barajar. Array(T)
  • 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*
Valor devuelto Array con los elementos barajados Array(T) Ejemplos Ejemplo sin semilla (resultados inestables)
Query
SELECT arrayShuffle([1, 2, 3, 4]);
Response
[1,4,2,3]
Ejemplo sin semilla (resultados estables)
Query
SELECT arrayShuffle([1, 2, 3, 4], 41);
Response
[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 
arraySimilarity(from, to, from_weights, to_weights)
Argumentos 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 Ejemplos Ejemplo de uso
Query
SELECT arraySimilarity(['A', 'B', 'C'], ['A', 'K', 'L'], [1.0, 2, 3], [3.0, 4, 5]);
Response
0.2222222222222222

​
arraySlice

Introducido en: v1.1.0 Devuelve una porción del array, incluidos los elementos NULL. Sintaxis 
arraySlice(arr, offset [, length])
Argumentos
  • arr — Array que se va a segmentar. Array(T)
  • 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*
  • 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*
Valor devuelto Devuelve un segmento del array con length elementos a partir del offset especificado Array(T) Ejemplos Ejemplo de uso
Query
SELECT arraySlice([1, 2, NULL, 4, 5], 2, 3) AS res;
Response
[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. Sintaxis 
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) - 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). Ejemplos Ejemplo 1
Query
SELECT arraySort([1, 3, 3, 0]);
Response
[0,1,3,3]
Ejemplo 2
Query
SELECT arraySort(['hello', 'world', '!']);
Response
['!','hello','world']
Ejemplo 3
Query
SELECT arraySort([1, nan, 2, NULL, 3, nan, -4, NULL, inf, -inf]);
Response
[-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 
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. - source_arr — El array de origen que se va a dividir Array(T). - [, cond1_arr, ... , condN_arr] — Opcional. N arrays de condición que proporcionan argumentos adicionales a la función lambda. Array(T).
Valor devuelto Devuelve un array de arrays Array(Array(T)) Ejemplos Ejemplo de uso
Query
SELECT arraySplit((x, y) -> y, [1, 2, 3, 4, 5], [1, 0, 0, 1, 0]) AS res
Response
[[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 
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
  • source_arr — El array de origen que se va a procesar. Array(T)
  • , cond1_arr, ... , condN_arr] — Opcional. N arrays de condición que proporcionan argumentos adicionales a la función lambda. Array(T)
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
Query
SELECT arraySum([1, 2, 3, 4]);
Response
10
Uso con una función lambda
Query
SELECT arraySum(x, y -> x+y, [1, 1, 1, 1], [1, 1, 1, 1]);
Response
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 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 
arraySymmetricDifference(arr1, arr2, ... , arrN)
Argumentos
  • arrN — N arrays a partir de las cuales se crea el nuevo array. Array(T).
Valor devuelto Devuelve un array de elementos distintos que no están presentes en todos los arrays de origen Array(T) Ejemplos Ejemplo de uso
Query
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
┌─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 
arrayTranspose(arr)
Argumentos
  • arr — Un array bidimensional para transponer. Todos los arrays internos deben tener la misma longitud. Array(Array(T))
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)) Ejemplos Matriz cuadrada
Query
SELECT arrayTranspose([[1, 2], [3, 4]])
Response
[[1, 3], [2, 4]]
Matriz no cuadrada
Query
SELECT arrayTranspose([[1, 2, 3], [4, 5, 6]])
Response
[[1, 4], [2, 5], [3, 6]]
Elementos de tipo String
Query
SELECT arrayTranspose([['a', 'b'], ['c', 'd']])
Response
[['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 
arrayUnion(arr1, arr2, ..., arrN)
Argumentos
  • arrN — N arrays a partir de las cuales se crea el nuevo array. Array(T)
Valor devuelto Devuelve un array con elementos distintos de los arrays de entrada Array(T) Ejemplos Ejemplo de uso
Query
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
┌─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 
arrayUniq(arr1[, arr2, ..., arrN])
Argumentos
  • arr1 — Array cuyo número de elementos únicos se va a contar. Array(T)
  • [, 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)
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 Ejemplos Argumento único
Query
SELECT arrayUniq([1, 1, 2, 2])
Response
2
Varios argumentos
Query
SELECT arrayUniq([1, 2, 3, 1], [4, 5, 6, 4])
Response
3

​
arrayWithConstant

Introducido en: v20.1.0 Crea un array de longitud length relleno con la constante x. Sintaxis 
arrayWithConstant(N, x)
Argumentos
  • length — Número de elementos del array. (U)Int*
  • 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) Ejemplos Ejemplo de uso
Query
SELECT arrayWithConstant(3, 1)
Response
[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 
arrayZip(arr1, arr2, ... , arrN)
Argumentos
  • arr1, arr2, ... , arrN — N arrays para combinar en un único array. Array(T)
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) Ejemplos Ejemplo de uso
Query
SELECT arrayZip(['a', 'b', 'c'], [5, 2, 1]);
Response
[('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 
arrayZipUnaligned(arr1, arr2, ..., arrN)
Argumentos
  • arr1, arr2, ..., arrN — N arrays para combinar en un solo array. Array(T)
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) o Tuple(T1, T2, ...) Ejemplos Ejemplo de uso
Query
SELECT arrayZipUnaligned(['a'], [1, 2, 3]);
Response
[('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 
countEqual(arr, x)
Argumentos
  • arr — Array en el que buscar. Array(T)
  • 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 Ejemplos Ejemplo de uso
Query
SELECT countEqual([1, 2, NULL, NULL], NULL)
Response
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. Con optimize_functions_to_subcolumns = 1, la función lee solo la subcolumna size0 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 
empty(arr)
Argumentos Valor devuelto Devuelve 1 para un array vacío o 0 para un array no vacío UInt8 Ejemplos Ejemplo de uso
Query
SELECT empty([]);
Response
1

​
emptyArrayDate

Introducido en: v1.1.0 Devuelve un array vacío de Date Sintaxis 
emptyArrayDate()
Argumentos
  • Ninguno.
Valor devuelto Un array de Date vacío. Array(T) Ejemplos Ejemplo de uso
Query
SELECT emptyArrayDate
Response
[]

​
emptyArrayDateTime

Introducido en: v1.1.0 Devuelve un array DateTime vacío Sintaxis 
emptyArrayDateTime()
Argumentos
  • Ninguno.
Valor devuelto Un array de DateTime vacío. Array(T) Ejemplos Ejemplo de uso
Query
SELECT emptyArrayDateTime
Response
[]

​
emptyArrayFloat32

Introducido en: v1.1.0 Devuelve un Array(Float32) vacío Sintaxis 
emptyArrayFloat32()
Argumentos
  • Ninguno.
Valor devuelto Un array vacío de Float32. Array(T) Ejemplos Ejemplo de uso
Query
SELECT emptyArrayFloat32
Response
[]

​
emptyArrayFloat64

Introducido en: v1.1.0 Devuelve un Array(Float64) vacío Sintaxis 
emptyArrayFloat64()
Argumentos
  • Ninguno.
Valor devuelto Un array vacío de Float64. Array(T) Ejemplos Ejemplo de uso
Query
SELECT emptyArrayFloat64
Response
[]

​
emptyArrayInt16

Introducido en: v1.1.0 Devuelve un array vacío de Int16 Sintaxis 
emptyArrayInt16()
Argumentos
  • Ninguno.
Valor devuelto Un array vacío de Int16. Array(T) Ejemplos Ejemplo de uso
Query
SELECT emptyArrayInt16
Response
[]

​
emptyArrayInt32

Introducido en: v1.1.0 Devuelve un array Int32 vacío Sintaxis 
emptyArrayInt32()
Argumentos
  • Ninguno.
Valor devuelto Un array vacío de Int32. Array(T) Ejemplos Ejemplo de uso
Query
SELECT emptyArrayInt32
Response
[]

​
emptyArrayInt64

Introducido en: v1.1.0 Devuelve un array Int64 vacío Sintaxis 
emptyArrayInt64()
Argumentos
  • Ninguno.
Valor devuelto Un array Int64 vacío. Array(T) Ejemplos Ejemplo de uso
Query
SELECT emptyArrayInt64
Response
[]

​
emptyArrayInt8

Introducido en: v1.1.0 Devuelve un array Int8 vacío Sintaxis 
emptyArrayInt8()
Argumentos
  • Ninguno.
Valor devuelto Un array de Int8 vacío. Array(T) Ejemplos Ejemplo de uso
Query
SELECT emptyArrayInt8
Response
[]

​
emptyArrayString

Introducido en: v1.1.0 Devuelve un array de String vacío Sintaxis 
emptyArrayString()
Argumentos
  • Ninguno.
Valor devuelto Un array vacío de String. Array(T) Ejemplos Ejemplo de uso
Query
SELECT emptyArrayString
Response
[]

​
emptyArrayToSingle

Introducido en: v1.1.0 Acepta un array vacío y devuelve un array de un solo elemento igual al valor predeterminado. Sintaxis 
emptyArrayToSingle(arr)
Argumentos Valor devuelto Un array con un único valor del tipo predeterminado del Array. Array(T) Ejemplos Ejemplo básico
Query
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
┌─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 
emptyArrayUInt16()
Argumentos
  • Ninguno.
Valor devuelto Un array vacío de UInt16. Array(T) Ejemplos Ejemplo de uso
Query
SELECT emptyArrayUInt16
Response
[]

​
emptyArrayUInt32

Introducido en: v1.1.0 Devuelve un array vacío de UInt32 Sintaxis 
emptyArrayUInt32()
Argumentos
  • Ninguno.
Valor devuelto Un array de UInt32 vacío. Array(T) Ejemplos Ejemplo de uso
Query
SELECT emptyArrayUInt32
Response
[]

​
emptyArrayUInt64

Introducido en: v1.1.0 Devuelve un Array de UInt64 vacío Sintaxis 
emptyArrayUInt64()
Argumentos
  • Ninguno.
Valor devuelto Un array vacío de UInt64. Array(T) Ejemplos Ejemplo de uso
Query
SELECT emptyArrayUInt64
Response
[]

​
emptyArrayUInt8

Introducido en: v1.1.0 Devuelve un Array vacío de UInt8 Sintaxis 
emptyArrayUInt8()
Argumentos
  • Ninguno.
Valor devuelto Un array vacío de UInt8. Array(T) Ejemplos Ejemplo de uso
Query
SELECT emptyArrayUInt8
Response
[]

​
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 
has(haystack, needle)
Argumentos
  • haystack — El array, mapa o JSON de origen. Array o Map o JSON
  • 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 Ejemplos Uso básico de mapa
Query
SELECT has([1, 2, 3], 2)
Response
1
Array no encontrado
Query
SELECT has([1, 2, 3], 4)
Response
0
Uso básico de mapa
Query
SELECT has(map('a', 1, 'b', 2), 'b')
Response
1
Ruta JSON
Query
SELECT has('{"a": {"b": 1}}'::JSON, 'a.b')
Response
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 
hasAll(set, subset)
Argumentos
  • set — Array de cualquier tipo con elementos. Array(T)
  • 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)
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
Query
SELECT hasAll([], [])
Response
1
Arrays con valores NULL
Query
SELECT hasAll([1, Null], [Null])
Response
1
Arrays que contienen valores de distinto tipo
Query
SELECT hasAll([1.0, 2, 3, 4], [1, 3])
Response
1
Arrays que contienen valores String
Query
SELECT hasAll(['a', 'b'], ['a'])
Response
1
Arrays sin tipo común
Query
SELECT hasAll([1], ['a'])
Response
Lanza una excepción NO_COMMON_TYPE
Array de arrays
Query
SELECT hasAll([[1, 2], [3, 4]], [[1, 2], [3, 5]])
Response
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 
hasAny(arr_x, arr_y)
Argumentos
  • arr_x — Array de cualquier tipo que contiene un conjunto de elementos. Array(T)
  • arr_y — Array de cualquier tipo que comparte un supertipo común con el array arr_x. Array(T)
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
Query
SELECT hasAny([1], [])
Response
0
Arrays con valores NULL
Query
SELECT hasAny([Null], [Null, 1])
Response
1
Arrays con valores de distinto tipo
Query
SELECT hasAny([-128, 1., 512], [1])
Response
1
Arrays sin un tipo común
Query
SELECT hasAny([[1, 2], [3, 4]], ['a', 'c'])
Response
Lanza una excepción `NO_COMMON_TYPE`
Array de Array
Query
SELECT hasAll([[1, 2], [3, 4]], [[1, 2], [1, 2]])
Response
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 
hasSubstr(arr1, arr2)
Argumentos
  • arr1 — Array de cualquier tipo con un conjunto de elementos. Array(T)
  • arr2 — Array de cualquier tipo con un conjunto de elementos. Array(T)
Valor devuelto Devuelve 1 si arr1 contiene arr2. De lo contrario, devuelve 0. UInt8 Ejemplos Ambos arrays están vacíos
Query
SELECT hasSubstr([], [])
Response
1
Arrays con valores NULL
Query
SELECT hasSubstr([1, Null], [Null])
Response
1
Arrays con valores de distinto tipo
Query
SELECT hasSubstr([1.0, 2, 3, 4], [1, 3])
Response
0
Arrays de cadenas
Query
SELECT hasSubstr(['a', 'b'], ['a'])
Response
1
Arrays con orden válido
Query
SELECT hasSubstr(['a', 'b' , 'c'], ['a', 'b'])
Response
1
Arrays con un orden no válido
Query
SELECT hasSubstr(['a', 'b' , 'c'], ['a', 'c'])
Response
0
Array de arrays
Query
SELECT hasSubstr([[1, 2], [3, 4], [5, 6]], [[1, 2], [3, 4]])
Response
1
Arrays sin tipo común
Query
SELECT hasSubstr([1, 2, NULL, 3, 4], ['a'])
Response
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 
indexOf(arr, x)
Argumentos
  • arr — Un array en el que buscar x. Array(T)
  • x — Valor del primer elemento coincidente de arr cuyo índice se debe devolver. UInt64
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 Ejemplos Ejemplo básico
Query
SELECT indexOf([5, 4, 1, 3], 3)
Response
4
Array con NULL
Query
SELECT indexOf([1, 3, NULL, NULL], NULL)
Response
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 
indexOfAssumeSorted(arr, x)
Argumentos
  • arr — Un array ordenado en el que buscar. Array(T)
  • x — Valor del primer elemento coincidente de arr ordenado cuyo índice se debe devolver. UInt64
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 Ejemplos Ejemplo básico
Query
SELECT indexOfAssumeSorted([1, 3, 3, 3, 4, 4, 5], 4)
Response
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 
kql_array_sort_asc(array1[, array2, ..., nulls_last])
Argumentos
  • array1 — El array que se va a ordenar. Array(T)
  • array2 — Opcional. Arrays adicionales que se reordenarán según el orden de array1. Array(T)
  • nulls_last — Opcional. Un valor booleano que indica si los valores nulos deben aparecer al final. El valor predeterminado es true. UInt8
Valor devuelto Devuelve una tupla de arrays ordenados en orden ascendente. Tuple(Array, ...) Ejemplos Uso básico
Query
SELECT kql_array_sort_asc([3, 1, 2])
Response
([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 
kql_array_sort_desc(array1[, array2, ..., nulls_last])
Argumentos
  • array1 — El array que se va a ordenar. Array(T)
  • array2 — Arrays adicionales opcionales que se reordenan según el orden de clasificación de array1. Array(T)
  • nulls_last — Booleano opcional que indica si los valores NULL deben aparecer al final. El valor predeterminado es true. UInt8
Valor devuelto Devuelve una tupla de arrays ordenados en orden descendente. Tuple(Array, ...) Ejemplos Uso básico
Query
SELECT kql_array_sort_desc([3, 1, 2])
Response
([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 
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 o FixedString o Array(T)
Valor devuelto Devuelve el número de bytes de la String/FixedString x / el número de elementos del Array x UInt64 Ejemplos Ejemplo de String
Query
SELECT length('Hello, world!')
Response
13
Ejemplo de Array
Query
SELECT length(['Hello', 'world'])
Response
2
ejemplo de constexpr
Query
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
┌─str────┬─str_length_is_constant─┬─fixed_str_length_is_constant─┐
│ hello0 │                      0 │                            1 │
│ hello1 │                      0 │                            1 │
│ hello2 │                      0 │                            1 │
└────────┴────────────────────────┴──────────────────────────────┘
ejemplo de Unicode
Query
SELECT 'ёлка' AS str1, length(str1), lengthUTF8(str1), normalizeUTF8NFKD(str1) AS str2, length(str2), lengthUTF8(str2)
Response
┌─str1─┬─length(str1)─┬─lengthUTF8(str1)─┬─str2─┬─length(str2)─┬─lengthUTF8(str2)─┐
│ ёлка │            8 │                4 │ ёлка │           10 │                5 │
└──────┴──────────────┴──────────────────┴──────┴──────────────┴──────────────────┘
Ejemplo de ascii_vs_utf8
Query
SELECT 'ábc' AS str, length(str), lengthUTF8(str)
Response
┌─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. Con optimize_functions_to_subcolumns = 1, la función lee solo la subcolumna size0 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 
notEmpty(arr)
Argumentos Valor devuelto Devuelve 1 para un array no vacío o 0 para un array vacío UInt8 Ejemplos Ejemplo de uso
Query
SELECT notEmpty([1,2]);
Response
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.
  • 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 
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) Ejemplos Ejemplo de uso
Query
SELECT range(5), range(1, 5), range(1, 5, 2), range(-1, 5, 2);
Response
┌─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 
replicate(x, arr)
Argumentos
  • x — El valor con el que rellenar el array de resultados. Any
  • arr — Un array. Array(T)
Valor devuelto Devuelve un array de la misma longitud que arr, relleno con el valor x. Array(T) Ejemplos Ejemplo de uso
Query
SELECT replicate(1, ['a', 'b', 'c']);
Response
┌─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 
reverse(arr | str)
Argumentos Valor devuelto Devuelve un array o una cadena con el orden de los elementos o los caracteres invertido. Ejemplos Invertir un array
Query
SELECT reverse([1, 2, 3, 4]);
Response
[4, 3, 2, 1]
Invertir una cadena
Query
SELECT reverse('abcd');
Response
'dcba'

​
Funciones de distancia

Todas las funciones compatibles se describen en la documentación sobre funciones de distancia.
Última modificación el 10 de junio de 2026