Funciones de arrays - ClickHouse Documentation

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

No todos los elementos coinciden

Query

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

Response

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

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

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

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

Indexación negativa

Query

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

Response

Uso de la notación [n]

Query

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

Response

Índice fuera de rango del array

Query

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

Response

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

Índices negativos

Query

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

Response

Í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:

Se conserva el orden de los elementos de source
Los duplicados de source se conservan si no existen en except
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

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

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

Sin coincidencia

Query

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

Response

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

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

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

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

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

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

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

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

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

No hay coincidencias

Query

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

Response

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

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

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

Query

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

Response

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

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

Query

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

Response

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

Uso con una función lambda

Query

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

Response

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

Uso con una función lambda

Query

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

Response

arrayNormalizedGini

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

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

Uso con funciones lambda

Query

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

Response

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:

-Inf
Inf
NaN
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

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

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

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

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:

-Inf
Inf
NaN
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

Uso con una función lambda

Query

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

Response

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

Varios argumentos

Query

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

Response

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

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

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

Query

SELECT empty([]);

Response

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

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

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

Array no encontrado

Query

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

Response

Uso básico de mapa

Query

SELECT has(map('a', 1, 'b', 2), 'b')

Response

Ruta JSON

Query

SELECT has('{"a": {"b": 1}}'::JSON, 'a.b')

Response

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

Arrays con valores NULL

Query

SELECT hasAll([1, Null], [Null])

Response

Arrays que contienen valores de distinto tipo

Query

SELECT hasAll([1.0, 2, 3, 4], [1, 3])

Response

Arrays que contienen valores String

Query

SELECT hasAll(['a', 'b'], ['a'])

Response

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

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

Arrays con valores NULL

Query

SELECT hasAny([Null], [Null, 1])

Response

Arrays con valores de distinto tipo

Query

SELECT hasAny([-128, 1., 512], [1])

Response

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

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

Arrays con valores NULL

Query

SELECT hasSubstr([1, Null], [Null])

Response

Arrays con valores de distinto tipo

Query

SELECT hasSubstr([1.0, 2, 3, 4], [1, 3])

Response

Arrays de cadenas

Query

SELECT hasSubstr(['a', 'b'], ['a'])

Response

Arrays con orden válido

Query

SELECT hasSubstr(['a', 'b' , 'c'], ['a', 'b'])

Response

Arrays con un orden no válido

Query

SELECT hasSubstr(['a', 'b' , 'c'], ['a', 'c'])

Response

Array de arrays

Query

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

Response

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

Array con NULL

Query

SELECT indexOf([1, 3, NULL, NULL], NULL)

Response

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

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

Ejemplo de Array

Query

SELECT length(['Hello', 'world'])

Response

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

arr — Array de entrada. Array(T)

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

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

arr | str — El array o la cadena de entrada. Array(T) o String

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.

​array

​arrayAUCPR

​arrayAll

​arrayAutocorrelation

​arrayAvg

​arrayCompact

​arrayConcat

​arrayCount

​arrayCumSum

​arrayCumSumNonNegative

​arrayDifference

​arrayDistinct

​arrayDotProduct

​arrayElement

​arrayElementOrNull

​arrayEnumerate

​arrayEnumerateDense

​arrayEnumerateDenseRanked

​arrayEnumerateUniq

​arrayEnumerateUniqRanked

​arrayExcept

​arrayExists

​arrayFill

​arrayFilter

​arrayFirst

​arrayFirstIndex

​arrayFirstOrNull

​arrayFlatten

​arrayFold

​arrayIntersect

​arrayJaccardIndex

​arrayJoin

​arrayLast

​arrayLastIndex

​arrayLastOrNull

​arrayLevenshteinDistance

​arrayLevenshteinDistanceWeighted

​arrayMap

​arrayMax

​arrayMin

​arrayNormalizedGini

​arrayPartialReverseSort

​arrayPartialShuffle

​arrayPartialSort

​arrayPopBack

​arrayPopFront

​arrayProduct

​arrayPushBack

​arrayPushFront

​arrayROCAUC

​arrayRandomSample

​arrayReduce

​arrayReduceInRanges

​arrayRemove

​arrayResize

​arrayReverse

​arrayReverseFill

​arrayReverseSort

​arrayReverseSplit

​arrayRotateLeft

​arrayRotateRight

​arrayShiftLeft

​arrayShiftRight

​arrayShingles

​arrayShuffle

​arraySimilarity

​arraySlice

​arraySort

​arraySplit

​arraySum

​arraySymmetricDifference

​arrayTranspose

​arrayUnion

​arrayUniq

​arrayWithConstant

​arrayZip

​arrayZipUnaligned

​countEqual

​empty

​emptyArrayDate

array

arrayAUCPR

arrayAll

arrayAutocorrelation

arrayAvg

arrayCompact

arrayConcat

arrayCount

arrayCumSum

arrayCumSumNonNegative

arrayDifference

arrayDistinct

arrayDotProduct

arrayElement

arrayElementOrNull

arrayEnumerate

arrayEnumerateDense

arrayEnumerateDenseRanked

arrayEnumerateUniq

arrayEnumerateUniqRanked

arrayExcept

arrayExists

arrayFill

arrayFilter

arrayFirst

arrayFirstIndex

arrayFirstOrNull

arrayFlatten

arrayFold

arrayIntersect

arrayJaccardIndex

arrayJoin

arrayLast

arrayLastIndex

arrayLastOrNull

arrayLevenshteinDistance

arrayLevenshteinDistanceWeighted

arrayMap

arrayMax

arrayMin

arrayNormalizedGini

arrayPartialReverseSort

arrayPartialShuffle

arrayPartialSort

arrayPopBack

arrayPopFront

arrayProduct

arrayPushBack

arrayPushFront

arrayROCAUC

arrayRandomSample

arrayReduce

arrayReduceInRanges

arrayRemove

arrayResize

arrayReverse

arrayReverseFill

arrayReverseSort

arrayReverseSplit

arrayRotateLeft

arrayRotateRight

arrayShiftLeft

arrayShiftRight

arrayShingles

arrayShuffle

arraySimilarity

arraySlice

arraySort

arraySplit

arraySum

arraySymmetricDifference

arrayTranspose

arrayUnion

arrayUniq

arrayWithConstant

arrayZip

arrayZipUnaligned

countEqual

empty

emptyArrayDate