Funciones de arrays

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

SELECT array(toInt32(1), toUInt16(2), toInt8(3)) AS a, toTypeName(a)

┌─a───────┬─toTypeName(a)─┐
│ [1,2,3] │ Array(Int32)  │
└─────────┴───────────────┘

Uso incorrecto

SELECT array(toInt32(5), toDateTime('1998-06-16'), toInt8(5)) AS a, toTypeName(a)

┌─a───────────────────────────┬─toTypeName(a)─────────────────────────┐
│ [5,'1998-06-16 00:00:00',5] │ Array(Variant(DateTime, Int32, Int8)) │
└─────────────────────────────┴───────────────────────────────────────┘

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.

Valor devuelto

Devuelve el área bajo la curva de precisión-exhaustividad (PR). Float64

Ejemplos

Ejemplo de uso

SELECT arrayAUCPR([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1]);

┌─arrayAUCPR([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1])─┐
│                              0.8333333333333333 │
└─────────────────────────────────────────────────┘

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

SELECT arrayAll(x, y -> x=y, [1, 2, 3], [1, 2, 3])

1

No todos los elementos coinciden

SELECT arrayAll(x, y -> x=y, [1, 2, 3], [1, 1, 1])

0

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

SELECT arrayAutocorrelation([1, 2, 3, 4, 5]);

[1,0.4,-0.1,-0.4,-0.4]

Simétrica

SELECT arrayAutocorrelation([10, 20, 10]);

[1,-0.6666666666666669,0.16666666666666674]

Constante

SELECT arrayAutocorrelation([5, 5, 5]);

[nan,nan,nan]

Limitado

SELECT arrayAutocorrelation([1, 2, 3, 4, 5], 2);

[1,0.4]

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

SELECT arrayAvg([1, 2, 3, 4]);

2.5

Uso con una función lambda

SELECT arrayAvg(x, y -> x*y, [2, 3], [2, 3]) AS res;

6.5

Introducido en: v26.6.0

Devuelve un array con los K elementos más pequeños del array de entrada, ordenados en orden ascendente. Si se especifica una función lambda f, los elementos se comparan según el resultado de aplicar f a cada elemento. Si f acepta varios argumentos, se pasan arrays adicionales a arrayBottomK; sus elementos se corresponden con los argumentos de f.

Los valores NULL se omiten y no aparecen en el resultado. El tamaño del resultado es como máximo K y puede ser menor cuando el array de entrada contiene menos elementos distintos de NULL que K. El tipo de elemento del resultado es la variante no Nullable del tipo de elemento de entrada.

arrayBottomK es una función de orden superior.

Véase también:

• arrayTopK, que devuelve en su lugar los K elementos más grandes.
• arrayPartialSort, que produce los mismos K elementos en las posiciones [1..K], pero también mantiene los elementos restantes en un orden no especificado y no omite los valores NULL.

Sintaxis

arrayBottomK([f,] K, arr [, arr1, ... ,arrN])

Argumentos

• f(arr[, arr1, ... ,arrN]) — Opcional. Una función lambda para calcular la clave de ordenación de cada elemento. Función lambda
• K — El número de elementos más pequeños que se devolverán. (U)Int8/16/32/64
• arr — Un array. Array(T)
• arr1, ... ,arrN — N arrays adicionales, en caso de que f acepte varios argumentos. Array(T)

Valor devuelto

Devuelve hasta K elementos de arr con los valores más pequeños (o con los menores resultados de la función lambda), ordenados de forma ascendente. Se omiten los valores NULL. El array devuelto tiene tipo de elemento T incluso cuando la entrada es de tipo Nullable(T).

Ejemplos

simple_int

SELECT arrayBottomK(3, [1, 5, 2, 7, 3])

[1,2,3]

skip_nulls

SELECT arrayBottomK(3, [1, NULL, 5, 2, NULL, 7])

[1,2,5]

fewer_than_k

SELECT arrayBottomK(5, [1, NULL, 2])

[1,2]

lambda_simple

SELECT arrayBottomK((x) -> -x, 2, [5, 9, 1, 3])

[9,5]

lambda_multi

SELECT arrayBottomK((x, y) -> y, 2, ['a', 'b', 'c'], [3, 1, 2])

['b','c']

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

SELECT arrayCompact([1, 1, nan, nan, 2, 3, 3, 3]);

[1,nan,2,3]

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

SELECT arrayConcat([1, 2], [3, 4], [5, 6]) AS res

[1,2,3,4,5,6]

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

SELECT arrayCount(x -> (x % 2), groupArray(number)) FROM numbers(10)

5

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

SELECT arrayCumSum([1, 1, 1, 1]) AS res

[1,2,3,4]

Con una función lambda

SELECT arrayCumSum(x -> x * 2, [1, 2, 3]) AS res

[2,6,12]

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

SELECT arrayCumSumNonNegative([1, 1, -4, 1]) AS res

[1,2,0,1]

Con una lambda

SELECT arrayCumSumNonNegative(x -> x * 2, [1, -2, 3]) AS res

[2,0,6]

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

SELECT arrayDifference([1, 2, 3, 4]);

[0,1,1,1]

Ejemplo de desbordamiento por el tipo de resultado Int64

SELECT arrayDifference([0, 10000000000000000000]);

┌─arrayDifference([0, 10000000000000000000])─┐
│ [0,-8446744073709551616]                   │
└────────────────────────────────────────────┘

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

SELECT arrayDistinct([1, 2, 2, 3, 1]);

[1,2,3]

Introducido en: v23.5.0

Devuelve el producto escalar de dos arrays.

Sintaxis

arrayDotProduct(v1, v2)

Argumentos

• v1 — Primer vector. Array((U)Int* | Float* | BFloat16 | Decimal) o Tuple((U)Int* | Float* | Decimal)
• v2 — Segundo vector. Array((U)Int* | Float* | BFloat16 | Decimal) o Tuple((U)Int* | Float* | Decimal)

Valor devuelto

El producto escalar de ambos vectores.

(U)Int* o Float* o Decimal

Ejemplos

Ejemplo de Array

SELECT arrayDotProduct([1, 2, 3], [4, 5, 6]) AS res, toTypeName(res);

32	UInt16

Ejemplo de Tuple

SELECT dotProduct((1::UInt16, 2::UInt8, 3::Float32),(4::Int16, 5::Float32, 6::UInt8)) AS res, toTypeName(res);

32	Float64

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.

Cuando n es un array de enteros, devuelve un array con los elementos en las posiciones especificadas (una operación de recopilación). Esto equivale a arrayMap(i -> arr[i], n), pero cuenta con una implementación independiente y más eficiente. Las posiciones fuera de los límites producen el valor predeterminado, igual que para un índice escalar. Los elementos del índice pueden ser Nullable. Un índice NULL produce NULL (y hace que el tipo de elemento resultante sea Nullable) cuando el tipo de elemento puede envolverse en Nullable; para los tipos de elemento que no pueden estar dentro de Nullable (como Array, Map), un índice NULL produce el valor predeterminado en su lugar. Este es el mismo comportamiento que para un índice escalar NULL.

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.

El primer argumento también puede ser un QBit: el n-ésimo elemento del vector se reconstruye con la precisión completa del tipo de elemento de QBit, leyendo solo los planos de bits del grupo de stride que lo contiene.

Sintaxis

arrayElement(arr, n)

Argumentos

• arr — El array en el que se busca. Array(T) o QBit. - n — Posición del elemento que se quiere obtener o un array de posiciones. Las posiciones pueden ser Nullable. (U)Int* o Array((U)Int*).

Valor devuelto

Cuando n es un escalar, devuelve el elemento de tipo T. Cuando n es un array, devuelve Array(Nullable(T)) si los elementos del índice pueden ser Nullable y T puede envolverse en Nullable; de lo contrario, devuelve Array(T). Any o Array(T) o Array(Nullable(T))

Ejemplos

Ejemplo de uso

SELECT arrayElement(arr, 2) FROM (SELECT [1, 2, 3] AS arr)

2

Indexación negativa

SELECT arrayElement(arr, -1) FROM (SELECT [1, 2, 3] AS arr)

3

Uso de la notación [n]

SELECT arr[2] FROM (SELECT [1, 2, 3] AS arr)

2

Índice fuera de rango del array

SELECT arrayElement(arr, 4) FROM (SELECT [1, 2, 3] AS arr)

0

Array de índices

SELECT [10, 20, 30, 40][[2, 4, 1]]

[20,40,10]

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, siempre que el tipo de resultado pueda ser Nullable. Para los tipos de elementos que no son Nullable y no pueden incluirse dentro de Nullable (como Array, Map), se devuelve en su lugar el valor predeterminado del tipo de elemento.

Cuando n es un array de enteros, devuelve un array con los elementos de las posiciones especificadas. Esto equivale a arrayMap(i -> arrayElementOrNull(arr, i), n), pero tiene una implementación independiente y más eficiente. Las posiciones fuera de los límites y los índices NULL producen valores NULL en el array resultante, siguiendo la misma regla que para un índice escalar.

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(arr, n)

Argumentos

• arr — El array en el que buscar. Array(T). - n — Posición del elemento que se desea obtener o un array de posiciones. Las posiciones pueden ser Nullable. (U)Int* o Array((U)Int*).

Valor devuelto

Cuando n es un escalar, devuelve Nullable(T) si T puede envolverse en Nullable; de lo contrario, T. Cuando n es un array, devuelve Array(Nullable(T)) si T puede envolverse en Nullable; de lo contrario, Array(T). Any o Nullable(T) o Array(T) o Array(Nullable(T))

Ejemplos

Ejemplo de uso

SELECT arrayElementOrNull(arr, 2) FROM (SELECT [1, 2, 3] AS arr)

2

Indexación negativa

SELECT arrayElementOrNull(arr, -1) FROM (SELECT [1, 2, 3] AS arr)

3

Índice fuera de rango del array

SELECT arrayElementOrNull(arr, 4) FROM (SELECT [1, 2, 3] AS arr)

\N

Array de índices

SELECT arrayElementOrNull([10, 20, 30], [1, 5, 2])

[10,NULL,20]

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

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

┌─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 │
└────┴────────────────┴─────────────┴─────┘

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

SELECT arrayEnumerateDense([10, 20, 10, 30])

[1,2,1,3]

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

-- With clear_depth=1 and max_array_depth=1, the result is identical to what arrayEnumerateDense would give.

SELECT arrayEnumerateDenseRanked(1,[10, 20, 10, 30],1);

[1,2,1,3]

Uso con un array multidimensional

-- In this example, arrayEnumerateDenseRanked is used to obtain an array indicating, for each element of the
-- multidimensional array, what its position is among elements of the same value.
-- For the first row of the passed array, [10, 10, 30, 20], the corresponding first row of the result is [1, 1, 2, 3],
-- indicating that 10 is the first number encountered in position 1 and 2, 30 the second number encountered in position 3
-- and 20 is the third number encountered in position 4.
-- For the second row, [40, 50, 10, 30], the corresponding second row of the result is [4,5,1,2], indicating that 40
-- and 50 are the fourth and fifth numbers encountered in position 1 and 2 of that row, that another 10
-- (the first encountered number) is in position 3 and 30 (the second number encountered) is in the last position.

SELECT arrayEnumerateDenseRanked(1,[[10,10,30,20],[40,50,10,30]],2);

[[1,1,2,3],[4,5,1,2]]

Ejemplo con un clear_depth mayor

-- Changing clear_depth=2 results in the enumeration occurring separately for each row anew.

SELECT arrayEnumerateDenseRanked(2,[[10,10,30,20],[40,50,10,30]],2);

[[1,1,2,3],[1,2,3,4]]

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

SELECT arrayEnumerateUniq([10, 20, 10, 30]);

[1,1,2,1]

Varios arrays

SELECT arrayEnumerateUniq([1, 1, 1, 2, 2, 2], [1, 1, 2, 1, 1, 2]);

[1,2,1,1,2,1]

Agregación con ARRAY JOIN

-- Each goal ID has a calculation of the number of conversions (each element in the Goals nested data structure is a goal that was reached, which we refer to as a conversion)
-- and the number of sessions. Without ARRAY JOIN, we would have counted the number of sessions as sum(Sign). But in this particular case,
-- the rows were multiplied by the nested Goals structure, so in order to count each session one time after this, we apply a condition to the
-- value of the arrayEnumerateUniq(Goals.ID) function.

CREATE TABLE visits (CounterID UInt32, Sign Int8, Goals Nested(ID UInt32)) ENGINE = Memory;

INSERT INTO visits VALUES
    (160656, 1, [53225, 53225, 56600]),
    (160656, 1, [53225, 2825062]),
    (160656, 1, [56600, 56600, 2825062]),
    (160657, 1, [53225]);

SELECT
    Goals.ID AS GoalID,
    sum(Sign) AS Reaches,
    sumIf(Sign, num = 1) AS Visits
FROM visits
ARRAY JOIN
    Goals,
    arrayEnumerateUniq(Goals.ID) AS num
WHERE CounterID = 160656
GROUP BY GoalID
ORDER BY Reaches DESC, GoalID
LIMIT 10

┌──GoalID─┬─Reaches─┬─Visits─┐
│   53225 │       3 │      2 │
│   56600 │       3 │      2 │
│ 2825062 │       2 │      2 │
└─────────┴─────────┴────────┘

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

-- With clear_depth=1 and max_array_depth=1, the result of arrayEnumerateUniqRanked
-- is identical to that which arrayEnumerateUniq would give for the same array.

SELECT arrayEnumerateUniqRanked(1, [1, 2, 1], 1);

[1,1,2]

Ejemplo 2

-- with clear_depth=1 and max_array_depth=1, the result of arrayEnumerateUniqRanked
-- is identical to that which arrayEnumerateUniqwould give for the same array.

SELECT arrayEnumerateUniqRanked(1, [[1, 2, 3], [2, 2, 1], [3]], 2);

[[1,1,1],[2,3,2],[2]]

Ejemplo 3

-- In this example, arrayEnumerateUniqRanked is used to obtain an array indicating,
-- for each element of the multidimensional array, what its position is among elements
-- of the same value. For the first row of the passed array, [1, 2, 3], the corresponding
-- result is [1, 1, 1], indicating that this is the first time 1, 2 and 3 are encountered.
-- For the second row of the provided array, [2, 2, 1], the corresponding result is [2, 3, 3],
-- indicating that 2 is encountered for a second and third time, and 1 is encountered
-- for the second time. Likewise, for the third row of the provided array [3] the
-- corresponding result is [2] indicating that 3 is encountered for the second time.

SELECT arrayEnumerateUniqRanked(1, [[1, 2, 3], [2, 2, 1], [3]], 2);

[[1,1,1],[2,3,2],[2]]

Ejemplo 4

-- Changing clear_depth=2, results in elements being enumerated separately for each row.
SELECT arrayEnumerateUniqRanked(2,[[1, 2, 3],[2, 2, 1],[3]], 2);

[[1,1,1],[1,2,1],[1]]

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

SELECT arrayExcept([1, 2, 3, 2, 4], [3, 5])

[1,2,2,4]

with_nulls1

SELECT arrayExcept([1, NULL, 2, NULL], [2])

[1,NULL,NULL]

with_nulls2

SELECT arrayExcept([1, NULL, 2, NULL], [NULL, 2, NULL])

[1]

cadenas

SELECT arrayExcept(['apple', 'banana', 'cherry'], ['banana', 'date'])

['apple','cherry']

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

SELECT arrayExists(x, y -> x=y, [1, 2, 3], [0, 0, 0])

0

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

SELECT arrayFill(x -> not isNull(x), [1, null, 2, null]) AS res

[1,1,2,2]

Ejemplo con dos arrays

SELECT arrayFill(x, y, z -> x > y AND x < z, [5, 3, 6, 2], [4, 7, 1, 3], [10, 2, 8, 5]) AS res

[5,5,6,6]

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

SELECT arrayFilter(x -> x LIKE '%World%', ['Hello', 'abc World']) AS res

['abc World']

Ejemplo 2

SELECT
    arrayFilter(
        (i, x) -> x LIKE '%World%',
        arrayEnumerate(arr),
        ['Hello', 'abc World'] AS arr)
    AS res

[2]

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 predeterminado.

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

SELECT arrayFirst(x, y -> x=y, ['a', 'b', 'c'], ['c', 'b', 'a'])

b

No hay coincidencias

SELECT arrayFirst(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)

0	UInt8

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

SELECT arrayFirstIndex(x, y -> x=y, ['a', 'b', 'c'], ['c', 'b', 'a'])

2

Sin coincidencia

SELECT arrayFirstIndex(x, y -> x=y, ['a', 'b', 'c'], ['d', 'e', 'f'])

0

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

SELECT arrayFirstOrNull(x, y -> x=y, ['a', 'b', 'c'], ['c', 'b', 'a'])

b

Sin coincidencias

SELECT arrayFirstOrNull(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)

\N	Nullable(UInt8)

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

• arr — Un array multidimensional. Array(Array(T))

Valor devuelto

Devuelve un array aplanado a partir del array multidimensional Array(T)

Ejemplos

Ejemplo de uso

SELECT arrayFlatten([[[1]], [[2], [3]]]);

[1,2,3]

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(λ

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

SELECT arrayFold(acc,x -> acc + x*2, [1, 2, 3, 4], 3::Int64) AS res;

23

Sucesión de Fibonacci

SELECT arrayFold(acc, x -> (acc.2, acc.2 + acc.1),range(number),(1::Int64, 0::Int64)).1 AS fibonacci FROM numbers(1,10);

┌─fibonacci─┐
│         0 │
│         1 │
│         1 │
│         2 │
│         3 │
│         5 │
│         8 │
│        13 │
│        21 │
│        34 │
└───────────┘

Ejemplo con varios arrays

SELECT arrayFold(
(acc, x, y) -> acc + (x * y),
[1, 2, 3, 4],
[10, 20, 30, 40],
0::Int64
) AS res;

300

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

SELECT
arrayIntersect([1, 2], [1, 3], [2, 3]) AS empty_intersection,
arrayIntersect([1, 2], [1, 3], [1, 4]) AS non_empty_intersection

┌─empty_intersection─┬─non_empty_intersection─┐
│ []                 │ [1]                    │
└────────────────────┴────────────────────────┘

Introducido en: v23.7.0

Devuelve el índice de Jaccard de dos arrays.

Sintaxis

arrayJaccardIndex(arr_x, arr_y)

Argumentos

• arr_x — Primer array. Array(T)
• arr_y — Segundo array. Array(T)

Valor devuelto

Devuelve el índice de Jaccard entre arr_x y arr_y Float64

Ejemplos

Ejemplo de uso

SELECT arrayJaccardIndex([1, 2], [2, 3]) AS res

0.3333333333333333

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.

unnest (desde la versión 26.5) es un alias de arrayJoin que no distingue entre mayúsculas y minúsculas en forma de llamada a función (SELECT unnest(arr)). La sintaxis de PostgreSQL para fuentes de tabla no es compatible (FROM unnest(...), CROSS JOIN UNNEST(...) y LATERAL). Use la cláusula ARRAY JOIN para esas consultas.

arrayJoin, incluso mediante su alias unnest, no se puede usar en una condición JOIN ON que se evalúe durante la unión, ya que dicha condición debe preservar el número de filas. Una condición que se aplica solo a un lado y una clave de igualdad basada en arrayJoin se extraen antes de la unión y no se ven afectadas. Una condición no disyuntiva de ALL INNER JOIN tampoco se ve afectada, porque en ese caso la condición se aplica después de la unión. Cuando la expansión depende de un solo lado, muévala a un ARRAY JOIN en una subconsulta antes de la unión; una condición cuyo argumento de arrayJoin hace referencia a columnas de ambos lados debe reestructurarse.

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

SELECT arrayJoin([1, 2, 3] AS src) AS dst, 'Hello', src

┌─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

-- The arrayJoin function affects all sections of the query, including the WHERE section. Notice the result 2, even though the subquery returned 1 row.

SELECT sum(1) AS impressions
FROM
(
    SELECT ['Istanbul', 'Berlin', 'Bobruisk'] AS cities
)
WHERE arrayJoin(cities) IN ['Istanbul', 'Berlin'];

┌─impressions─┐
│           2 │
└─────────────┘

Uso de varias funciones arrayJoin

-- A query can use multiple arrayJoin functions. In this case, the transformation is performed multiple times and the rows are multiplied.

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
ORDER BY
    city,
    browser

┌─impressions─┬─city─────┬─browser─┐
│           2 │ Berlin   │ Chrome  │
│           1 │ Berlin   │ Firefox │
│           2 │ Bobruisk │ Chrome  │
│           1 │ Bobruisk │ Firefox │
│           2 │ Istanbul │ Chrome  │
│           1 │ Istanbul │ Firefox │
└─────────────┴──────────┴─────────┘

Resultados inesperados debido a optimizaciones

-- Using multiple arrayJoin with the same expression may not produce the expected result due to optimizations.
-- For these cases, consider modifying the repeated array expression with extra operations that do not affect join result.
-- e.g. arrayJoin(arraySort(arr)), arrayJoin(arrayConcat(arr, []))

SELECT
    arrayJoin(dice) as first_throw,
    /* arrayJoin(dice) as second_throw */ -- is technically correct, but will annihilate result set
    arrayJoin(arrayConcat(dice, [])) as second_throw -- intentionally changed expression to force re-evaluation
FROM (
    SELECT [1, 2, 3, 4, 5, 6] as dice
);

┌─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

-- Note the ARRAY JOIN syntax in the `SELECT` query below, which provides broader possibilities.
-- ARRAY JOIN allows you to convert multiple arrays with the same number of elements at a time.

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
ORDER BY
    2,
    3

┌─impressions─┬─city─────┬─browser─┐
│           1 │ Berlin   │ Chrome  │
│           1 │ Bobruisk │ Chrome  │
│           1 │ Istanbul │ Firefox │
└─────────────┴──────────┴─────────┘

Uso de tupla

-- You can also use 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
ORDER BY
    2,
    3

┌─impressions─┬─city─────┬─browser─┐
│           1 │ Berlin   │ Chrome  │
│           1 │ Bobruisk │ Chrome  │
│           1 │ Istanbul │ Firefox │
└─────────────┴──────────┴─────────┘

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

SELECT arrayLast(x, y -> x=y, ['a', 'b', 'c'], ['a', 'b', 'c'])

c

No hay coincidencias

SELECT arrayFirst(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)

0	UInt8

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

SELECT arrayLastIndex(x, y -> x=y, ['a', 'b', 'c'], ['a', 'b', 'c']);

3

No hay coincidencias

SELECT arrayLastIndex(x, y -> x=y, ['a', 'b', 'c'], ['d', 'e', 'f']);

0

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

SELECT arrayLastOrNull(x, y -> x=y, ['a', 'b', 'c'], ['a', 'b', 'c'])

c

Sin coincidencias

SELECT arrayLastOrNull(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)

\N	Nullable(UInt8)

Introducido en: v25.4.0

Calcula la distancia de Levenshtein entre dos arrays.

Sintaxis

arrayLevenshteinDistance(from, to)

Argumentos

• from — El primer array. Array(T). - to — El segundo array. Array(T).

Valor devuelto

Distancia de Levenshtein entre el primer y el segundo array. Float64

Ejemplos

Ejemplo de uso

SELECT arrayLevenshteinDistance([1, 2, 4], [1, 2, 3])

1

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

• from — primer array. Array(T). - to — segundo array. Array(T). - from_weights — pesos del primer array. Array((U)Int*|Float*)
• to_weights — pesos del segundo array. Array((U)Int*|Float*)

Valor devuelto

Distancia de Levenshtein entre el primer y el segundo array con pesos personalizados para cada elemento Float64

Ejemplos

Ejemplo de uso

SELECT arrayLevenshteinDistanceWeighted(['A', 'B', 'C'], ['A', 'K', 'L'], [1.0, 2, 3], [3.0, 4, 5])

14

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 origen (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

SELECT arrayMap(x -> (x + 2), [1, 2, 3]) as res;

[3,4,5]

Crear una tupla de elementos de diferentes arrays

SELECT arrayMap((x, y) -> (x, y), [1, 2, 3], [4, 5, 6]) AS res

[(1,4),(2,5),(3,6)]

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

SELECT arrayMax([5, 3, 2, 7]);

7

Uso con una función lambda

SELECT arrayMax(x, y -> x/y, [4, 8, 12, 16], [1, 2, 1, 2]);

12

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

SELECT arrayMin([5, 3, 2, 7]);

2

Uso con una función lambda

SELECT arrayMin(x, y -> x/y, [4, 8, 12, 16], [1, 2, 1, 2]);

4

Introducido en: v25.1.0

Calcula el coeficiente de Gini normalizado.

Sintaxis

arrayNormalizedGini(predicted, label)

Argumentos

• predicted — El valor predicho. Array(T)
• label — El valor real. Array(T)

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

SELECT arrayNormalizedGini([0.9, 0.3, 0.8, 0.7],[6, 1, 0, 2]);

(0.18055555555555558,0.2638888888888889,0.6842105263157896)

Introducido en: v23.2.0

Esta función es igual que arrayReverseSort, pero con un argumento adicional, limit, que permite una ordenación parcial.

Sintaxis

arrayPartialReverseSort([f,] limit, arr [, arr1, ... ,arrN])

Argumentos

• f(arr[, arr1, ... ,arrN]) — La función lambda que se aplica a los elementos del array x. Función lambda
• limit — Valor de índice hasta el que se realizará la ordenación. (U)Int*
• arr — Array que se va a ordenar. Array(T)
• arr1, ... ,arrN — N arrays adicionales, en caso de que f acepte varios argumentos. Array(T)

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

SELECT arrayPartialReverseSort(2, [5, 9, 1, 3])

[9,5,1,3]

simple_string

SELECT arrayPartialReverseSort(2, ['expenses','lasso','embolism','gladly'])

['lasso','gladly','expenses','embolism']

retain_sorted

SELECT arrayResize(arrayPartialReverseSort(2, [5, 9, 1, 3]), 2)

[9,5]

lambda_simple

SELECT arrayPartialReverseSort((x) -> -x, 2, [5, 9, 1, 3])

[1,3,5,9]

lambda_complex

SELECT arrayPartialReverseSort((x, y) -> -y, 1, [0, 1, 2], [1, 2, 3]) as res

[0,1,2]

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:

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

SELECT arrayPartialShuffle([1, 2, 3, 4], 0)

[2, 4, 3, 1]

no_limit2

SELECT arrayPartialShuffle([1, 2, 3, 4])

[2,3,4,1]

random_seed

SELECT arrayPartialShuffle([1, 2, 3, 4], 2)

[3, 4, 1, 2]

explicit_seed

SELECT arrayPartialShuffle([1, 2, 3, 4], 2, 41)

[3,2,1,4]

materializar

SELECT arrayPartialShuffle(materialize([1, 2, 3, 4]), 2, 42), arrayPartialShuffle([1, 2, 3], 2, 42) FROM numbers(10)

┌─arrayPartialShuffle(materialize([1, 2, 3, 4]), 2, 42)─┬─arrayPartialShuffle([1, 2, 3], 2, 42)─┐
│ [3,2,1,4]                                             │ [3,2,1]                               │
│ [3,2,1,4]                                             │ [3,1,2]                               │
│ [4,3,2,1]                                             │ [1,3,2]                               │
│ [1,4,3,2]                                             │ [2,1,3]                               │
│ [3,4,1,2]                                             │ [3,2,1]                               │
│ [1,2,3,4]                                             │ [3,2,1]                               │
│ [1,4,3,2]                                             │ [1,2,3]                               │
│ [1,4,3,2]                                             │ [3,2,1]                               │
│ [3,1,2,4]                                             │ [3,2,1]                               │
│ [1,3,2,4]                                             │ [2,1,3]                               │
└───────────────────────────────────────────────────────┴───────────────────────────────────────┘

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.

Sintaxis

arrayPartialSort([f,] limit, arr [, arr1, ... ,arrN])

Argumentos

• f(arr[, arr1, ... ,arrN]) — La función lambda que se aplica a los elementos del array x. Función lambda
• limit — Valor de índice hasta el que se realizará la ordenación. (U)Int*
• arr — Array que se va a ordenar. Array(T)
• arr1, ... ,arrN — N arrays adicionales, en caso de que f acepte varios argumentos. Array(T)

Valor devuelto

Devuelve un array del mismo tamaño que el array original, en el que los elementos del rango [1..limit] se ordenan de forma ascendente. Los elementos restantes (limit..N] quedan en un orden no especificado.

Ejemplos

simple_int

SELECT arrayPartialSort(2, [5, 9, 1, 3])

[1,3,5,9]

simple_string

SELECT arrayPartialSort(2, ['expenses', 'lasso', 'embolism', 'gladly'])

['embolism','expenses','gladly','lasso']

retain_sorted

SELECT arrayResize(arrayPartialSort(2, [5, 9, 1, 3]), 2)

[1,3]

lambda_simple

SELECT arrayPartialSort((x) -> -x, 2, [5, 9, 1, 3])

[9,5,1,3]

lambda_complex

SELECT arrayPartialSort((x, y) -> -y, 1, [0, 1, 2], [1, 2, 3]) as res

[2,1,0]

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

SELECT arrayPopBack([1, 2, 3]) AS res;

[1,2]

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

SELECT arrayPopFront([1, 2, 3]) AS res;

[2,3]

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

SELECT arrayProduct([1, 2, 3, 4]);

24

Uso con funciones lambda

SELECT arrayProduct(x, y -> x+y, [2, 2], [2, 2]) AS res;

16

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

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

SELECT arrayPushBack(['a'], 'b') AS res;

['a','b']

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

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

SELECT arrayPushFront(['b'], 'a') AS res;

['a','b']

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.

Valor devuelto

Devuelve el área bajo la curva ROC (característica operativa del receptor). Float64

Ejemplos

Ejemplo de uso

SELECT arrayROCAUC([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1]);

0.75

Introducido en: v23.10.0

Devuelve un subconjunto con samples elementos aleatorios de un array de entrada. Si samples supera el tamaño del array de entrada, el tamaño de la muestra se limita al tamaño del array; es decir, se devuelven todos los elementos del array, pero no se garantiza su orden. La función puede manejar tanto arrays planos como arrays anidados.

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

SELECT arrayRandomSample(['apple', 'banana', 'cherry', 'date'], 2) as res;

['cherry','apple']

Uso de un array multidimensional

SELECT arrayRandomSample([[1, 2], [3, 4], [5, 6]], 2) as res;

[[3,4],[5,6]]

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

SELECT arrayReduce('max', [1, 2, 3]);

┌─arrayReduce('max', [1, 2, 3])─┐
│                             3 │
└───────────────────────────────┘

Ejemplo con función de agregación que usa varios argumentos

--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]);

┌─arrayReduce('maxIf', [3, 5], [1, 0])─┐
│                                    3 │
└──────────────────────────────────────┘

Ejemplo con una función de agregación paramétrica

SELECT arrayReduce('uniqUpTo(3)', [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);

┌─arrayReduce('uniqUpTo(3)', [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])─┐
│                                                           4 │
└─────────────────────────────────────────────────────────────┘

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

SELECT arrayReduceInRanges(
    'sum',
    [(1, 5), (2, 3), (3, 4), (4, 4)],
    [1000000, 200000, 30000, 4000, 500, 60, 7]
) AS res

┌─res─────────────────────────┐
│ [1234500,234000,34560,4567] │
└─────────────────────────────┘

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 origen Array(T)

Ejemplos

Ejemplo 1

SELECT arrayRemove([1, 2, 2, 3], 2)

[1,3]

Ejemplo 2

SELECT arrayRemove(['a', NULL, 'b', NULL], NULL)

['a','b']

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

SELECT arrayResize([1], 3);

[1,0,0]

Ejemplo 2

SELECT arrayResize([1], 3, NULL);

[1,NULL,NULL]

Introducido en: v1.1.0

Invierte el orden de los elementos de un array dado.

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

SELECT arrayReverse([1, 2, 3])

[3,2,1]

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

SELECT arrayReverseFill(x -> not isNull(x), [1, null, 2, null]) AS res

[1,2,2,NULL]

Ejemplo con dos arrays

SELECT arrayReverseFill(x, y, z -> x > y AND x < z, [5, 3, 6, 2], [4, 7, 1, 3], [10, 2, 8, 5]) AS res;

[5,6,6,2]

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, ..., arrN — 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

SELECT arrayReverseSort((x, y) -> y, [4, 3, 5], ['a', 'b', 'c']) AS res;

[5,3,4]

Ejemplo 2

SELECT arrayReverseSort((x, y) -> -y, [4, 3, 5], [1, 2, 3]) AS res;

[4,3,5]

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

SELECT arrayReverseSplit((x, y) -> y, [1, 2, 3, 4, 5], [1, 0, 0, 1, 0]) AS res

[[1],[2,3,4],[5]]

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

SELECT arrayRotateLeft([1,2,3,4,5,6], 2) as res;

[3,4,5,6,1,2]

Valor negativo de n

SELECT arrayRotateLeft([1,2,3,4,5,6], -2) as res;

[5,6,1,2,3,4]

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

• arr — El array cuyos elementos se rotan.Array(T). - n — Número de elementos que se rotan. (U)Int8/16/32/64.

Valor devuelto

Un array rotado a la derecha en el número de elementos especificado Array(T)

Ejemplos

Ejemplo de uso

SELECT arrayRotateRight([1,2,3,4,5,6], 2) as res;

[5,6,1,2,3,4]

Valor negativo para n

SELECT arrayRotateRight([1,2,3,4,5,6], -2) as res;

[3,4,5,6,1,2]

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

SELECT arrayShiftLeft([1,2,3,4,5,6], 2) as res;

[3,4,5,6,0,0]

Cuando n es negativo

SELECT arrayShiftLeft([1,2,3,4,5,6], -2) as res;

[0,0,1,2,3,4]

Usar un valor predeterminado

SELECT arrayShiftLeft([1,2,3,4,5,6], 2, 42) as res;

[3,4,5,6,42,42]

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

SELECT arrayShiftRight([1, 2, 3, 4, 5, 6], 2) as res;

[0,0,1,2,3,4]

Valor negativo de n

SELECT arrayShiftRight([1, 2, 3, 4, 5, 6], -2) as res;

[3,4,5,6,0,0]

Usar un valor predeterminado

SELECT arrayShiftRight([1, 2, 3, 4, 5, 6], 2, 42) as res;

[42,42,1,2,3,4]

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

SELECT arrayShingles([1, 2, 3, 4], 3) as res;

[[1,2,3],[2,3,4]]

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.

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)

SELECT arrayShuffle([1, 2, 3, 4]);

[1,4,2,3]

Ejemplo sin semilla (resultados estables)

SELECT arrayShuffle([1, 2, 3, 4], 41);

[3,2,1,4]

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

• from — primer array Array(T)
• to — segundo array Array(T)
• from_weights — pesos del primer array. Array((U)Int*|Float*)
• to_weights — pesos del segundo array. Array((U)Int*|Float*)

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

SELECT arraySimilarity(['A', 'B', 'C'], ['A', 'K', 'L'], [1.0, 2, 3], [3.0, 4, 5]);

0.2222222222222222

Introducido en: v1.1.0

Devuelve un segmento del array, incluidos los elementos NULL.

El primer argumento también puede ser un QBit: el resultado es un QBit sobre las dimensiones seleccionadas (una proyección a un subconjunto de dimensiones). En ese caso, offset y length deben ser constantes, porque la dimensión de un QBit forma parte de su tipo y el segmento debe seleccionar al menos una dimensión. Un segmento alineado con los límites de los grupos de stride de QBit conserva el stride y reutiliza los flujos de planos de bits almacenados sin copiarlos.

Sintaxis

arraySlice(arr, offset [, length])

Argumentos

• arr — Array que se va a segmentar. Array(T) o QBit
• 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

SELECT arraySlice([1, 2, NULL, 4, 5], 2, 3) AS res;

[2,NULL,4]

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, ..., arrN — 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

SELECT arraySort([1, 3, 3, 0]);

[0,1,3,3]

Ejemplo 2

SELECT arraySort(['hello', 'world', '!']);

['!','hello','world']

Ejemplo 3

SELECT arraySort([1, nan, 2, NULL, 3, nan, -4, NULL, inf, -inf]);

[-inf,-4,1,2,3,inf,nan,nan,NULL,NULL]

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

SELECT arraySplit((x, y) -> y, [1, 2, 3, 4, 5], [1, 0, 0, 1, 0]) AS res

[[1,2,3],[4,5]]

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

SELECT arraySum([1, 2, 3, 4]);

10

Uso con una función lambda

SELECT arraySum(x, y -> x+y, [1, 1, 1, 1], [1, 1, 1, 1]);

8

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.

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

SELECT
arraySymmetricDifference([1, 2], [1, 2], [1, 2]) AS empty_symmetric_difference,
arraySymmetricDifference([1, 2], [1, 2], [1, 3]) AS non_empty_symmetric_difference;

┌─empty_symmetric_difference─┬─non_empty_symmetric_difference─┐
│ []                         │ [3,2]                          │
└────────────────────────────┴────────────────────────────────┘

Introducido en: v26.6.0

Devuelve un array con los K elementos más grandes del array de entrada, ordenados en orden descendente. Si se especifica una función lambda f, los elementos se comparan según el resultado de aplicar f a cada elemento. Si f acepta varios argumentos, se pasan arrays adicionales a arrayTopK, y sus elementos corresponden a los argumentos de f.

Los valores NULL se omiten y no aparecen en el resultado. El tamaño del resultado es como máximo K y puede ser menor cuando el array de entrada contiene menos elementos no nulos que K. El tipo de elemento del resultado es la contraparte no Nullable del tipo de elemento de entrada.

arrayTopK es una función de orden superior.

Consulte también arrayBottomK, que devuelve en su lugar los K elementos más pequeños.

Sintaxis

arrayTopK([f,] K, arr [, arr1, ... ,arrN])

Argumentos

• f(arr[, arr1, ... ,arrN]) — Opcional. Una función lambda para calcular la clave de ordenación de cada elemento. Función lambda
• K — El número de elementos más grandes que se van a devolver. (U)Int8/16/32/64
• arr — Un array. Array(T)
• arr1, ... ,arrN — N arrays adicionales, en el caso de que f acepte varios argumentos. Array(T)

Valor devuelto

Devuelve hasta K elementos de arr con los valores más altos (o los valores más altos devueltos por la función lambda), ordenados de forma descendente. Se omiten los NULL. El array devuelto tiene tipo de elemento T incluso cuando la entrada es de tipo Nullable(T).

Ejemplos

simple_int

SELECT arrayTopK(3, [1, 5, 2, 7, 3])

[7,5,3]

skip_nulls

SELECT arrayTopK(3, [1, NULL, 5, 2, NULL, 7])

[7,5,2]

fewer_than_k

SELECT arrayTopK(5, [1, NULL, 2])

[2,1]

lambda_simple

SELECT arrayTopK((x) -> -x, 2, [5, 9, 1, 3])

[1,3]

lambda_multi

SELECT arrayTopK((x, y) -> y, 2, ['a', 'b', 'c'], [3, 1, 2])

['a','c']

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

SELECT arrayTranspose([[1, 2], [3, 4]])

[[1,3],[2,4]]

Matriz no cuadrada

SELECT arrayTranspose([[1, 2, 3], [4, 5, 6]])

[[1,4],[2,5],[3,6]]

Elementos de tipo String

SELECT arrayTranspose([['a', 'b'], ['c', 'd']])

[['a','c'],['b','d']]

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

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

┌─num_example─┬─str_example────┬─null_example─┐
│ [10,-2,1]   │ ['hello','hi'] │ [3,2,1,NULL] │
└─────────────┴────────────────┴──────────────┘

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.

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

SELECT arrayUniq([1, 1, 2, 2])

2

Varios argumentos

SELECT arrayUniq([1, 2, 3, 1], [4, 5, 6, 4])

3

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

SELECT arrayWithConstant(3, 1)

[1,1,1]

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

SELECT arrayZip(['a', 'b', 'c'], [5, 2, 1]);

[('a',5),('b',2),('c',1)]

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

SELECT arrayZipUnaligned(['a'], [1, 2, 3]);

[('a',1),(NULL,2),(NULL,3)]

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

SELECT countEqual([1, 2, NULL, NULL], NULL)

2

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.

La función también funciona con Strings o UUIDs.

Sintaxis

empty(arr)

Argumentos

• arr — Array de entrada. Array(T)

Valor devuelto

Devuelve 1 para un array vacío o 0 para un array no vacío UInt8

Ejemplos

Ejemplo de uso

SELECT empty([]);

1

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

SELECT emptyArrayDate()

[]

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

SELECT emptyArrayDateTime()

[]

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

SELECT emptyArrayFloat32()

[]

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

SELECT emptyArrayFloat64()

[]

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

SELECT emptyArrayInt16()

[]

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

SELECT emptyArrayInt32()

[]

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

SELECT emptyArrayInt64()

[]

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

SELECT emptyArrayInt8()

[]

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

SELECT emptyArrayString()

[]

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

• arr — Un array vacío. Array(T)

Valor devuelto

Un array con un único valor del tipo predeterminado del Array. Array(T)

Ejemplos

Ejemplo básico

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;

┌─emptyArrayToSingle(a)─┬─emptyArrayToSingle(b)─┬─emptyArrayToSingle(c)───┐
│ [0]                   │ ['']                  │ ['1970-01-01 00:00:00'] │
└───────────────────────┴───────────────────────┴─────────────────────────┘

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

SELECT emptyArrayUInt16()

[]

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

SELECT emptyArrayUInt32()

[]

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

SELECT emptyArrayUInt64()

[]

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