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

┌─a───────────────────────────┬─toTypeName(a)─────────────────────────┐
│ [5,'1998-06-16 00:00:00',5] │ Array(Variant(DateTime, Int32, 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, a menos que una puntuación sea NaN, en cuyo caso el resultado es NaN. 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-exhaustividad (PR), o NaN si alguna puntuación es NaN. 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

arrayBottomK

Introducido en: v26.6.0 Devuelve un array con los K elementos más pequeños del array de entrada, ordenados en orden ascendente. Si se especifica una función lambda f, los elementos se comparan según el resultado de aplicar f a cada elemento. Si f acepta varios argumentos, se pasan arrays adicionales a arrayBottomK; sus elementos se corresponden con los argumentos de f. Los valores NULL se omiten y no aparecen en el resultado. El tamaño del resultado es como máximo K y puede ser menor cuando el array de entrada contiene menos elementos distintos de NULL que K. El tipo de elemento del resultado es la variante no Nullable del tipo de elemento de entrada. arrayBottomK es una función de orden superior. Véase también:

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

Sintaxis

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

Argumentos

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

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

Query

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

Response

[1,2,3]

skip_nulls

Query

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

Response

[1,2,5]

fewer_than_k

Query

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

Response

[1,2]

lambda_simple

Query

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

Response

[9,5]

lambda_multi

Query

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

Response

['b','c']

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* | BFloat16 | Decimal) o Tuple((U)Int* | Float* | Decimal)
v2 — Segundo vector. Array((U)Int* | Float* | BFloat16 | Decimal) o Tuple((U)Int* | Float* | Decimal)

Valor devuelto El producto escalar de ambos vectores.

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. Dos arrays BFloat16 se acumulan en Float32 y devuelven Float32 (la misma regla que para dos arrays Float32).

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

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. El primer argumento también puede ser:

un mapa: m['key'] devuelve el valor almacenado para key, o el valor predeterminado del tipo del valor cuando la clave no existe.
un QBit: q[n] reconstruye el n-ésimo elemento del vector con la precisión completa del tipo de elemento de QBit, leyendo solo los planos de bits del grupo de stride que lo contiene.
un JSON o un Nullable(JSON): json['key'] devuelve el valor almacenado en la ruta key, que debe ser una cadena constante, exactamente igual que hace la dot syntax json.key. Para un Nullable(JSON), el resultado sigue las mismas reglas de nulabilidad que json.key: una ruta que puede representar NULL (Dynamic, o una typed path que puede envolverse en Nullable) da NULL para las filas NULL externas, mientras que una typed path no nullable como Array o mapa conserva ahí su valor predeterminado. La clave también puede ser un Nullable(String) constante; una clave NULL da NULL. El acceso anidado puede encadenarse: json['a']['b'].

Sintaxis

arrayElement(arr, n)

Argumentos

arr — El valor del que se lee un elemento. Array(T), mapa(K, V), QBit, JSON o Nullable(JSON). - n — Posición del elemento que se quiere obtener o un array de posiciones. Las posiciones pueden ser Nullable. (U)Int* o Array((U)Int*). Para un argumento mapa, una clave de tipo K; para un argumento JSON, una ruta String constante.

Valor devuelto Cuando n es un escalar, devuelve el elemento de tipo T. Cuando n es un array, devuelve Array(Nullable(T)) si los elementos del índice pueden ser Nullable y T puede envolverse en Nullable; de lo contrario, devuelve Array(T). Para un mapa devuelve el valor de tipo V; para un JSON, el valor almacenado en la ruta. Any o Array(T) o Array(Nullable(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

Array de índices

Query

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

Response

[20,40,10]

Acceso por clave de mapa

Query

SELECT map('a', 1, 'b', 2)['b']

Response

Acceso con corchetes en JSON

Query

SELECT json['a'] FROM (SELECT '{"a" : 42}'::JSON AS json)

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, siempre que el tipo de resultado pueda ser Nullable. Para los tipos de elementos que no son Nullable y no pueden incluirse dentro de Nullable (como Array, mapa), se devuelve en su lugar el valor predeterminado del tipo de elemento. Cuando n es un array de enteros, devuelve un array con los elementos de las posiciones especificadas. Esto equivale a arrayMap(i -> arrayElementOrNull(arr, i), n), pero tiene una implementación independiente y más eficiente. Las posiciones fuera de los límites y los índices NULL producen valores NULL en el array resultante, siguiendo la misma regla que para un índice escalar.

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. El primer argumento también puede ser un mapa: una clave ausente devuelve NULL en lugar del valor predeterminado del tipo de valor, siempre que ese tipo pueda envolverse en Nullable. JSON no es compatible aquí; utilice arrayElement en su lugar. Sintaxis

arrayElementOrNull(arr, n)

Argumentos

arr — El valor del que se lee un elemento. Array(T) o mapa(K, V). - n — Posición del elemento que se desea obtener o un array de posiciones. Las posiciones pueden ser Nullable. (U)Int* o Array((U)Int*). Para un argumento mapa, una clave de tipo K.

Valor devuelto Cuando n es un escalar, devuelve Nullable(T) si T puede envolverse en Nullable; de lo contrario, T. Cuando n es un array, devuelve Array(Nullable(T)) si T puede envolverse en Nullable; de lo contrario, Array(T). Para un mapa se aplica la misma regla al tipo de valor V. Any o Nullable(T) o Array(T) o Array(Nullable(T)) Ejemplos Ejemplo de uso

Query

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

Response

Indexación negativa

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

\N

Array de índices

Query

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

Response

[10,NULL,20]

Clave ausente en el mapa

Query

SELECT arrayElementOrNull(map('a', 1), 'z')

Response

\N

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

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

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

Response

[1,2,1,3]

Uso con un array multidimensional

Query

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

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

Response

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

Ejemplo con un clear_depth mayor

Query

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

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

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

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

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

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

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

Response

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

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

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

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

Response

[1,1,2]

Ejemplo 2

Query

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

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

Response

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

Ejemplo 3

Query

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

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

Response

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

Ejemplo 4

Query

-- Changing clear_depth=2, results in elements being enumerated separately for each row.
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 predeterminado. Sintaxis

arrayFirst(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

Argumentos

func(x[, y1, ..., yN]) — Una función lambda que opera sobre los elementos del array de origen (x) y de los arrays de condición (y). Función lambda. - source_arr — El array de origen que se va a procesar. Array(T). - [, cond1_arr, ... , condN_arr] — Opcional. N arrays de condición que proporcionan argumentos adicionales para la función lambda. Array(T).

Valor devuelto Devuelve el primer elemento del array de origen para el que λ es true; de lo contrario, devuelve el valor predeterminado de T. Ejemplos Ejemplo de uso

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

\N	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]

arrayFlattenedLength

Introducido en: v26.9.0 Devuelve el número total de elementos de un array multidimensional, como si se hubiera aplanado con la función arrayFlatten. Función:

Se aplica a arrays anidados con cualquier nivel de profundidad.
Es equivalente a length para arrays que ya son planos.
Solo sigue el anidamiento de Array. Los elementos se cuentan en el primer nivel que no es un array, por lo que los elementos de un Map, Tuple, Dynamic o Variant anidado no se cuentan individualmente, incluso cuando contienen arrays.

Equivale a cardinality en PostgreSQL; en cambio, en ClickHouse cardinality es un alias de length y solo cuenta los elementos del array más externo. Sintaxis

arrayFlattenedLength(arr)

Argumentos

arr — Un array posiblemente multidimensional. Array(T)

Valor devuelto Devuelve el número de elementos del array tras aplanar todos los arrays anidados. UInt64 Ejemplos Array anidado

Query

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

Response

Anidamiento más profundo

Query

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

Response

Array plana

Query

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

Response

No se recorren los elementos que no son arrays

Query

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

Response

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. unnest (desde la versión 26.5) es un alias de arrayJoin que no distingue entre mayúsculas y minúsculas en forma de llamada a función (SELECT unnest(arr)). La sintaxis de PostgreSQL para fuentes de tabla no es compatible (FROM unnest(...), CROSS JOIN UNNEST(...) y LATERAL). Use la cláusula ARRAY JOIN para esas consultas. arrayJoin, incluso mediante su alias unnest, no se puede usar en una condición JOIN ON que se evalúe durante la unión, ya que dicha condición debe preservar el número de filas. Una condición que se aplica solo a un lado y una clave de igualdad basada en arrayJoin se extraen antes de la unión y no se ven afectadas. Una condición no disyuntiva de ALL INNER JOIN tampoco se ve afectada, porque en ese caso la condición se aplica después de la unión. Cuando la expansión depende de un solo lado, muévala a un ARRAY JOIN en una subconsulta antes de la unión; una condición cuyo argumento de arrayJoin hace referencia a columnas de ambos lados debe reestructurarse.

Esta función no es determinista: puede devolver resultados diferentes con los mismos argumentos.

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

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

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

Response

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

Uso de varias funciones arrayJoin

Query

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

SELECT
    sum(1) AS impressions,
    arrayJoin(cities) AS city,
    arrayJoin(browsers) AS browser
FROM
(
    SELECT
        ['Istanbul', 'Berlin', 'Bobruisk'] AS cities,
        ['Firefox', 'Chrome', 'Chrome'] AS browsers
)
GROUP BY
    2,
    3
ORDER BY
    city,
    browser

Response

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

Resultados inesperados debido a optimizaciones

Query

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

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

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

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

SELECT
    sum(1) AS impressions,
    city,
    browser
FROM
(
    SELECT
        ['Istanbul', 'Berlin', 'Bobruisk'] AS cities,
        ['Firefox', 'Chrome', 'Chrome'] AS browsers
)
ARRAY JOIN
    cities AS city,
    browsers AS browser
GROUP BY
    2,
    3
ORDER BY
    2,
    3

Response

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

Uso de tupla

Query

-- You can also use Tuple

SELECT
    sum(1) AS impressions,
    (arrayJoin(arrayZip(cities, browsers)) AS t).1 AS city,
    t.2 AS browser
FROM
(
    SELECT
        ['Istanbul', 'Berlin', 'Bobruisk'] AS cities,
        ['Firefox', 'Chrome', 'Chrome'] AS browsers
)
GROUP BY
    2,
    3
ORDER BY
    2,
    3

Response

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

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

\N	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 origen (x) y los arrays de condición (y). Función lambda
arr — N arrays para procesar. Array(T)

Valor devuelto Devuelve un array a partir de los resultados de la función lambda Array(T) Ejemplos Ejemplo de uso

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.

Esta función no es determinista: puede devolver resultados diferentes con los mismos argumentos.

Sintaxis

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

Argumentos

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

Valor devuelto Devuelve un array del mismo tamaño que el array original, en el que los elementos del rango [1..limit] se ordenan en orden descendente. Los elementos restantes (limit..N] quedan en un orden no especificado. Ejemplos simple_int

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.

Esta función no es determinista: puede devolver resultados diferentes para los mismos argumentos.

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

[2,3,4,1]

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

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

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.

Esta función no es determinista: puede devolver resultados diferentes para los mismos argumentos.

Sintaxis

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

Argumentos

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

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

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. Con scale establecido en true, que es el valor predeterminado, el valor resultante va de cero a uno; cuanto mayor sea el valor, mejor será el rendimiento del modelo, y el resultado es NaN cuando el ROC AUC no está definido, por ejemplo, si no hay etiquetas positivas o no hay etiquetas negativas. Una puntuación NaN siempre produce un resultado NaN. 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). Devuelve NaN si una puntuación es NaN y, cuando scale es true, también si el ROC AUC no está definido porque no hay etiquetas positivas o negativas. 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 un array de entrada. Si samples supera el tamaño del array de entrada, el tamaño de la muestra se limita al tamaño del array; es decir, se devuelven todos los elementos del array, pero no se garantiza su orden. La función puede manejar tanto arrays planos como arrays anidados.

Esta función no es determinista: puede devolver resultados diferentes para los mismos argumentos.

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 origen 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, ..., arrN — Opcional. N arrays adicionales, si f acepta varios argumentos.

Valor devuelto Devuelve el array x ordenado en orden descendente si no se proporciona ninguna función lambda; de lo contrario, devuelve un array ordenado según la lógica de la función lambda proporcionada y luego invertido. Array(T). Ejemplos Ejemplo 1

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.

Esta función no es determinista: puede devolver resultados diferentes para los mismos argumentos.

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

arraySlice(arr, offset [, length])

Argumentos

arr — Array que se va a segmentar. Array(T) o QBit
offset — Desplazamiento desde el borde del array. Un valor positivo indica un desplazamiento desde la izquierda y un valor negativo indica un desplazamiento desde la derecha. La numeración de los elementos del array comienza en 1. (U)Int*
length — La longitud del segmento requerido. Si especifica un valor negativo, la función devuelve un segmento abierto [offset, array_length - length]. Si omite el valor, la función devuelve el segmento [offset, the_end_of_array]. (U)Int*

Valor devuelto Devuelve un segmento del array con length elementos a partir del offset especificado Array(T) Ejemplos Ejemplo de uso

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, ..., arrN — Opcional. N arrays adicionales si f acepta varios argumentos.

Valor devuelto Devuelve el array arr ordenado de forma ascendente si no se proporciona ninguna función lambda; en caso contrario, devuelve un array ordenado según la lógica de la función lambda proporcionada. Array(T). Ejemplos Ejemplo 1

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

arrayTopK

Introducido en: v26.6.0 Devuelve un array con los K elementos más grandes del array de entrada, ordenados en orden descendente. Si se especifica una función lambda f, los elementos se comparan según el resultado de aplicar f a cada elemento. Si f acepta varios argumentos, se pasan arrays adicionales a arrayTopK, y sus elementos corresponden a los argumentos de f. Los valores NULL se omiten y no aparecen en el resultado. El tamaño del resultado es como máximo K y puede ser menor cuando el array de entrada contiene menos elementos no nulos que K. El tipo de elemento del resultado es la contraparte no Nullable del tipo de elemento de entrada. arrayTopK es una función de orden superior. Consulte también arrayBottomK, que devuelve en su lugar los K elementos más pequeños. Sintaxis

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

Argumentos

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

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

Query

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

Response

[7,5,3]

skip_nulls

Query

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

Response

[7,5,2]

fewer_than_k

Query

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

Response

[2,1]

lambda_simple

Query

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

Response

[1,3]

lambda_multi

Query

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

Response

['a','c']

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

Received exception:
Code: 386. DB::Exception: There is no supertype for types UInt8, String because some of them are String/FixedString/Enum and some of them are not. (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

Received exception:
Code: 386. DB::Exception: There is no supertype for types Array(UInt8), String because some of them are Array and some of them are not. (NO_COMMON_TYPE)

Array de arrays

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

Received exception:
Code: 386. DB::Exception: There is no supertype for types UInt8, String because some of them are String/FixedString/Enum and some of them are not. (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. Los elementos NaN no siguen la regla de NULL anterior. Una comparación escalar de dos valores NaN (NaN = NaN) es 0, pero indexOf puede indicar que se encontró un elemento NaN. Que lo haga es un detalle de implementación. No dependa de un comportamiento específico. Para encontrar uno, compruébelo: arrayFirstIndex(x -> isNaN(x), arr) devuelve su posición y arrayExists(x -> isNaN(x), arr), un indicador. 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

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.
Para argumentos QBit: calcula la dimensión del vector.
Si se aplica a un argumento FixedString o QBit, 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, CARDINALITY Argumentos

x — Valor para el que se calcula el número de bytes (para String/FixedString), de elementos (para array) o la dimensión (para QBit). String o FixedString o Array(T) o QBit

Valor devuelto Devuelve el número de bytes de la String/FixedString x, el número de elementos del array x o la dimensión del QBit x UInt64 Ejemplos Ejemplo de String

Query

SELECT length('Hello, world!')

Response

Ejemplo de array

Query

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

Response

Ejemplo de QBit

Query

SELECT length([0, 0, 0, 0, 0, 0, 0, 0]::QBit(Float32, 8))

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

notHas

Introducido en: v26.8.0 Devuelve si el array no contiene el elemento especificado, el mapa no contiene la clave especificada o el objeto JSON no contiene la ruta especificada. Es la negación de has. Sintaxis

notHas(haystack, needle)

Argumentos

haystack — El array, mapa o JSON de entrada. Array o Map o JSON
needle — El valor que se buscará (elemento del array, clave del mapa o cadena de ruta en JSON).

Valor devuelto Devuelve 1 si el haystack no contiene el needle especificado; de lo contrario, 0. UInt8 Ejemplos Uso básico de Array

Query

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

Response

Array no encontrado

Query

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

Response

Uso básico de Map

Query

SELECT notHas(map('a', 1, 'b', 2), 'c')

Response

Uso básico de JSON

Query

SELECT notHas('{"a" : 1, "b" : {"c" : 2}}'::JSON, 'b.c')

Response

randomHadamardTransform

Introducido en: v26.7.0 Aplica una transformada de Hadamard aleatoria a un vector de coma flotante: y = (1/sqrt(k)) * (H * D * x), donde D es una matriz diagonal de signos deterministas +/-1 elegidos por seed y H es la transformada de Walsh-Hadamard. La transformada es una rotación ortogonal que preserva la norma y reparte uniformemente la energía de un vector entre las coordenadas, haciendo que la distribución por coordenada sea aproximadamente gaussiana e independiente de los datos. Es útil como paso de preprocesamiento antes de la cuantización escalar y, cuando se trunca, como una proyección aleatoria de Johnson-Lindenstrauss / Hadamard aleatorizada submuestreada (SRHT). La transformada completa (sin truncamiento) conserva la longitud de entrada. Es exacta para las siguientes longitudes:

una potencia de dos (una transformada rápida de Walsh-Hadamard simple);
2^k * m con m en {12, 20} (órdenes que tienen una matriz de Hadamard +/-1, por ejemplo, 768 = 64 * 12, 1536 = 128 * 12, 3072 = 256 * 12, 2560 = 128 * 20), aplicada como la transformada exacta de Kronecker H_(2^k) (x) H_m (sin multiplicaciones en coma flotante);
2^k * m con cualquier otro m impar hasta 64 (órdenes que no tienen una matriz de Hadamard +/-1; estas solo existen para los órdenes 1, 2 y los múltiplos de 4), aplicada como la transformada exacta de Kronecker H_(2^k) (x) C_m, donde C_m es una matriz ortogonal real de transformada discreta de Hartley. Esto cubre las familias de embeddings restantes, como 3584 = 512 * 7, 1152 = 128 * 9, 1408 = 128 * 11.

Una transformada completa de una longitud cuyo mayor factor impar supera 64 no tiene una forma exacta y requeriría relleno con ceros hasta una potencia de dos mayor; se rechaza con una excepción en lugar de devolver silenciosamente un vector más largo. Use una longitud compatible o pase output_dims para calcular una proyección truncada de una longitud arbitraria (véase más abajo). El resultado tiene el mismo tipo de elemento que la entrada; un array de entrada vacío devuelve un array vacío (output_dims no se aplica a él).

seed (opcional, valor predeterminado 0): selecciona el patrón de signos; el mismo seed siempre produce la misma transformada.
output_dims (opcional; de forma predeterminada, la longitud de la transformada): conserva solo las primeras output_dims coordenadas, convirtiendo la transformada en una proyección aleatoria que acepta cualquier longitud. El escalado 1/sqrt(output_dims) hace que el resultado preserve la norma en la transformada completa y la preserve en valor esperado cuando se trunca. No debe superar la longitud de la transformada. Como un prefijo truncado del factor de transformada discreta de Hartley C_m no tiene el leverage uniforme de una matriz de Hadamard +/-1, un output_dims truncado sobre una longitud de la familia Hartley (o sobre cualquier longitud sin un factor exacto) usa la transformada de potencia de dos con relleno de ceros, que sí conserva esa propiedad.

Sintaxis

randomHadamardTransform(vector[, seed[, output_dims]])

Argumentos

vector — Vector que se transformará. Array(BFloat16) o Array(Float32) o Array(Float64)
seed — Opcional. Semilla para los signos deterministas de +/-1 (valor predeterminado: 0). UInt*
output_dims — Opcional. Trunca el resultado a este número de coordenadas iniciales (valor predeterminado: la longitud completa de la transformada, que coincide con la longitud de entrada para cada dimensión admitida). Especificar output_dims también habilita la transformada para longitudes para las que no existe una forma exacta de transformada completa. UInt*

Valor devuelto El vector transformado (con el mismo tipo de elemento que el de entrada). Su longitud es la longitud de la transformada (la longitud de entrada para una transformada completa de una dimensión admitida), truncada opcionalmente a output_dims. Array(BFloat16) o Array(Float32) o Array(Float64) Ejemplos Transformada completa para una longitud que es una potencia de dos

Query

SELECT length(randomHadamardTransform([1, 2, 3, 4]::Array(Float32)))

Response

Se conserva la norma

Query

SELECT round(arraySum(x -> x * x, randomHadamardTransform([1, 2, 3, 4]::Array(Float32))) - 30, 4)

Response

Proyección truncada a 3 dimensiones (acepta cualquier longitud)

Query

SELECT length(randomHadamardTransform([1, 2, 3, 4, 5, 6, 7, 8]::Array(Float32), 42, 3))

Response

La transformada exacta de una dimensión 2^k * m conserva la longitud de la entrada (sin relleno)

Query

SELECT length(randomHadamardTransform(CAST(range(1152), 'Array(Float32)')))

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

​arrayBottomK

​arrayCompact

​arrayConcat

​arrayCount

​arrayCumSum

​arrayCumSumNonNegative

​arrayDifference

​arrayDistinct

​arrayDotProduct

​arrayElement

​arrayElementOrNull

​arrayEnumerate

​arrayEnumerateDense

​arrayEnumerateDenseRanked

​arrayEnumerateUniq

​arrayEnumerateUniqRanked

​arrayExcept

​arrayExists

​arrayFill

​arrayFilter

​arrayFirst

​arrayFirstIndex

​arrayFirstOrNull

​arrayFlatten

​arrayFlattenedLength

​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

​arrayTopK

​arrayTranspose

​arrayUnion

​arrayUniq

​arrayWithConstant

​arrayZip

​arrayZipUnaligned

array

arrayAUCPR

arrayAll

arrayAutocorrelation

arrayAvg

arrayBottomK

arrayCompact

arrayConcat

arrayCount

arrayCumSum

arrayCumSumNonNegative

arrayDifference

arrayDistinct

arrayDotProduct

arrayElement

arrayElementOrNull

arrayEnumerate

arrayEnumerateDense

arrayEnumerateDenseRanked

arrayEnumerateUniq

arrayEnumerateUniqRanked

arrayExcept

arrayExists

arrayFill

arrayFilter

arrayFirst

arrayFirstIndex

arrayFirstOrNull

arrayFlatten

arrayFlattenedLength

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

arrayTopK

arrayTranspose

arrayUnion

arrayUniq

arrayWithConstant

arrayZip

arrayZipUnaligned