Funções de array

Introduzido em: v1.1.0

Cria um array a partir dos argumentos da função.

Os argumentos devem ser constantes e ter tipos que compartilhem um supertipo comum. É necessário fornecer pelo menos um argumento, pois, caso contrário, não fica claro qual tipo de array deve ser criado. Isso significa que você não pode usar esta função para criar um array vazio. Para isso, use a função emptyArray*.

Use o operador [ ] para obter a mesma funcionalidade.

Sintaxe

array(x1 [, x2, ..., xN])

Argumentos

• x1 — Valor constante de qualquer tipo T. Se apenas este argumento for fornecido, o array será do tipo T. - [, x2, ..., xN] — N valores constantes adicionais que compartilham um supertipo comum com x1

Valor retornado

Retorna um array, em que 'T' é o tipo comum mais específico entre os argumentos fornecidos. Array(T)

Exemplos

Uso válido

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

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

Uso incorreto

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

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

Introduzido em: v20.4.0

Calcula a área sob a curva de precisão-recall (PR). Uma curva de precisão-recall é criada ao plotar a precisão no eixo y e o recall no eixo x em todos os limiares. O valor resultante varia de 0 a 1, com valores mais altos indicando melhor desempenho do modelo. A PR AUC é particularmente útil para conjuntos de dados desbalanceados, proporcionando uma comparação de desempenho mais clara do que a ROC AUC nesses casos. Para mais detalhes, consulte aqui, aqui e aqui.

Sintaxe

arrayAUCPR(scores, labels[, partial_offsets])

Aliases: arrayPRAUC

Argumentos

• cores — Pontuações fornecidas pelo modelo de predição. Array((U)Int*) ou Array(Float*)
• labels — Rótulos das amostras, geralmente 1 para amostra positiva e 0 para amostra negativa. Array((U)Int*) ou Array(Enum)
• partial_offsets —
• Opcional. Um Array(T) de três inteiros não negativos para calcular uma área parcial sob a curva PR (equivalente a uma faixa vertical no espaço PR) em vez da AUC completa. Essa opção é útil para o cálculo distribuído da PR AUC. O array deve conter os seguintes elementos [higher_partitions_tp, higher_partitions_fp, total_positives].
  • higher_partitions_tp: O número de rótulos positivos nas partições com pontuações mais altas.
  • higher_partitions_fp: O número de rótulos negativos nas partições com pontuações mais altas.
  • total_positives: O número total de amostras positivas em todo o conjunto de dados.

Valor retornado

Retorna a área sob a curva de precisão-recall (PR). Float64

Exemplos

Exemplo de uso

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

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

Introduzido em: v1.1.0

Retorna 1 se a lambda func(x [, y1, y2, ... yN]) retornar verdadeiro para todos os elementos. Caso contrário, retorna 0.

Sintaxe

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

Argumentos

• func(x[, y1, ..., yN]) — Uma função lambda que opera sobre os elementos do array de origem (x) e dos arrays de condição (y). Função lambda
• source_arr — O array de origem a ser processado. Array(T)
• cond1_arr, ... — Opcional. N arrays de condição que fornecem argumentos adicionais para a função lambda. Array(T)

Valor retornado

Retorna 1 se a função lambda retornar verdadeiro para todos os elementos; caso contrário, 0 UInt8

Exemplos

Todos os elementos satisfazem a condição

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

1

Nem todos os elementos coincidem

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

0

Introduzido em: v26.4.0

Calcula a autocorrelação de um array. Se max_lag for informado, calcula a correlação apenas para defasagens no intervalo [0, max_lag). Se max_lag não for informado, calcula para todas as defasagens possíveis.

Sintaxe

arrayAutocorrelation(arr, [max_lag])

Argumentos

• arr — Array de números. Array(T)
• max_lag — Opcional. Número máximo de defasagens a calcular. Deve ser um inteiro não negativo. Integer

Valor retornado

Retorna um array de Float64. Retorna NaN se a variância for 0. Array(Float64)

Exemplos

Linear

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

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

Simétrico

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

[1,-0.6666666666666669,0.16666666666666674]

Constante

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

[nan,nan,nan]

Limitado

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

[1,0.4]

Introduzido em: v21.1.0

Retorna a média dos elementos do array de origem.

Se uma função lambda func for especificada, retorna a média dos elementos resultantes da lambda.

Sintaxe

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

Argumentos

• func(x[, y1, ..., yN]) — Opcional. Uma função lambda que opera sobre os elementos do array de origem (x) e dos arrays de condição (y). Função lambda
• source_arr — O array de origem a ser processado. Array(T)
• [, cond1_arr, ... , condN_arr] — Opcional. N arrays de condição que fornecem argumentos adicionais para a função lambda. Array(T)

Valor retornado

Retorna a média dos elementos no array de origem ou, se fornecida, a média dos resultados da função lambda. Float64

Exemplos

Exemplo básico

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

2.5

Uso com função lambda

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

6.5

Introduzido em: v26.6.0

Retorna um array com os K menores elementos do array de entrada, ordenados em ordem crescente. Se uma função lambda f for especificada, os elementos serão comparados com base no resultado de f aplicado a cada elemento. Se f aceitar vários argumentos, arrays adicionais serão passados para arrayBottomK, e seus elementos corresponderão aos argumentos de f.

Os valores NULL são ignorados e não aparecem no resultado. O tamanho do resultado é, no máximo, K e pode ser menor quando o array de entrada contiver menos de K elementos não nulos. O tipo de elemento do resultado é a versão não Nullable do tipo de elemento de entrada.

arrayBottomK é uma função de ordem superior.

Veja também:

• arrayTopK, que retorna os K maiores elementos.
• arrayPartialSort, que produz os mesmos K elementos nas posições [1..K], mas também mantém os elementos restantes em ordem não especificada e não ignora valores nulos.

Sintaxe

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

Argumentos

• f(arr[, arr1, ... ,arrN]) — Opcional. Uma função lambda para calcular a chave de ordenação de cada elemento. Função lambda
• K — O número de menores elementos a serem retornados. (U)Int8/16/32/64
• arr — Um array. Array(T)
• arr1, ... ,arrN — N arrays adicionais, caso f aceite vários argumentos. Array(T)

Valor retornado

Retorna até K elementos de arr com os menores valores (ou os menores resultados da função lambda), ordenados em ordem crescente. Valores NULL são ignorados. O array retornado tem tipo de elemento T mesmo quando a entrada tem tipo Nullable(T).

Exemplos

simple_int

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

[1,2,3]

skip_nulls

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

[1,2,5]

fewer_than_k

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

[1,2]

lambda_simple

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

[9,5]

lambda_multi

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

['b','c']

Introduzido em: v20.1.0

Remove elementos duplicados consecutivos de um array, incluindo valores null. A ordem dos valores no array resultante é determinada pela ordem dos elementos no array de origem.

Sintaxe

arrayCompact(arr)

Argumentos

• arr — Um array do qual serão removidos os valores duplicados. Array(T)

Valor retornado

Retorna um array sem valores duplicados Array(T)

Exemplos

Exemplo de uso

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

[1,nan,2,3]

Introduzido em: v1.1.0

Combina os arrays passados como argumentos.

Sintaxe

arrayConcat(arr1 [, arr2, ... , arrN])

Argumentos

• arr1 [, arr2, ... , arrN] — N arrays para concatenar. Array(T)

Valor retornado

Retorna um único array combinado a partir dos argumentos de array fornecidos. Array(T)

Exemplos

Exemplo de uso

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

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

Introduzido em: v1.1.0

Retorna o número de elementos para os quais func(arr1[i], ..., arrN[i]) retorna verdadeiro. Se func não for especificada, retorna o número de elementos não nulos no array.

arrayCount é uma função de ordem superior.

Sintaxe

arrayCount([func, ] arr1, ...)

Argumentos

• func — Opcional. Função a ser aplicada a cada elemento do(s) array(s). Função lambda
• arr1, ..., arrN — N arrays. Array(T)

Valor retornado

Retorna o número de elementos para os quais func retorna verdadeiro. Caso contrário, retorna o número de elementos não zero no array. UInt32

Exemplos

Exemplo de uso

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

5

Introduzido em: v1.1.0

Retorna um array com as somas parciais (acumuladas) dos elementos no array de origem. Se uma função lambda for especificada, a soma será calculada aplicando a função lambda aos elementos do array em cada posição.

Sintaxe

arrayCumSum([func,] arr1[, arr2, ... , arrN])

Argumentos

• func — Opcional. Uma função lambda a ser aplicada aos elementos do array em cada posição. Função lambda
• arr1 — O array de origem de valores numéricos. Array(T)
• [arr2, ..., arrN] — Opcional. Arrays adicionais do mesmo tamanho, passados como argumentos para a função lambda, se especificada. Array(T)

Valor retornado

Retorna um array com as somas parciais dos elementos do array de origem. O tipo do resultado corresponde ao tipo numérico do array de entrada. Array(T)

Exemplos

Uso básico

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

[1,2,3,4]

Com função lambda

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

[2,6,12]

Introduzido em: v18.12.0

Retorna um array com as somas parciais (acumuladas) dos elementos no array de origem, substituindo por zero qualquer soma acumulada negativa. Se uma função lambda for especificada, a soma é calculada aplicando a função lambda aos elementos do array em cada posição.

Sintaxe

arrayCumSumNonNegative([func,] arr1[, arr2, ... , arrN])

Argumentos

• func — Opcional. Uma função lambda a ser aplicada aos elementos do array em cada posição. Função lambda
• arr1 — O array de origem de valores numéricos. Array(T)
• [arr2, ..., arrN] — Opcional. Arrays adicionais do mesmo tamanho, passados como argumentos para a função lambda, se ela for especificada. Array(T)

Valor retornado

Retorna um array com as somas parciais dos elementos do array de origem, com qualquer soma acumulada negativa substituída por zero. O tipo do resultado corresponde ao tipo numérico do array de entrada. Array(T)

Exemplos

Uso básico

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

[1,2,0,1]

Com lambda

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

[2,0,6]

Introduzido em: v1.1.0

Calcula um array com as diferenças entre elementos adjacentes do array. O primeiro elemento do array resultante será 0, o segundo arr[1] - arr[0], o terceiro arr[2] - arr[1] e assim por diante. O tipo dos elementos no array resultante é determinado pelas regras de inferência de tipo para subtração (por exemplo, UInt8 - UInt8 = Int16).

Sintaxe

arrayDifference(arr)

Argumentos

• arr — Array para o qual serão calculadas as diferenças entre elementos adjacentes. Array(T)

Valor retornado

Retorna um array com as diferenças entre elementos adjacentes do array UInt*

Exemplos

Exemplo de uso

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

[0,1,1,1]

Exemplo de overflow causado pelo tipo de resultado Int64

SELECT arrayDifference([0, 10000000000000000000]);

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

Introduzido em: v1.1.0

Retorna um array que contém apenas os elementos distintos de um array.

Sintaxe

arrayDistinct(arr)

Argumentos

• arr — Array da qual extrair elementos distintos. Array(T)

Valor retornado

Retorna um array contendo os elementos distintos Array(T)

Exemplos

Exemplo de uso

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

[1,2,3]

Introduzido em: v23.5.0

Retorna o produto escalar de dois arrays.

Sintaxe

arrayDotProduct(v1, v2)

Argumentos

• v1 — Primeiro vetor. Array((U)Int* | Float* | BFloat16 | Decimal) ou Tuple((U)Int* | Float* | Decimal)
• v2 — Segundo vetor. Array((U)Int* | Float* | BFloat16 | Decimal) ou Tuple((U)Int* | Float* | Decimal)

Valor retornado

O produto escalar dos dois vetores.

(U)Int* ou Float* ou Decimal

Exemplos

Exemplo de Array

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

32	UInt16

Exemplo de Tuple

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

32	Float64

Introduzido em: v1.1.0

Obtém o elemento do array fornecido no índice n, em que n pode ser de qualquer tipo inteiro. Se o índice estiver fora dos limites de um array, a função retornará um valor padrão (0 para números, uma string vazia para strings etc.), exceto no caso de argumentos com um array não constante e um índice constante 0. Nesse caso, ocorrerá o erro Array indices are 1-based.

Quando n é um array de inteiros, retorna um array com os elementos nas posições especificadas (uma operação de coleta). Isso é equivalente a arrayMap(i -> arr[i], n), mas tem uma implementação separada e mais eficiente. Posições fora dos limites geram o valor padrão, assim como para um índice escalar. Os elementos do índice podem ser Nullable. Um índice NULL produz NULL (e torna Nullable o tipo de elemento do resultado) quando o tipo de elemento pode ser envolvido em Nullable; para tipos de elemento que não podem estar dentro de Nullable (como Array, Map), um índice NULL produz o valor padrão. Esse é o mesmo comportamento de um índice escalar NULL.

Índices negativos são suportados. Nesse caso, o elemento correspondente é selecionado, contando a partir do final. Por exemplo, arr[-1] é o último item do array.

O operador [n] fornece a mesma funcionalidade.

O primeiro argumento também pode ser um QBit: o n-ésimo elemento do vetor é reconstruído com a precisão total do tipo de elemento QBit, lendo apenas os planos de bits do grupo de stride que o contém.

Sintaxe

arrayElement(arr, n)

Argumentos

• arr — O array em que pesquisar. Array(T) ou QBit. - n — Posição do elemento a ser obtido ou um array de posições. As posições podem ser Nullable. (U)Int* ou Array((U)Int*).

Valor retornado

Quando n é um escalar, retorna o elemento do tipo T. Quando n é um array, retorna Array(Nullable(T)) se os elementos de índice forem Nullable e T puder ser encapsulado em Nullable; caso contrário, retorna Array(T). Any ou Array(T) ou Array(Nullable(T))

Exemplos

Exemplo de uso

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

2

Indexação com índices negativos

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

3

Uso da notação [n]

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

2

Índice fora dos limites do array

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

0

Array de índices

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

[20,40,10]

Introduzido em: v1.1.0

Obtém o elemento do array fornecido no índice n, em que n pode ser qualquer tipo inteiro. Se o índice estiver fora dos limites do array, NULL será retornado em vez de um valor padrão, desde que o tipo de resultado possa ser Nullable. Para tipos de elemento que ainda não são Nullable e não podem ser envolvidos por Nullable (como Array, Map), o valor padrão do tipo de elemento será retornado.

Quando n é um array de inteiros, retorna um array dos elementos nas posições especificadas. Isso é equivalente a arrayMap(i -> arrayElementOrNull(arr, i), n), mas tem uma implementação separada e mais eficiente. Posições fora dos limites e índices NULL produzem valores NULL no array de resultado, seguindo a mesma regra de um índice escalar.

Índices negativos são compatíveis. Nesse caso, seleciona o elemento correspondente contado a partir do fim. Por exemplo, arr[-1] é o último item do array.

Sintaxe

arrayElementOrNull(arr, n)

Argumentos

• arr — O array a ser pesquisado. Array(T). - n — Posição do elemento a ser obtido ou um array de posições. As posições podem ser Nullable. (U)Int* ou Array((U)Int*).

Valor retornado

Quando n é escalar, retorna Nullable(T) se T puder ser encapsulado em Nullable; caso contrário, T. Quando n é um array, retorna Array(Nullable(T)) se T puder ser encapsulado em Nullable; caso contrário, Array(T). Any ou Nullable(T) ou Array(T) ou Array(Nullable(T))

Exemplos

Exemplo de uso

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

2

Indexação com índices negativos

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

3

Índice fora dos limites do array

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

\N

Array de índices

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

[10,NULL,20]

Introduzido em: v1.1.0

Retorna o Array [1, 2, 3, ..., length (arr)]

Essa função normalmente é usada com a cláusula ARRAY JOIN. Ela permite contar algo apenas uma vez para cada array após a aplicação de ARRAY JOIN. Essa função também pode ser usada em funções de ordem superior. Por exemplo, você pode usá-la para obter os índices do array dos elementos que correspondem a uma condição.

Sintaxe

arrayEnumerate(arr)

Argumentos

• arr — O array a ser enumerado. Array

Valor retornado

Retorna o array [1, 2, 3, ..., length (arr)]. Array(UInt32)

Exemplos

Exemplo básico com ARRAY JOIN

CREATE TABLE test
(
    `id` UInt8,
    `tag` Array(String),
    `version` Array(String)
)
ENGINE = MergeTree
ORDER BY id;

INSERT INTO test VALUES (1, ['release-stable', 'dev', 'security'], ['2.4.0', '2.6.0-alpha', '2.4.0-sec1']);

SELECT
    id,
    tag,
    version,
    seq
FROM test
ARRAY JOIN
    tag,
    version,
    arrayEnumerate(tag) AS seq

┌─id─┬─tag────────────┬─version─────┬─seq─┐
│  1 │ release-stable │ 2.4.0       │   1 │
│  1 │ dev            │ 2.6.0-alpha │   2 │
│  1 │ security       │ 2.4.0-sec1  │   3 │
└────┴────────────────┴─────────────┴─────┘

Introduzido em: v18.12.0

Retorna um array do mesmo tamanho que o array de origem, indicando a posição da primeira ocorrência de cada elemento no array de origem.

Sintaxe

arrayEnumerateDense(arr)

Argumentos

• arr — O array a ser enumerado. Array(T)

Valor retornado

Retorna um array do mesmo tamanho que arr, indicando onde cada elemento aparece pela primeira vez no array de origem Array(T)

Exemplos

Exemplo de uso

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

[1,2,1,3]

Introduzido em: v20.1.0

Retorna um array do mesmo tamanho que o array de origem, indicando onde cada elemento aparece pela primeira vez no array de origem. Permite enumerar um array multidimensional, com a possibilidade de especificar até que profundidade inspecionar o array.

Sintaxe

arrayEnumerateDenseRanked(clear_depth, arr, max_array_depth)

Argumentos

• clear_depth — Enumera separadamente os elementos no nível especificado. Deve ser menor ou igual a max_arr_depth. UInt*
• arr — Array multidimensional a ser enumerado. Array(T)
• max_array_depth — A profundidade efetiva máxima. Deve ser menor ou igual à profundidade de arr. UInt*

Valor retornado

Retorna um array que indica onde cada elemento aparece pela primeira vez no array de origem Array

Exemplos

Uso básico

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

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

[1,2,1,3]

Uso com array multidimensional

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

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

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

Exemplo com clear_depth maior

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

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

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

Introduzido em: v1.1.0

Retorna um array do mesmo tamanho que o array de origem, indicando, para cada elemento, qual é sua posição entre os elementos com o mesmo valor.

Esta função é útil ao usar ARRAY JOIN e agregação de elementos de array.

A função pode receber vários arrays do mesmo tamanho como argumentos. Nesse caso, a unicidade é considerada para Tuples de elementos nas mesmas posições em todos os arrays.

Sintaxe

arrayEnumerateUniq(arr1[, arr2, ... , arrN])

Argumentos

• arr1 — Primeiro array a ser processado. Array(T)
• arr2, ... — Opcional. Arrays adicionais do mesmo tamanho para unicidade de tuplas. Array(UInt32)

Valor retornado

Retorna um array em que cada elemento representa a posição entre os elementos com o mesmo valor ou tupla. Array(T)

Exemplos

Uso básico

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

[1,1,2,1]

Vários arrays

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

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

Agregação com ARRAY JOIN

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

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

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

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

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

Introduzido em: v20.1.0

Retorna um array (ou array multidimensional) com as mesmas dimensões do array de origem, indicando, para cada elemento, qual é sua posição entre os elementos com o mesmo valor. Permite enumerar um array multidimensional com a possibilidade de especificar até que profundidade procurar dentro do array.

Sintaxe

arrayEnumerateUniqRanked(clear_depth, arr, max_array_depth)

Argumentos

• clear_depth — Enumera separadamente os elementos no nível especificado. Inteiro positivo menor ou igual a max_arr_depth. UInt*
• arr — Array N-dimensional a ser enumerado. Array(T)
• max_array_depth — A profundidade efetiva máxima. Inteiro positivo menor ou igual à profundidade de arr. UInt*

Valor retornado

Retorna um Array N-dimensional do mesmo tamanho de arr, em que cada elemento mostra a posição desse elemento em relação aos outros elementos com o mesmo valor. Array(T)

Exemplos

Exemplo 1

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

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

[1,1,2]

Exemplo 2

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

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

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

Exemplo 3

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

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

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

Exemplo 4

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

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

Introduzido em: v25.9.0

Retorna um array contendo os elementos de source que não estão presentes em except, preservando a ordem original.

Esta função realiza uma operação de diferença de conjuntos entre dois arrays. Para cada elemento em source, ela verifica se esse elemento existe em except (usando comparação exata). Caso não exista, o elemento é incluído no resultado.

A operação mantém as seguintes propriedades:

1. A ordem dos elementos de source é preservada
2. Duplicatas em source são preservadas se não existirem em except
3. NULL é tratado como um valor distinto

Sintaxe

arrayExcept(source, except)

Argumentos

• source — O array de entrada que contém os elementos a serem filtrados. Array(T)
• except — O array que contém os elementos a serem excluídos do resultado. Array(T)

Valor retornado

Retorna um array do mesmo tipo que o array de entrada, contendo os elementos de source que não foram encontrados em except. Array(T)

Exemplos

básico

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

[1,2,2,4]

with_nulls1

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

[1,NULL,NULL]

with_nulls2

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

[1]

strings

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

['apple','cherry']

Introduzido em: v1.1.0

Retorna 1 se houver pelo menos um elemento no array de origem para o qual func(x[, y1, y2, ... yN]) retorne true. Caso contrário, retorna 0.

Sintaxe

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

Argumentos

• func(x[, y1, ..., yN]) — Uma função lambda que opera nos elementos do array de origem (x) e dos arrays de condição (y). Função lambda
• source_arr — O array de origem a ser processado. Array(T)
• [, cond1_arr, ... , condN_arr] — Opcional. N arrays de condição que fornecem argumentos adicionais para a função lambda. Array(T)

Valor retornado

Retorna 1 se a função lambda retornar verdadeiro para pelo menos um elemento; caso contrário, 0. UInt8

Exemplos

Exemplo de uso

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

0

Introduzido em: v20.1.0

A função arrayFill processa sequencialmente um array de origem, do primeiro ao último elemento, avaliando uma condição lambda em cada posição com base em elementos do array de origem e dos arrays de condição. Quando a função lambda retorna false na posição i, a função substitui esse elemento pelo elemento na posição i-1 do estado atual do array. O primeiro elemento é sempre preservado, independentemente de qualquer condição.

Sintaxe

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

Argumentos

• func(x [, y1, ..., yN]) — Uma função lambda func(x [, y1, y2, ... yN]) → F(x [, y1, y2, ... yN]) que opera nos elementos do array de origem (x) e dos arrays de condição (y). função lambda
• source_arr — O array de origem a ser processado. função lambda
• [, cond1_arr, ... , condN_arr] — Opcional. N arrays de condição que fornecem argumentos adicionais à função lambda. Array(T)

Valor retornado

Retorna um array Array(T)

Exemplos

Exemplo com um único array

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

[1,1,2,2]

Exemplo com dois arrays

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

[5,5,6,6]

Introduzido em: v1.1.0

Retorna um array que contém apenas os elementos do array de origem para os quais uma função lambda retorna true.

Sintaxe

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

Argumentos

• func(x[, y1, ..., yN]) — Uma função lambda que opera sobre os elementos do array de origem (x) e dos arrays de condição (y). Função lambda
• source_arr — O array de origem a ser processado. Array(T)
• [, cond1_arr, ... , condN_arr] — Opcional. N arrays de condição que fornecem argumentos adicionais para a função lambda. Array(T)

Valor retornado

Retorna um subconjunto do array de origem Array(T)

Exemplos

Exemplo 1

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

['abc World']

Exemplo 2

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

[2]

Introduzido em: v1.1.0

Retorna o primeiro elemento no array de origem para o qual func(x[, y1, y2, ... yN]) retorna true; caso contrário, retorna um valor padrão.

Sintaxe

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

Argumentos

• func(x[, y1, ..., yN]) — Uma função lambda que opera nos elementos do array de origem (x) e dos arrays de condição (y). Função lambda. - source_arr — O array de origem a ser processado. Array(T). - [, cond1_arr, ... , condN_arr] — Opcional. N arrays de condição que fornecem argumentos adicionais à função lambda. Array(T).

Valor retornado

Retorna o primeiro elemento do array de origem para o qual λ é true; caso contrário, retorna o valor padrão de T.

Exemplos

Exemplo de uso

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

b

Nenhuma correspondência

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

0	UInt8

Introduzido em: v1.1.0

Retorna o índice do primeiro elemento no array de origem para o qual func(x[, y1, y2, ... yN]) retorna verdadeiro; caso contrário, retorna '0'.

Sintaxe

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

Argumentos

• func(x[, y1, ..., yN]) — Uma função lambda que opera nos elementos do array de origem (x) e dos arrays de condição (y). Função lambda. - source_arr — O array de origem a ser processado. Array(T). - [, cond1_arr, ... , condN_arr] — Opcional. N arrays de condição que fornecem argumentos adicionais para a função lambda. Array(T).

Valor retornado

Retorna o índice do primeiro elemento do array de origem para o qual func é verdadeiro; caso contrário, retorna 0 UInt32

Exemplos

Exemplo de uso

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

2

Sem correspondência

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

0

Introduzido em: v1.1.0

Retorna o primeiro elemento do array de origem para o qual func(x[, y1, y2, ... yN]) retorna true; caso contrário, retorna NULL.

Sintaxe

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

Argumentos

• func(x[, y1, ..., yN]) — Uma função lambda que atua sobre os elementos do array de origem (x) e dos arrays de condição (y). Função lambda
• source_arr — O array de origem a ser processado. Array(T)
• [, cond1_arr, ... , condN_arr] — Opcional. N arrays de condição que fornecem argumentos adicionais à função lambda. Array(T)

Valor retornado

Retorna o primeiro elemento do array de origem para o qual func é verdadeiro; caso contrário, retorna NULL.

Exemplos

Exemplo de uso

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

b

Sem correspondência

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

\N	Nullable(UInt8)

Introduzido em: v20.1.0

Converte um array de arrays em um array plano.

Função:

• Aplica-se a qualquer nível de profundidade de arrays aninhados.
• Não altera arrays que já são planos.

O array achatado contém todos os elementos de todos os arrays de origem.

Sintaxe

arrayFlatten(arr)

Aliases: flatten

Argumentos

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

Valor retornado

Retorna um array unidimensional a partir do array multidimensional Array(T)

Exemplos

Exemplo de uso

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

[1,2,3]

Introduzido em: v23.10.0

Aplica uma função lambda a um ou mais arrays de mesmo tamanho e acumula o resultado em um acumulador.

Sintaxe

arrayFold(λ

Argumentos

• λ(x, x1 [, x2, x3, ... xN]) — Uma função lambda λ(acc, x1 [, x2, x3, ... xN]) → F(acc, x1 [, x2, x3, ... xN]), em que F é uma operação aplicada a acc e aos valores do array x, reutilizando o resultado de acc. Função lambda
• arr1 [, arr2, arr3, ... arrN] — N arrays sobre os quais a operação será aplicada. Array(T)
• acc — Valor do acumulador com o mesmo tipo do valor de retorno da função lambda.

Valor retornado

Retorna o valor final de acc.

Exemplos

Exemplo de uso

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

23

Sequência de Fibonacci

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

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

Exemplo com vários arrays

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

300

Introduzido em: v1.1.0

Recebe múltiplos arrays e retorna um array com os elementos presentes em todos os arrays de origem. O resultado contém apenas valores únicos.

Sintaxe

arrayIntersect(arr, arr1, ..., arrN)

Argumentos

• arrN — N arrays a partir dos quais o novo array será criado. Array(T).

Valor retornado

Retorna um array com elementos distintos presentes em todos os N arrays Array(T)

Exemplos

Exemplo de uso

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

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

Introduzido em: v23.7.0

Retorna o índice de Jaccard de dois arrays.

Sintaxe

arrayJaccardIndex(arr_x, arr_y)

Argumentos

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

Valor retornado

Retorna o índice de Jaccard entre arr_x e arr_y Float64

Exemplos

Exemplo de uso

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

0.3333333333333333

Introduzido em: v1.1.0

A função arrayJoin recebe uma linha que contém um array e o expande, gerando várias linhas — uma para cada elemento do array. Isso contrasta com as funções regulares no ClickHouse, que mapeiam valores de entrada para valores de saída dentro da mesma linha, e com as funções de agregação, que recebem um grupo de linhas e as "comprimem" ou "reduzem" a uma única linha de resumo (ou a um único valor dentro de uma linha de resumo, se usadas com GROUP BY).

Todos os valores nas colunas são simplesmente copiados, exceto os valores da coluna à qual essa função é aplicada; eles são substituídos pelo valor correspondente do array.

unnest (desde a versão 26.5) é um alias de arrayJoin que não diferencia maiúsculas de minúsculas na forma de chamada de função (SELECT unnest(arr)). A sintaxe do PostgreSQL para fonte de tabela não é compatível (FROM unnest(...), CROSS JOIN UNNEST(...) e LATERAL). Use a cláusula ARRAY JOIN para essas consultas.

arrayJoin, inclusive por meio de seu alias unnest, não pode ser usado em uma condição JOIN ON avaliada durante o join, pois essa condição deve preservar o número de linhas. Uma condição que se aplica a apenas um lado e uma chave de igualdade sobre arrayJoin são extraídas antes do join e não são afetadas. Uma condição ALL INNER JOIN sem disjunções também não é afetada, pois, nesse caso, a condição é aplicada após o join. Quando a expansão depende de apenas um lado, mova-a para um ARRAY JOIN em uma subconsulta antes do join; uma condição cujo argumento de arrayJoin lê colunas de ambos os lados precisa ser reestruturada.

Sintaxe

arrayJoin(arr)

Aliases: unnest

Argumentos

• arr — Um array a ser expandido. Array(T)

Valor retornado

Retorna um conjunto de linhas geradas a partir da expansão de arr.

Exemplos

Uso básico

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

┌─dst─┬─'Hello'─┬─src─────┐
│   1 │ Hello   │ [1,2,3] │
│   2 │ Hello   │ [1,2,3] │
│   3 │ Hello   │ [1,2,3] │
└─────┴─────────┴─────────┘

arrayJoin afeta todas as cláusulas da consulta

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

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

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

Usando várias funções arrayJoin

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

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

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

Resultados inesperados devido a otimizações

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

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

┌─first_throw─┬─second_throw─┐
│           1 │            1 │
│           1 │            2 │
│           1 │            3 │
│           1 │            4 │
│           1 │            5 │
│           1 │            6 │
│           2 │            1 │
│           2 │            2 │
│           2 │            3 │
│           2 │            4 │
│           2 │            5 │
│           2 │            6 │
│           3 │            1 │
│           3 │            2 │
│           3 │            3 │
│           3 │            4 │
│           3 │            5 │
│           3 │            6 │
│           4 │            1 │
│           4 │            2 │
│           4 │            3 │
│           4 │            4 │
│           4 │            5 │
│           4 │            6 │
│           5 │            1 │
│           5 │            2 │
│           5 │            3 │
│           5 │            4 │
│           5 │            5 │
│           5 │            6 │
│           6 │            1 │
│           6 │            2 │
│           6 │            3 │
│           6 │            4 │
│           6 │            5 │
│           6 │            6 │
└─────────────┴──────────────┘

Usando a sintaxe ARRAY JOIN

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

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

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

Uso de Tuple

-- You can also use Tuple

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

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

Introduzido em: v1.1.0

Retorna o último elemento no array de origem para o qual uma função lambda func(x [, y1, y2, ... yN]) retorna true; caso contrário, retorna um valor padrão.

Sintaxe

arrayLast(func(x[, y1, ..., yN]), source[, cond1, ... , condN_arr])

Argumentos

• func(x[, y1, ..., yN]) — Uma função lambda que opera sobre elementos do array de origem (x) e arrays de condição (y). Função lambda. - source — O array de origem a ser processado. Array(T). - [, cond1, ... , condN] — Opcional. N arrays de condição que fornecem argumentos adicionais à função lambda. Array(T).

Valor retornado

Retorna o último elemento do array de origem para o qual func é verdadeiro; caso contrário, retorna o valor padrão de T.

Exemplos

Exemplo de uso

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

c

Nenhuma correspondência

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

0	UInt8

Introduzido em: v1.1.0

Retorna o índice do último elemento no array de origem para o qual func(x[, y1, y2, ... yN]) retorna true; caso contrário, retorna '0'.

Sintaxe

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

Argumentos

• func(x[, y1, ..., yN]) — Uma função lambda que opera nos elementos do array de origem (x) e dos arrays de condição (y). Função lambda
• source_arr — O array de origem a ser processado. Array(T)
• [, cond1_arr, ... , condN_arr] — Opcional. N arrays de condição que fornecem argumentos adicionais para a função lambda. Array(T)

Valor retornado

Retorna o índice do último elemento do array de origem para o qual func é verdadeiro; caso contrário, retorna 0 UInt32

Exemplos

Exemplo de uso

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

3

Nenhuma correspondência

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

0

Introduzido em: v1.1.0

Retorna o último elemento do array de origem para o qual uma função lambda func(x [, y1, y2, ... yN]) retorna true; caso contrário, retorna NULL.

Sintaxe

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

Argumentos

• func(x [, y1, ..., yN]) — Uma função lambda que opera sobre os elementos do array de origem (x) e dos arrays de condição (y). Função lambda. - source_arr — O array de origem a ser processado. Array(T). - [, cond1_arr, ... , condN_arr] — Opcional. N arrays de condição que fornecem argumentos adicionais para a função lambda. Array(T).

Valor retornado

Retorna o último elemento do array de origem para o qual λ não for verdadeiro; caso contrário, retorna NULL.

Exemplos

Exemplo de uso

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

c

Nenhuma correspondência

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

\N	Nullable(UInt8)

Introduzido em: v25.4.0

Calcula a distância de Levenshtein entre dois arrays.

Sintaxe

arrayLevenshteinDistance(from, to)

Argumentos

• from — O primeiro array. Array(T). - to — O segundo array. Array(T).

Valor retornado

Distância de Levenshtein entre o primeiro array e o segundo array. Float64

Exemplos

Exemplo de uso

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

1

Introduzido em: v25.4.0

Calcula a distância de Levenshtein entre dois arrays com pesos personalizados para cada elemento. O número de elementos do array e o de seus pesos devem corresponder.

Sintaxe

arrayLevenshteinDistanceWeighted(from, to, from_weights, to_weights)

Argumentos

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

Valor retornado

Distância de Levenshtein entre os dois arrays, com pesos personalizados para cada elemento Float64

Exemplos

Exemplo de uso

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

14

Introduzido na versão: v1.1.0

Retorna um array obtido dos arrays originais ao aplicar uma função lambda a cada elemento.

Sintaxe

arrayMap(func, arr)

Argumentos

• func — Uma função lambda que opera sobre os elementos do array de origem (x) e dos arrays de condição (y). Função lambda
• arr — N arrays a serem processados. Array(T)

Valor retornado

Retorna um array com os resultados da função lambda Array(T)

Exemplos

Exemplo de uso

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

[3,4,5]

Criando uma tupla com elementos de arrays diferentes

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

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

Introduzido em: v21.1.0

Retorna o maior elemento do array de origem.

Se uma função lambda func for especificada, retorna o maior elemento entre os resultados da lambda.

Sintaxe

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

Argumentos

• func(x[, y1, ..., yN]) — Opcional. Uma função lambda aplicada aos elementos do array de origem (x) e dos arrays de condição (y). Função lambda
• source_arr — O array de origem a ser processado. Array(T)
• [, cond1_arr, ... , condN_arr] — Opcional. N arrays de condição que fornecem argumentos adicionais para a função lambda. Array(T)

Valor retornado

Retorna o maior elemento do array de origem ou, se fornecida, o maior elemento entre os resultados da função lambda.

Exemplos

Exemplo básico

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

7

Uso com função lambda

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

12

Introduzido em: v21.1.0

Retorna o menor elemento no array de entrada.

Se uma função lambda func for especificada, retorna o menor elemento dos resultados da função lambda.

Sintaxe

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

Argumentos

• func(x[, y1, ..., yN]) — Opcional. Uma função lambda que opera nos elementos do array de origem (x) e dos arrays de condição (y). Função lambda
• source_arr — O array de origem a ser processado. Array(T)
• cond1_arr, ... — Opcional. N arrays de condição que fornecem argumentos adicionais para a função lambda. Array(T)

Valor retornado

Retorna o menor elemento do array de origem ou, se fornecida, o menor elemento entre os resultados da função lambda.

Exemplos

Exemplo básico

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

2

Uso com função lambda

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

4

Introduzido em: v25.1.0

Calcula o coeficiente de Gini normalizado.

Sintaxe

arrayNormalizedGini(predicted, label)

Argumentos

• predicted — O valor previsto. Array(T)
• label — O valor real. Array(T)

Valor retornado

Uma tupla que contém os coeficientes de Gini dos valores previstos, o coeficiente de Gini dos valores normalizados e o coeficiente de Gini normalizado (= a razão entre os dois coeficientes de Gini anteriores) Tuple(Float64, Float64, Float64)

Exemplos

Exemplo de uso

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

(0.18055555555555558,0.2638888888888889,0.6842105263157896)

Introduzido em: v23.2.0

Esta função é igual a arrayReverseSort, mas com o argumento adicional limit, que permite ordenação parcial.

Sintaxe

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

Argumentos

• f(arr[, arr1, ... ,arrN]) — A função lambda a ser aplicada aos elementos do array x. Função lambda
• limit — Valor do índice até o qual a ordenação ocorrerá. (U)Int*
• arr — Array a ser ordenado. Array(T)
• arr1, ... ,arrN — N arrays adicionais, caso f aceite vários argumentos. Array(T)

Valor retornado

Retorna um array do mesmo tamanho que o array original, em que os elementos no intervalo [1..limit] são ordenados em ordem decrescente. Os elementos restantes (limit..N] ficam em ordem não especificada.

Exemplos

simple_int

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

[9,5,1,3]

simple_string

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

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

retain_sorted

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

[9,5]

lambda_simple

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

[1,3,5,9]

lambda_complex

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

[0,1,2]

Introduzido em: v23.2.0

Retorna um array do mesmo tamanho que o array original, em que os elementos no intervalo [1..limit] formam um subconjunto aleatório do array original. O restante em (limit..n] deve conter os elementos que não estão no intervalo [1..limit], em ordem indefinida. O valor de limit deve estar no intervalo [1..n]. Valores fora desse intervalo equivalem a executar arrayShuffle completo:

Sintaxe

arrayPartialShuffle(arr [, limit[, seed]])

Argumentos

• arr — O array a ser embaralhado. Array(T)
• seed — Opcional. A semente usada na geração de números aleatórios. Se não for fornecida, uma semente aleatória será usada. (U)Int*
• limit — Opcional. O número que limita as trocas de elementos, no intervalo [1..N]. (U)Int*

Valor retornado

Array com elementos parcialmente embaralhados. Array(T)

Exemplos

no_limit1

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

[2, 4, 3, 1]

no_limit2

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

[2,3,4,1]

random_seed

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

[3, 4, 1, 2]

explicit_seed

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

[3,2,1,4]

materializar

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

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

Introduzido em: v23.2.0

Esta função é igual a arraySort, mas com um argumento adicional, limit, que permite ordenação parcial.

Sintaxe

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

Argumentos

• f(arr[, arr1, ... ,arrN]) — A função lambda a ser aplicada aos elementos do array x. Função lambda
• limit — Valor do índice até o qual a ordenação ocorrerá. (U)Int*
• arr — Array a ser ordenado. Array(T)
• arr1, ... ,arrN — N arrays adicionais, quando f aceita vários argumentos. Array(T)

Valor retornado

Retorna um array do mesmo tamanho que o array original, em que os elementos no intervalo [1..limit] são ordenados em ordem crescente. Os elementos restantes (limit..N] ficam em ordem não especificada.

Exemplos

simple_int

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

[1,3,5,9]

simple_string

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

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

retain_ordenado

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

[1,3]

lambda_simple

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

[9,5,1,3]

lambda_complex

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

[2,1,0]

Introduzido em: v1.1.0

Remove o último elemento da array.

Sintaxe

arrayPopBack(arr)

Argumentos

• arr — O array do qual o último elemento será removido. Array(T)

Valor retornado

Retorna um array idêntico a arr, mas sem o último elemento de arr Array(T)

Exemplos

Exemplo de uso

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

[1,2]

Introduzido em: v1.1.0

Remove o primeiro elemento do array.

Sintaxe

arrayPopFront(arr)

Argumentos

• arr — O array do qual o primeiro elemento será removido. Array(T)

Valor retornado

Retorna um array idêntico a arr, mas sem o seu primeiro elemento Array(T)

Exemplos

Exemplo de uso

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

[2,3]

Introduzido em: v21.1.0

Retorna o produto dos elementos do array de origem.

Se uma função lambda func for especificada, retorna o produto dos elementos resultantes da função lambda.

Sintaxe

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

Argumentos

• func(x[, y1, ..., yN]) — Opcional. Uma função lambda que opera nos elementos do array de origem (x) e dos arrays condicionais (y). Função lambda
• source_arr — O array de origem a ser processado. Array(T)
• [, cond1_arr, ... , condN_arr] — Opcional. N arrays condicionais que fornecem argumentos adicionais para a função lambda. Array(T)

Valor retornado

Retorna o produto dos elementos no array de origem ou, se fornecida, o produto dos elementos resultantes da função lambda. Float64

Exemplos

Exemplo básico

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

24

Uso com função lambda

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

16

Introduzido em: v1.1.0

Adiciona um item ao final do array.

Sintaxe

arrayPushBack(arr, x)

Argumentos

• arr — O array ao qual o valor x será adicionado ao final. Array(T)
• x —
• Valor único a ser adicionado ao final do array. Array(T).

Valor retornado

Retorna um array idêntico a arr, mas com um valor adicional x no final do array Array(T)

Exemplos

Exemplo de uso

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

['a','b']

Introduzido em: v1.1.0

Adiciona um elemento no início do array.

Sintaxe

arrayPushFront(arr, x)

Argumentos

• arr — O array ao qual o valor x será adicionado ao final. Array(T). - x —
• Valor único a ser adicionado ao início do array. Array(T).

Valor retornado

Retorna um array idêntico a arr, mas com um valor adicional x no início do array Array(T)

Exemplos

Exemplo de uso

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

['a','b']

Introduzido em: v20.4.0

Calcula a área sob a curva ROC (receiver operating characteristic). Uma curva ROC é gerada ao traçar a Taxa de Verdadeiros Positivos (TPR) no eixo y e a Taxa de Falsos Positivos (FPR) no eixo x para todos os limiares. O valor resultante varia de zero a um, e valores mais altos indicam melhor desempenho do modelo.

A ROC AUC (também conhecida simplesmente como AUC) é um conceito de aprendizado de máquina. Para mais detalhes, consulte aqui, aqui e aqui.

Sintaxe

arrayROCAUC(scores, labels[, scale[, partial_offsets]])

Aliases: arrayAUC

Argumentos

• scores — Pontuações geradas pelo modelo de predição. Array((U)Int*) ou Array(Float*)
• labels — Rótulos das amostras, geralmente 1 para amostra positiva e 0 para amostra negativa. Array((U)Int*) ou Enum
• scale — Opcional. Determina se a área normalizada deve ser retornada. Se for false, retorna a área sob a curva TP (verdadeiros positivos) x FP (falsos positivos). Valor padrão: true. Bool
• partial_offsets —
• Um array de quatro inteiros não negativos para calcular uma área parcial sob a curva ROC (equivalente a uma faixa vertical no espaço ROC) em vez da AUC completa. Essa opção é útil para o cálculo distribuído da ROC AUC. O array deve conter os seguintes elementos [higher_partitions_tp, higher_partitions_fp, total_positives, total_negatives]. Array de Integers não negativos. Opcional.
  • higher_partitions_tp: O número de rótulos positivos nas partições com pontuações mais altas.
  • higher_partitions_fp: O número de rótulos negativos nas partições com pontuações mais altas.
  • total_positives: O número total de amostras positivas em todo o conjunto de dados.
  • total_negatives: O número total de amostras negativas em todo o conjunto de dados.

Valor retornado

Retorna a área sob a curva ROC (receiver operating characteristic). Float64

Exemplos

Exemplo de uso

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

0.75

Introduzido em: v23.10.0

Retorna um subconjunto com samples elementos aleatórios de um array de entrada. Se samples exceder o tamanho do array de entrada, o tamanho da amostra será limitado ao tamanho do array, ou seja, todos os elementos do array serão retornados, mas a ordem deles não é garantida. A função pode lidar tanto com arrays simples quanto com arrays aninhados.

Sintaxe

arrayRandomSample(arr, samples)

Argumentos

• arr — O array de entrada ou array multidimensional do qual serão amostrados os elementos. Array(T)
• samples — O número de elementos a incluir na amostra aleatória. (U)Int*

Valor retornado

Um array contendo uma amostra aleatória de elementos do array de entrada Array(T)

Exemplos

Exemplo de uso

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

['cherry','apple']

Usando um array multidimensional

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

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

Introduzido em: v1.1.0

Aplica uma função de agregação aos elementos de um array e retorna o resultado. O nome da função de agregação é fornecido como uma string entre aspas simples: 'max', 'sum'. Ao usar funções de agregação paramétricas, o parâmetro é indicado após o nome da função, entre parênteses: 'uniqUpTo(6)'.

Sintaxe

arrayReduce(agg_f, arr1[, arr2, ... , arrN])

Argumentos

• agg_f — O nome de uma função de agregação, que deve ser uma constante. String
• arr1[, arr2, ... , arrN] — N arrays correspondentes aos argumentos de agg_f. Array(T)

Valor retornado

Retorna o resultado da função de agregação

Exemplos

Exemplo de uso

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

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

Exemplo com função de agregação usando vários argumentos

--Se uma função de agregação recebe múltiplos argumentos, ela deve ser aplicada a múltiplos arrays de mesmo tamanho.

SELECT arrayReduce('maxIf', [3, 5], [1, 0]);

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

Exemplo com uma função de agregação paramétrica

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

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

Introduzido em: v20.4.0

Aplica uma função de agregação aos elementos do array nos intervalos especificados e retorna um array contendo o resultado correspondente a cada intervalo. A função retornará o mesmo resultado que várias chamadas de arrayReduce(agg_func, arraySlice(arr1, index, length), ...).

Sintaxe

arrayReduceInRanges(agg_f, ranges, arr1[, arr2, ... ,arrN])

Argumentos

• agg_f — O nome da função de agregação a ser usada. String
• ranges — O intervalo no qual agregar. Um array de tuplas (i, r) contendo o índice i a partir do qual começar e o intervalo r no qual agregar. Array(T) ou Tuple(T)
• arr1[, arr2, ... ,arrN] — N arrays como argumentos da função de agregação. Array(T)

Valor retornado

Retorna um array contendo os resultados da função de agregação nos intervalos especificados Array(T)

Exemplos

Exemplo de uso

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

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

Introduzido em: v25.11.0

Remove todos os elementos de um array iguais a um determinado valor. NULLs são tratados como iguais.

Sintaxe

arrayRemove(arr, elem)

Aliases: array_remove

Argumentos

• arr — Array(T) - elem — T

Valor retornado

Retorna um subconjunto do array de origem Array(T)

Exemplos

Exemplo 1

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

[1,3]

Exemplo 2

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

['a','b']

Introduzido em: v1.1.0

Altera o tamanho do array.

Sintaxe

arrayResize(arr, size[, extender])

Argumentos

• arr — Array a ser redimensionado. Array(T)
• size — -O novo tamanho do array. Se size for menor que o tamanho original do array, o array será truncado à direita. Se size for maior que o tamanho inicial do array, o array será estendido à direita com valores de extender ou com valores padrão do tipo de dado dos itens do array.
• extender — Valor a ser usado para estender o array. Pode ser NULL.

Valor retornado

Um array de tamanho size. Array(T)

Exemplos

Exemplo 1

SELECT arrayResize([1], 3);

[1,0,0]

Exemplo 2

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

[1,NULL,NULL]

Introduzido em: v1.1.0

Inverte a ordem dos elementos de um array.

Sintaxe

arrayReverse(arr)

Argumentos

• arr — O array a ser revertido. Array(T)

Valor retornado

Retorna um array do mesmo tamanho que o array original, com os elementos em ordem inversa Array(T)

Exemplos

Exemplo de uso

SELECT arrayReverse([1, 2, 3])

[3,2,1]

Introduzido em: v20.1.0

A função arrayReverseFill processa sequencialmente um array de origem do último elemento até o primeiro, avaliando uma condição lambda em cada posição com base nos elementos dos arrays de origem e de condição. Quando a condição resulta em falso na posição i, a função substitui esse elemento pelo elemento na posição i+1 do estado atual do array. O último elemento é sempre preservado, independentemente de qualquer condição.

Sintaxe

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

Argumentos

• func(x[, y1, ..., yN]) — Uma função lambda que opera sobre os elementos do array de origem (x) e dos arrays de condição (y). função lambda
• source_arr — O array de origem a ser processado. Array(T)
• [, cond1_arr, ... , condN_arr] — Opcional. N arrays de condição que fornecem argumentos adicionais para a função lambda. Array(T)

Valor retornado

Retorna um array com os elementos do array de origem substituídos pelos resultados da função lambda. Array(T)

Exemplos

Exemplo com um único array

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

[1,2,2,NULL]

Exemplo com dois arrays

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

[5,6,6,2]

Introduzido na versão: v1.1.0

Ordena os elementos de um array em ordem decrescente. Se uma função f for especificada, o array fornecido será ordenado de acordo com o resultado da função aplicada aos elementos do array, e depois o array ordenado será invertido. Se f aceitar vários argumentos, a função arrayReverseSort receberá vários arrays aos quais os argumentos de func corresponderão.

Se o array a ser ordenado contiver -Inf, NULL, NaN ou Inf, eles serão ordenados na seguinte ordem:

1. -Inf
2. Inf
3. NaN
4. NULL

arrayReverseSort é uma função de ordem superior.

Sintaxe

arrayReverseSort([f,] arr [, arr1, ... ,arrN])

Argumentos

• f(y1[, y2 ... yN]) — A função lambda a ser aplicada aos elementos do array x. - arr — Um array a ser classificado. Array(T) - arr1, ..., arrN — Opcional. N arrays adicionais, caso f aceite vários argumentos.

Valor retornado

Retorna o array x classificado em ordem decrescente se nenhuma função lambda for fornecida; caso contrário, retorna um array classificado de acordo com a lógica da função lambda fornecida e, em seguida, invertido. Array(T).

Exemplos

Exemplo 1

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

[5,3,4]

Exemplo 2

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

[4,3,5]

Introduzido em: v20.1.0

Divide um array de origem em vários arrays. Quando func(x[, y1, ..., yN]) retorna algo diferente de zero, o array será dividido à direita do elemento. O array não será dividido após o último elemento.

Sintaxe

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

Argumentos

• func(x[, y1, ..., yN]) — Uma função lambda que opera nos elementos do array de origem (x) e dos arrays de condição (y). Função lambda
• source_arr — O array de origem a ser processado. Função lambda
• [, cond1_arr, ... , condN_arr] — Opcional. N arrays de condição que fornecem argumentos adicionais para a função lambda. Array(T)

Valor retornado

Retorna um array de arrays. Array(Array(T))

Exemplos

Exemplo de uso

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

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

Introduzido em: v23.8.0

Rotaciona um array para a esquerda pelo número de elementos especificado. Valores negativos de n são tratados como uma rotação para a direita pelo valor absoluto de n.

Sintaxe

arrayRotateLeft(arr, n)

Argumentos

• arr — O array cujos elementos serão rotacionados.Array(T). - n — Número de elementos a rotacionar. (U)Int8/16/32/64.

Valor retornado

Um array rotacionado para a esquerda pelo número especificado de elementos Array(T)

Exemplos

Exemplo de uso

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

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

Valor negativo de n

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

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

Introduzido em: v23.8.0

Rotaciona um array para a direita em um número especificado de elementos. Valores negativos de n equivalem a uma rotação para a esquerda pelo valor absoluto de n.

Sintaxe

arrayRotateRight(arr, n)

Argumentos

• arr — O array cujos elementos serão rotacionados.Array(T). - n — Número de elementos a serem rotacionados. (U)Int8/16/32/64.

Valor retornado

Um array rotacionado para a direita pelo número especificado de elementos Array(T)

Exemplos

Exemplo de uso

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

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

Valor negativo de n

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

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

Introduzido em: v23.8.0

Desloca um array para a esquerda pelo número de elementos especificado. Os novos elementos são preenchidos com o argumento fornecido ou com o valor padrão do tipo de elemento do array. Se o número de elementos for negativo, o array será deslocado para a direita.

Sintaxe

arrayShiftLeft(arr, n[, default])

Argumentos

• arr — O array cujos elementos devem ser deslocados.Array(T). - n — Número de elementos a serem deslocados.(U)Int8/16/32/64. - default — Opcional. Valor padrão dos novos elementos.

Valor retornado

Um array deslocado para a esquerda pelo número especificado de elementos Array(T)

Exemplos

Exemplo de uso

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

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

Valor negativo de n

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

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

Usando um valor padrão

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

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

Introduzido em: v23.8.0

Desloca um array para a direita pelo número de elementos especificado. Os novos elementos são preenchidos com o argumento fornecido ou com o valor padrão do tipo de elemento do array. Se o número de elementos for negativo, o array é deslocado para a esquerda.

Sintaxe

arrayShiftRight(arr, n[, default])

Argumentos

• arr — O array cujos elementos devem ser deslocados. Array(T)
• n — Número de elementos a serem deslocados. (U)Int8/16/32/64
• default — Opcional. Valor padrão para os novos elementos.

Valor retornado

Um array deslocado para a direita pelo número de elementos especificado Array(T)

Exemplos

Exemplo de uso

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

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

Valor negativo de n

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

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

Usando um valor padrão

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

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

Introduzido em: v24.1.0

Gera um array de shingles (semelhantes a ngrams para strings), ou seja, subarrays consecutivos do array de entrada com um comprimento especificado.

Sintaxe

arrayShingles(arr, l)

Argumentos

• arr — Array a partir do qual será gerado um array de shingles. Array(T)
• l — O comprimento de cada shingle. (U)Int*

Valor retornado

Um array com os shingles gerados Array(T)

Exemplos

Exemplo de uso

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

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

Introduzido em: v23.2.0

Retorna um array do mesmo tamanho que o array original, com os elementos em ordem embaralhada. Os elementos são reordenados de modo que cada permutação possível tenha a mesma probabilidade de ocorrer.

Sintaxe

arrayShuffle(arr [, seed])

Argumentos

• arr — O array que será embaralhado. Array(T)
• seed (optional) — Opcional. A semente usada na geração de números aleatórios. Se não for fornecida, uma semente aleatória será usada. (U)Int*

Valor retornado

Array com os elementos embaralhados Array(T)

Exemplos

Exemplo sem seed (resultados instáveis)

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

[1,4,2,3]

Exemplo sem seed (resultados estáveis)

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

[3,2,1,4]

Introduzido em: v25.4.0

Calcula a similaridade entre dois arrays de 0 a 1 com base na distância de Levenshtein ponderada.

Sintaxe

arraySimilarity(from, to, from_weights, to_weights)

Argumentos

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

Valor retornado

Retorna a similaridade entre 0 e 1 entre os dois arrays, com base na distância de Levenshtein ponderada Float64

Exemplos

Exemplo de uso

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

0.2222222222222222

Introduzido em: v1.1.0

Retorna uma parte do array, incluindo elementos NULL.

O primeiro argumento também pode ser um QBit: o resultado é um QBit nas dimensões selecionadas (uma projeção para um subconjunto de dimensões). Nesse caso, offset e length devem ser constantes, pois a dimensão de um QBit faz parte de seu tipo, e a fatia deve selecionar pelo menos uma dimensão. Uma fatia alinhada aos limites dos grupos de stride do QBit mantém o stride e reutiliza os fluxos de planos de bits armazenados sem cópia.

Sintaxe

arraySlice(arr, offset [, length])

Argumentos

• arr — Array a ser fatiado. Array(T) ou QBit
• offset — Deslocamento a partir da borda do array. Um valor positivo indica um deslocamento à esquerda, e um valor negativo indica um recuo à direita. A numeração dos elementos do array começa em 1. (U)Int*
• length — O comprimento da fatia desejada. Se você especificar um valor negativo, a função retornará uma fatia aberta [offset, array_length - length]. Se você omitir o valor, a função retornará a fatia [offset, the_end_of_array]. (U)Int*

Valor retornado

Retorna uma fatia do array com length elementos a partir do offset especificado Array(T)

Exemplos

Exemplo de uso

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

[2,NULL,4]

Introduzido em: v1.1.0

Ordena os elementos do array fornecido em ordem crescente. Se uma função lambda f for especificada, a ordem de classificação será determinada pelo resultado da função lambda aplicada a cada elemento do array. Se a função lambda aceitar vários argumentos, a função arraySort receberá vários arrays aos quais os argumentos de f corresponderão.

Se o array a ser ordenado contiver -Inf, NULL, NaN ou Inf, eles serão ordenados na seguinte ordem:

1. -Inf
2. Inf
3. NaN
4. NULL

arraySort é uma função de ordem superior.

Sintaxe

arraySort([f,] arr [, arr1, ... ,arrN])

Argumentos

• f(y1[, y2 ... yN]) — A função lambda a ser aplicada aos elementos do array x. - arr — Um array a ser ordenado. Array(T) - arr1, ..., arrN — Opcional. N arrays adicionais, caso f aceite vários argumentos.

Valor retornado

Retorna o array arr ordenado em ordem crescente se nenhuma função lambda for fornecida; caso contrário, retorna um array ordenado de acordo com a lógica da função lambda fornecida. Array(T).

Exemplos

Exemplo 1

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

[0,1,3,3]

Exemplo 2

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

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

Exemplo 3

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

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

Introduzido em: v20.1.0

Divide um array de origem em vários arrays. Quando func(x [, y1, ..., yN]) retorna algo diferente de zero, o array é dividido antes do elemento. O array não será dividido antes do primeiro elemento.

Sintaxe

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

Argumentos

• func(x[, y1, ..., yN]) — Uma função lambda que opera sobre os elementos do array de origem (x) e dos arrays de condição (y).Função lambda. - source_arr — O array de origem a ser dividido Array(T). - [, cond1_arr, ... , condN_arr] — Opcional. N arrays de condição que fornecem argumentos adicionais para a função lambda. Array(T).

Valor retornado

Retorna um array de arrays Array(Array(T))

Exemplos

Exemplo de uso

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

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

Introduzido em: v21.1.0

Retorna a soma dos elementos do array de origem.

Se uma função lambda func for especificada, retorna a soma dos elementos dos resultados da função lambda.

Sintaxe

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

Argumentos

• func(x[, y1, ..., yN]) — Opcional. Uma função lambda que opera nos elementos do array de origem (x) e dos arrays de condição (y). Função lambda
• source_arr — O array de origem a ser processado. Array(T)
• , cond1_arr, ... , condN_arr] — Opcional. N arrays de condição que fornecem argumentos adicionais para a função lambda. Array(T)

Valor retornado

Retorna a soma dos elementos do array de origem ou, se fornecida, a soma dos elementos resultantes da função lambda.

Exemplos

Exemplo básico

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

10

Uso com função lambda

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

8

Introduzido em: v25.4.0

Aceita vários arrays e retorna um array com elementos que não estão presentes em todos os arrays de origem. O resultado contém apenas valores únicos.

Sintaxe

arraySymmetricDifference(arr1, arr2, ... , arrN)

Argumentos

• arrN — N arrays a partir dos quais o novo array é criado. Array(T).

Valor retornado

Retorna um array de elementos distintos que não estão presentes em todos os arrays de origem Array(T)

Exemplos

Exemplo de uso

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

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

Introduzido em: v26.6.0

Retorna um array com os K maiores elementos do array de entrada, em ordem decrescente. Se uma função lambda f for especificada, os elementos serão comparados com base no resultado de f aplicada a cada elemento. Se f aceitar vários argumentos, arrays adicionais serão passados para arrayTopK, e seus elementos corresponderão aos argumentos de f.

Os valores NULL são ignorados e não aparecem no resultado. O tamanho do resultado é, no máximo, K e pode ser menor quando o array de entrada contém menos elementos não nulos do que K. O tipo de elemento do resultado é a versão não Nullable do tipo de elemento de entrada.

arrayTopK é uma função de ordem superior.

Veja também arrayBottomK, que retorna os K menores elementos.

Sintaxe

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

Argumentos

• f(arr[, arr1, ... ,arrN]) — Opcional. Uma função lambda para calcular a chave de ordenação de cada elemento. Função lambda
• K — O número de maiores elementos a retornar. (U)Int8/16/32/64
• arr — Um array. Array(T)
• arr1, ... ,arrN — N arrays adicionais, caso f aceite vários argumentos. Array(T)

Valor retornado

Retorna até K elementos de arr com os maiores valores (ou os maiores resultados da função lambda), em ordem decrescente. Nulls são ignorados. O array retornado tem tipo de elemento T mesmo quando a entrada é do tipo Nullable(T).

Exemplos

simple_int

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

[7,5,3]

skip_nulls

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

[7,5,2]

fewer_than_k

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

[2,1]

lambda_simple

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

[1,3]

lambda_multi

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

['a','c']

Introduzido em: v26.4.0

Transpõe um array bidimensional.

Todos os arrays internos devem ter o mesmo comprimento.

Sintaxe

arrayTranspose(arr)

Argumentos

• arr — Um array bidimensional a ser transposto. Todos os arrays internos devem ter o mesmo comprimento. Array(Array(T))

Valor retornado

Um array bidimensional transposto em que o elemento [i][j] do resultado é igual ao elemento [j][i] do array de entrada. Array(Array(T))

Exemplos

Matriz quadrada

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

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

Matriz não quadrada

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

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

Elementos de String

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

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

Introduzido em: v24.10.0

Recebe vários arrays e retorna um array que contém todos os elementos presentes em qualquer um dos arrays de origem. O resultado contém apenas valores únicos.

Sintaxe

arrayUnion(arr1, arr2, ..., arrN)

Argumentos

• arrN — N arrays usados para criar o novo array. Array(T)

Valor retornado

Retorna um array com elementos distintos dos arrays de origem Array(T)

Exemplos

Exemplo de uso

SELECT
arrayUnion([-2, 1], [10, 1], [-2], []) as num_example,
arrayUnion(['hi'], [], ['hello', 'hi']) as str_example,
arrayUnion([1, 3, NULL], [2, 3, NULL]) as null_example

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

Introduzido em: v1.1.0

Quando é passado um único argumento, conta o número de elementos únicos no array. Quando são passados vários argumentos, conta o número de tuplas únicas formadas pelos elementos nas posições correspondentes de vários arrays.

Por exemplo, SELECT arrayUniq([1,2], [3,4], [5,6]) formará as seguintes tuplas:

• Posição 1: (1,3,5)
• Posição 2: (2,4,6)

Em seguida, contará o número de tuplas únicas. Neste caso, 2.

Todos os arrays passados devem ter o mesmo comprimento.

Sintaxe

arrayUniq(arr1[, arr2, ..., arrN])

Argumentos

• arr1 — Array em que se conta o número de elementos únicos. Array(T)
• [, arr2, ..., arrN] — Opcional. Arrays adicionais usadas para contar o número de tuplas únicas de elementos nas posições correspondentes em vários arrays. Array(T)

Valor retornado

Para um único argumento, retorna o número de elementos únicos. Para vários argumentos, retorna o número de tuplas únicas formadas por elementos nas posições correspondentes entre os arrays. UInt32

Exemplos

Argumento único

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

2

Vários argumentos

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

3

Introduzido em: v20.1.0

Cria um array de tamanho length preenchido com a constante x.

Sintaxe

arrayWithConstant(N, x)

Argumentos

• length — Número de elementos do array. (U)Int*
• x — O valor dos N elementos do array, de qualquer tipo.

Valor retornado

Retorna um Array com N elementos com valor x. Array(T)

Exemplos

Exemplo de uso

SELECT arrayWithConstant(3, 1)

[1,1,1]

Introduzido em: v20.1.0

Combina vários arrays em um único array. O array resultante contém os elementos correspondentes dos arrays de origem, agrupados em tuplas na ordem em que os argumentos são listados.

Sintaxe

arrayZip(arr1, arr2, ... , arrN)

Argumentos

• arr1, arr2, ... , arrN — N arrays a serem combinados em um único array. Array(T)

Valor retornado

Retorna um array com elementos dos arrays de origem agrupados em tuplas. Os tipos de dados na tupla são os mesmos dos arrays de entrada e seguem a mesma ordem em que os arrays são passados Array(T)

Exemplos

Exemplo de uso

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

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

Introduzido em: v20.1.0

Combina vários arrays em um único array, permitindo arrays não alinhados (arrays com comprimentos diferentes). O array resultante contém os elementos correspondentes dos arrays de origem agrupados em tuplas, na ordem em que os argumentos são listados.

Sintaxe

arrayZipUnaligned(arr1, arr2, ..., arrN)

Argumentos

• arr1, arr2, ..., arrN — N arrays a serem combinados em um único array. Array(T)

Valor retornado

Retorna um array com elementos dos arrays de origem agrupados em tuplas. Os tipos de dados na tupla são os mesmos dos arrays de entrada e seguem a mesma ordem em que os arrays são passados. Array(T) ou Tuple(T1, T2, ...)

Exemplos

Exemplo de uso

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

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

Introduzido em: v1.1.0

Retorna o número de elementos do array iguais a x. Equivalente a arrayCount(elem -> elem = x, arr).

Elementos NULL são tratados como valores distintos.

Sintaxe

countEqual(arr, x)

Argumentos

• arr — Array em que será feita a busca. Array(T)
• x — Valor no array a ser contado. Qualquer tipo.

Valor retornado

Retorna o número de elementos do array iguais a x UInt64

Exemplos

Exemplo de uso

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

2

Introduzido em: v1.1.0

Verifica se o array de entrada está vazio.

Um array é considerado vazio se não contiver nenhum elemento.

A função também funciona com strings ou UUIDs.

Sintaxe

empty(arr)

Argumentos

• arr — Array de entrada. Array(T)

Valor retornado

Retorna 1 para um array vazio ou 0 para um array não vazio UInt8

Exemplos

Exemplo de uso

SELECT empty([]);

1

Introduzido em: v1.1.0

Retorna um array de Date vazio

Sintaxe

emptyArrayDate()

Argumentos

• Nenhum.

Valor retornado

Um array vazio de Date. Array(T)

Exemplos

Exemplo de uso

SELECT emptyArrayDate()

[]

Introduzido em: v1.1.0

Retorna um array vazio de DateTime

Sintaxe

emptyArrayDateTime()

Argumentos

• Nenhum.

Valor retornado

Um array DateTime vazio. Array(T)

Exemplos

Exemplo de uso

SELECT emptyArrayDateTime()

[]

Introduzido em: v1.1.0

Retorna um array Float32 vazio

Sintaxe

emptyArrayFloat32()

Argumentos

• Nenhum.

Valor retornado

Um array vazio de Float32. Array(T)

Exemplos

Exemplo de uso

SELECT emptyArrayFloat32()

[]

Introduzido em: v1.1.0

Retorna um array Float64 vazio

Sintaxe

emptyArrayFloat64()

Argumentos

• Nenhum.

Valor retornado

Um array vazio de Float64. Array(T)

Exemplos

Exemplo de uso

SELECT emptyArrayFloat64()

[]

Introduzido em: v1.1.0

Retorna um array(Int16) vazio

Sintaxe

emptyArrayInt16()

Argumentos

• Nenhum.

Valor retornado

Um array Int16 vazio. Array(T)

Exemplos

Exemplo de uso

SELECT emptyArrayInt16()

[]

Introduzido em: v1.1.0

Retorna um array Int32 vazio

Sintaxe

emptyArrayInt32()

Argumentos

• Nenhum.

Valor retornado

Um array vazio de Int32. Array(T)

Exemplos

Exemplo de uso

SELECT emptyArrayInt32()

[]

Introduzido em: v1.1.0

Retorna um array Int64 vazio

Sintaxe

emptyArrayInt64()

Argumentos

• Nenhum.

Valor de retorno

Um array Int64 vazio. Array(T)

Exemplos

Exemplo de uso

SELECT emptyArrayInt64()

[]

Introduzido em: v1.1.0

Retorna um array(Int8) vazio

Sintaxe

emptyArrayInt8()

Argumentos

• Nenhum.

Valor retornado

Um array vazio de Int8. Array(T)

Exemplos

Exemplo de uso

SELECT emptyArrayInt8()

[]

Introduzido em: v1.1.0

Retorna um array vazio de String

Sintaxe

emptyArrayString()

Argumentos

• Nenhum.

Valor retornado

Um array vazio de String. Array(T)

Exemplos

Exemplo de uso

SELECT emptyArrayString()

[]

Introduzido em: v1.1.0

Aceita um array vazio e retorna um array com um único elemento, igual ao valor padrão.

Sintaxe

emptyArrayToSingle(arr)

Argumentos

• arr — Um array vazio. Array(T)

Valor retornado

Um array com um único valor do tipo padrão do Array. Array(T)

Exemplos

Exemplo básico

CREATE TABLE test (
  a Array(Int32),
  b Array(String),
  c Array(DateTime)
)
ENGINE = MergeTree
ORDER BY tuple();

INSERT INTO test VALUES ([], [], []);

SELECT emptyArrayToSingle(a), emptyArrayToSingle(b), emptyArrayToSingle(c) FROM test;

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

Introduzido em: v1.1.0

Retorna um array vazio de UInt16

Sintaxe

emptyArrayUInt16()

Argumentos

• Nenhum.

Valor retornado

Um array vazio de UInt16. Array(T)

Exemplos

Exemplo de uso

SELECT emptyArrayUInt16()

[]

Introduzido em: v1.1.0

Retorna um array vazio de UInt32

Sintaxe

emptyArrayUInt32()

Argumentos

• Nenhum.

Valor retornado

Um array vazio de UInt32. Array(T)

Exemplos

Exemplo de uso

SELECT emptyArrayUInt32()

[]

Introduzido em: v1.1.0

Retorna um array vazio de UInt64

Sintaxe

emptyArrayUInt64()

Argumentos

• Nenhum.

Valor retornado

Um array UInt64 vazio. Array(T)

Exemplos

Exemplo de uso

SELECT emptyArrayUInt64()

[]

Introduzido em: v1.1.0

Retorna um array UInt8 vazio

Sintaxe

emptyArrayUInt8()

Argumentos

• Nenhum.

Valor retornado

Um array UInt8 vazio. Array(T)

Exemplos

Exemplo de uso