Funções de array - ClickHouse Documentation

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

Query

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

Response

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

Uso incorreto

Query

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

Response

Received exception from server (version 25.4.3):
Code: 386. DB::Exception: Received from localhost:9000. DB::Exception:
There is no supertype for types Int32, DateTime, Int8 ...

arrayAUCPR

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.

Quando arr_partial_offsets é usado, arr_scores e arr_labels devem corresponder apenas a uma partição de todo o conjunto de dados, contendo um intervalo de pontuações. O conjunto de dados deve ser dividido em partições contíguas, em que cada partição contém o subconjunto de dados cujas pontuações se enquadram em um intervalo específico. Por exemplo:

Uma partição pode conter todas as pontuações no intervalo [0, 0.5).
Outra partição pode conter pontuações no intervalo [0.5, 1.0].

Valor retornado Retorna a área sob a curva de precisão-recall (PR). Float64 Exemplos Exemplo 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

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

Query

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

Response

Nem todos os elementos coincidem

Query

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

Response

arrayAutocorrelation

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

Query

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

Response

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

Simétrico

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

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

Query

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

Response

2.5

Uso com função lambda

Query

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

Response

6.5

arrayCompact

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

Query

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

Response

[1,nan,2,3]

arrayConcat

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

Query

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

Response

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

arrayCount

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

Query

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

Response

arrayCumSum

Introduzido em: v1.1.0 Retorna um array com as somas parciais (acumuladas) dos elementos no array de entrada. 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

Query

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

Response

[1, 2, 3, 4]

Com função lambda

Query

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

Response

[2, 6, 12]

arrayCumSumNonNegative

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

Query

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

Response

[1, 2, 0, 1]

Com lambda

Query

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

Response

[2, 0, 6]

arrayDifference

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

Query

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

Response

[0,1,1,1]

Exemplo de overflow causado pelo tipo de resultado Int64

Query

SELECT arrayDifference([0, 10000000000000000000]);

Response

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

arrayDistinct

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

Query

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

Response

[1,2,3]

arrayDotProduct

Introduzido em: v23.5.0 Retorna o produto escalar de dois arrays.

Os dois vetores devem ter o mesmo tamanho. Arrays e Tuples também podem conter tipos de elementos mistos.

Sintaxe

arrayDotProduct(v1, v2)

Argumentos

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

Valor retornado O produto escalar dos dois vetores.

O tipo de retorno é determinado pelos tipos dos argumentos. Se Arrays ou Tuples contiverem tipos de elemento mistos, o tipo do resultado será o supertipo.

(U)Int* ou Float* ou Decimal Exemplos Exemplo de Array

Query

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

Response

32    UInt16

Exemplo 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

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.

Arrays no ClickHouse são indexados a partir de 1.

Í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. Sintaxe

arrayElement(arr, n)

Argumentos

arr — O array em que pesquisar. Array(T). - n — Posição do elemento a ser obtido. (U)Int*.

Valor retornado Retorna um único array combinado a partir dos argumentos de array fornecidos Array(T) Exemplos Exemplo de uso

Query

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

Response

Indexação com índices negativos

Query

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

Response

Uso da notação [n]

Query

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

Response

Índice fora dos limites do array

Query

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

Response

arrayElementOrNull

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.

Arrays no ClickHouse são indexados a partir de 1.

Í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(arrays)

Argumentos

arrays — Número arbitrário de argumentos do tipo array. Array

Valor retornado Retorna um único array combinado a partir dos argumentos fornecidos. Array(T) Exemplos Exemplo de uso

Query

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

Response

Indexação com índices negativos

Query

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

Response

Índice fora dos limites do array

Query

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

Response

NULL

arrayEnumerate

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

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

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

Query

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

Response

[1,2,1,3]

arrayEnumerateDenseRanked

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

Query

-- Com clear_depth=1 e max_array_depth=1, o resultado é idêntico ao que arrayEnumerateDense produziria.

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

Response

[1,2,1,3]

Uso com array multidimensional

Query

-- Neste exemplo, arrayEnumerateDenseRanked é usado para obter um array indicando, para cada elemento do
-- array multidimensional, qual é sua posição entre os elementos de mesmo valor.
-- Para a primeira linha do array passado, [10, 10, 30, 20], a primeira linha correspondente do resultado é [1, 1, 2, 3],
-- indicando que 10 é o primeiro número encontrado nas posições 1 e 2, 30 é o segundo número encontrado na posição 3
-- e 20 é o terceiro número encontrado na posição 4.
-- Para a segunda linha, [40, 50, 10, 30], a segunda linha correspondente do resultado é [4,5,1,2], indicando que 40
-- e 50 são o quarto e o quinto números encontrados nas posições 1 e 2 dessa linha, que outro 10
-- (o primeiro número encontrado) está na posição 3 e 30 (o segundo número encontrado) está na última posição.

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

Response

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

Exemplo com clear_depth maior

Query

-- Alterar clear_depth=2 faz com que a enumeração ocorra separadamente para cada linha de novo.

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

Response

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

arrayEnumerateUniq

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

Query

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

Response

[1, 1, 2, 1]

Vários arrays

Query

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

Response

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

Agregação com ARRAY JOIN

Query

-- Cada ID de objetivo tem um cálculo do número de conversões (cada elemento na estrutura de dados aninhada Goals é um objetivo que foi atingido, ao qual nos referimos como uma conversão)
-- e o número de sessões. Sem o ARRAY JOIN, teríamos contado o número de sessões como sum(Sign). Mas neste caso específico,
-- as linhas foram multiplicadas pela estrutura aninhada Goals, portanto, para contar cada sessão apenas uma vez depois disso, aplicamos uma condição ao
-- valor da função arrayEnumerateUniq(Goals.ID).

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

Response

┌──GoalID─┬─Reaches─┬─Visits─┐
│   53225 │    3214 │   1097 │
│ 2825062 │    3188 │   1097 │
│   56600 │    2803 │    488 │
│ 1989037 │    2401 │    365 │
│ 2830064 │    2396 │    910 │
│ 1113562 │    2372 │    373 │
│ 3270895 │    2262 │    812 │
│ 1084657 │    2262 │    345 │
│   56599 │    2260 │    799 │
│ 3271094 │    2256 │    812 │
└─────────┴─────────┴────────┘

arrayEnumerateUniqRanked

Introduzido em: v20.1.0 Retorna um array (ou array multidimensional) com as mesmas dimensões do array de entrada, 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

Query

-- Com clear_depth=1 e max_array_depth=1, o resultado de arrayEnumerateUniqRanked
-- é idêntico ao que arrayEnumerateUniq retornaria para o mesmo array.

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

Response

[1, 1, 2]

Exemplo 2

Query

-- com clear_depth=1 e max_array_depth=1, o resultado de arrayEnumerateUniqRanked
-- é idêntico ao que arrayEnumerateUniq produziria para o mesmo array.

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

Response

[1, 1, 2]

Exemplo 3

Query

-- Neste exemplo, arrayEnumerateUniqRanked é usado para obter um array indicando,
-- para cada elemento do array multidimensional, qual é sua posição entre os elementos
-- de mesmo valor. Para a primeira linha do array fornecido, [1, 2, 3], o resultado
-- correspondente é [1, 1, 1], indicando que esta é a primeira vez que 1, 2 e 3 aparecem.
-- Para a segunda linha do array fornecido, [2, 2, 1], o resultado correspondente é [2, 3, 3],
-- indicando que 2 aparece pela segunda e terceira vez, e 1 aparece
-- pela segunda vez. Da mesma forma, para a terceira linha do array fornecido [3], o
-- resultado correspondente é [2], indicando que 3 aparece pela segunda vez.

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

Response

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

Exemplo 4

Query

-- Alterar clear_depth=2 faz com que os elementos sejam enumerados separadamente para cada linha.
SELECT arrayEnumerateUniqRanked(2,[[1, 2, 3],[2, 2, 1],[3]], 2);

Response

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

arrayExcept

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:

A ordem dos elementos de source é preservada
Duplicatas em source são preservadas se não existirem em except
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

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]

strings

Query

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

Response

['apple', 'cherry']

arrayExists

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

Query

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

Response

arrayFill

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

Query

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

Response

[1, 1, 2, 2]

Exemplo com dois 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

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

Query

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

Response

['abc World']

Exemplo 2

Query

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

Response

[2]

arrayFirst

Introduzido em: v1.1.0 Retorna o primeiro elemento no array de entrada para o qual func(x[, y1, y2, ... yN]) retorna verdadeiro; 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 λ é verdadeiro; caso contrário, retorna o valor padrão de T. Exemplos Exemplo de uso

Query

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

Response

Nenhuma correspondência

Query

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

Response

0 UInt8

arrayFirstIndex

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

Query

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

Response

Sem correspondência

Query

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

Response

arrayFirstOrNull

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

Query

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

Response

Sem correspondência

Query

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

Response

NULL Nullable(UInt8)

arrayFlatten

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

Query

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

Response

[1, 2, 3]

arrayFold

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(λ(acc, x1 [, x2, x3, ... xN]), arr1 [, arr2, arr3, ... arrN], acc)

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

Query

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

Response

Sequência 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 │
└───────────┘

Exemplo com vários arrays

Query

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

Response

arrayIntersect

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

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

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

Query

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

Response

0.3333333333333333

arrayJoin

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

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 afeta todas as cláusulas da consulta

Query

-- A função arrayJoin afeta todas as seções da consulta, incluindo a seção WHERE. Observe o resultado 2, mesmo que a subconsulta tenha retornado 1 linha.

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

Response

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

Usando várias funções arrayJoin

Query

- Uma consulta pode usar múltiplas funções arrayJoin. Nesse caso, a transformação é executada várias vezes e as linhas são multiplicadas.

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

Response

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

Resultados inesperados devido a otimizações

Query

-- Usar múltiplos arrayJoin com a mesma expressão pode não produzir o resultado esperado devido a otimizações.
-- Para esses casos, considere modificar a expressão de array repetida com operações extras que não afetam o resultado do join.
- e.g. arrayJoin(arraySort(arr)), arrayJoin(arrayConcat(arr, []))

SELECT
    arrayJoin(dice) as first_throw,
    /* arrayJoin(dice) as second_throw */ -- é tecnicamente correto, mas eliminará o conjunto de resultados
    arrayJoin(arrayConcat(dice, [])) as second_throw -- expressão intencionalmente alterada para forçar reavaliação
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 │
└─────────────┴──────────────┘

Usando a sintaxe ARRAY JOIN

Query

-- Observe a sintaxe ARRAY JOIN na consulta `SELECT` abaixo, que oferece possibilidades mais amplas.
-- ARRAY JOIN permite converter múltiplos arrays com o mesmo número de elementos de uma vez.

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

Response

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

Uso de Tuple

Query

-- Você também pode usar Tuple

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

Response

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

arrayLast

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

Query

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

Response

Nenhuma correspondência

Query

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

Response

0 UInt8

arrayLastIndex

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

Query

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

Response

Nenhuma correspondência

Query

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

Response

arrayLastOrNull

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

Query

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

Response

Nenhuma correspondência

Query

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

Response

NULL Nullable(UInt8)

arrayLevenshteinDistance

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

Query

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

Response

arrayLevenshteinDistanceWeighted

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

Query

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

Response

arrayMap

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

Query

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

Response

[3, 4, 5]

Criando uma tupla com elementos de arrays diferentes

Query

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

Response

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

arrayMax

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

Query

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

Response

Uso com função lambda

Query

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

Response

arrayMin

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

Query

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

Response

Uso com função lambda

Query

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

Response

arrayNormalizedGini

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

Query

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

Response

(0.18055555555555558, 0.2638888888888889, 0.6842105263157896)

arrayPartialReverseSort

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

Para manter apenas os elementos ordenados, use arrayResize.

Sintaxe

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

Argumentos

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

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

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

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:

Esta função não materializa constantes.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

Query

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

Response

[2, 4, 3, 1]

no_limit2

Query

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

Response

[4, 1, 3, 2]

random_seed

Query

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

Response

[3, 4, 1, 2]

explicit_seed

Query

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

Response

[3, 2, 1, 4]

materializar

Query

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

Response

┌─arrayPartial⋯4]), 2, 42)─┬─arrayPartial⋯ 3], 2, 42)─┐
│ [3,2,1,4]                │ [3,2,1]                  │
│ [3,2,1,4]                │ [3,2,1]                  │
│ [4,3,2,1]                │ [3,2,1]                  │
│ [1,4,3,2]                │ [3,2,1]                  │
│ [3,4,1,2]                │ [3,2,1]                  │
│ [1,2,3,4]                │ [3,2,1]                  │
│ [1,4,3,2]                │ [3,2,1]                  │
│ [1,4,3,2]                │ [3,2,1]                  │
│ [3,1,2,4]                │ [3,2,1]                  │
│ [1,3,2,4]                │ [3,2,1]                  │
└──────────────────────────┴──────────────────────────┘

arrayPartialSort

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

Para manter apenas os elementos classificados, use arrayResize.

Sintaxe

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

Argumentos

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

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

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

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

Query

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

Response

[1, 2]

arrayPopFront

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

Query

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

Response

[2, 3]

arrayProduct

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

Query

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

Response

Uso com função lambda

Query

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

Response

arrayPushBack

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

Somente números podem ser adicionados a um array de números, e somente strings podem ser adicionadas a um array de strings.
Ao adicionar números, o ClickHouse define automaticamente o tipo de x de acordo com o tipo de dado do array.
Pode ser NULL. A função adiciona um elemento NULL a um array, e o tipo dos elementos do array é convertido em Nullable.

Para mais informações sobre os tipos de dados no ClickHouse, consulte Tipos de dados.

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

Query

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

Response

['a','b']

arrayPushFront

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

Somente números podem ser adicionados a um array de números, e somente strings podem ser adicionadas a um array de strings.
Ao adicionar números, o ClickHouse define automaticamente o tipo de x de acordo com o tipo de dado do array.
Pode ser NULL. A função adiciona um elemento NULL ao array, e o tipo dos elementos do array é convertido para Nullable.

Para mais informações sobre os tipos de dados no ClickHouse, consulte Tipos de dados.

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

Query

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

Response

['a','b']

arrayROCAUC

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.

Quando arr_partial_offsets é usado, arr_scores e arr_labels devem corresponder apenas a uma partição de todo o conjunto de dados, contendo um intervalo de pontuações. O conjunto de dados deve ser dividido em partições contíguas, em que cada partição contém o subconjunto de dados cujas pontuações estão dentro de um intervalo específico. Por exemplo:

Uma partição pode conter todas as pontuações no intervalo [0, 0.5).
Outra partição pode conter pontuações no intervalo [0.5, 1.0].

Valor retornado Retorna a área sob a curva ROC (receiver operating characteristic). Float64 Exemplos Exemplo de uso

Query

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

Response

0.75

arrayRandomSample

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

Query

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

Response

['cherry','apple']

Usando um array multidimensional

Query

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

Response

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

arrayReduce

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

Query

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

Response

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

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

Query

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

Response

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

Exemplo com uma função de agregação 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

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

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

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

Query

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

Response

[1, 3]

Exemplo 2

Query

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

Response

['a', 'b']

arrayResize

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

Query

SELECT arrayResize([1], 3);

Response

[1,0,0]

Exemplo 2

Query

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

Response

[1,NULL,NULL]

arrayReverse

Introduzido em: v1.1.0 Inverte a ordem dos elementos de um array.

A função reverse(arr) realiza a mesma operação, mas também funciona com outros tipos de dados além de Arrays.

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

Query

SELECT arrayReverse([1, 2, 3])

Response

[3,2,1]

arrayReverseFill

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

Query

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

Response

[1, 2, 2, NULL]

Exemplo com dois 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

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:

-Inf
Inf
NaN
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, ..., yN — 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

Query

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

Response

[5,3,4]

Exemplo 2

Query

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

Response

[4,3,5]

arrayReverseSplit

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

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

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

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

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

Query

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

Response

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

Valor negativo de n

Query

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

Response

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

arrayShiftLeft

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

Query

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

Response

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

Valor negativo de n

Query

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

Response

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

Usando um valor padrão

Query

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

Response

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

arrayShiftRight

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

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]

Usando um valor padrão

Query

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

Response

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

arrayShingles

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

Query

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

Response

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

arrayShuffle

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.

Esta função não materializa constantes.

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)

Query

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

Response

[1,4,2,3]

Exemplo sem seed (resultados estáveis)

Query

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

Response

[3,2,1,4]

arraySimilarity

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

Query

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

Response

0.2222222222222222

arraySlice

Introduzido em: v1.1.0 Retorna uma parte do array, incluindo elementos NULL. Sintaxe

arraySlice(arr, offset [, length])

Argumentos

arr — Array a ser fatiado. Array(T)
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 tamanho 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

Query

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

Response

[2, NULL, 4]

arraySort

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:

-Inf
Inf
NaN
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, ..., yN — 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

Query

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

Response

[0,1,3,3]

Exemplo 2

Query

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

Response

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

Exemplo 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

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

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

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

Query

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

Response

Uso com função lambda

Query

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

Response

arraySymmetricDifference

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 entrada. O resultado contém apenas valores únicos.

A diferença simétrica de mais de dois conjuntos é definida matematicamente como o conjunto de todos os elementos de entrada que ocorrem em um número ímpar de conjuntos de entrada. Em contraste, a função arraySymmetricDifference simplesmente retorna o conjunto de elementos de entrada que não ocorrem em todos os conjuntos de entrada.

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

Query

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

Response

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

arrayTranspose

Introduzido em: v26.4.0 Transpõe um array de duas dimensões. 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

Query

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

Response

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

Matriz não quadrada

Query

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

Response

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

Elementos de String

Query

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

Response

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

arrayUnion

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

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

Introduzido em: v1.1.0 Quando é passado um único argumento, conta o número de elementos distintos no array. Quando são passados vários argumentos, conta o número de tuplas distintas 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.

Se você quiser obter uma lista de itens únicos em um array, pode usar arrayReduce('groupUniqArray', arr).

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

Query

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

Response

Vários argumentos

Query

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

Response

arrayWithConstant

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

Query

SELECT arrayWithConstant(3, 1)

Response

[1, 1, 1]

arrayZip

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

Query

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

Response

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

arrayZipUnaligned

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 entrada 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

Query

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

Response

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

countEqual

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

Query

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

Response

empty

Introduzido em: v1.1.0 Verifica se o array de entrada está vazio. Um array é considerado vazio se não contiver nenhum elemento.

Pode ser otimizada ao habilitar a configuração optimize_functions_to_subcolumns. Com optimize_functions_to_subcolumns = 1, a função lê apenas a subcoluna size0, em vez de ler e processar toda a coluna de array. A consulta SELECT empty(arr) FROM TABLE; é transformada em SELECT arr.size0 = 0 FROM TABLE;.

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

Query

SELECT empty([]);

Response

emptyArrayDate

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

Query

SELECT emptyArrayDate

Response

[]

emptyArrayDateTime

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

Query

SELECT emptyArrayDateTime

Response

[]

emptyArrayFloat32

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

Query

SELECT emptyArrayFloat32

Response

[]

emptyArrayFloat64

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

Query

SELECT emptyArrayFloat64

Response

[]

emptyArrayInt16

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

Query

SELECT emptyArrayInt16

Response

[]

emptyArrayInt32

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

Query

SELECT emptyArrayInt32

Response

[]

emptyArrayInt64

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

Query

SELECT emptyArrayInt64

Response

[]

emptyArrayInt8

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

Query

SELECT emptyArrayInt8

Response

[]

emptyArrayString

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

Query

SELECT emptyArrayString

Response

[]

emptyArrayToSingle

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

Query

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

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

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

Response

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

emptyArrayUInt16

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

Query

SELECT emptyArrayUInt16

Response

[]

emptyArrayUInt32

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

Query

SELECT emptyArrayUInt32

Response

[]

emptyArrayUInt64

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

Query

SELECT emptyArrayUInt64

Response

[]

emptyArrayUInt8

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

Query

SELECT emptyArrayUInt8

Response

[]

has

Introduzido em: v1.1.0 Retorna se o array contém o elemento especificado, se o map contém a chave especificada ou se o objeto JSON contém o caminho especificado. Para JSON, há suporte a caminhos aninhados usando notação de ponto (por exemplo, ‘a.b.c’). Quando o primeiro argumento é um array constante e o segundo argumento é uma coluna ou expressão, has(constant_array, column) se comporta como column IN (constant_array) e pode usar a chave primária e índices de data-skipping para otimização. Por exemplo, has([1, 10, 100], id) pode usar o índice da chave primária se id fizer parte da PRIMARY KEY. Essa otimização também se aplica quando a coluna é encapsulada em funções monotônicas (por exemplo, has([...], toDate(ts))). Sintaxe

has(haystack, needle)

Argumentos

haystack — O array, map ou JSON de origem. Array ou Map ou JSON
needle — O valor a ser procurado (elemento no array, chave no map ou string de caminho no JSON).

Valor retornado Retorna 1 se o haystack contiver o needle especificado; caso contrário, 0. UInt8 Exemplos Uso básico de Array

Query

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

Response

Array não encontrado

Query

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

Response

Uso básico do map

Query

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

Response

Caminho JSON

Query

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

Response

hasAll

Introduzido em: v1.1.0 Verifica se um array é subconjunto de outro array.

Um array vazio é subconjunto de qualquer array.
NULL é processado como um valor.
A ordem dos valores em ambos os arrays não importa.

Sintaxe

hasAll(set, subset)

Argumentos

set — Array de qualquer tipo com um conjunto de elementos. Array(T)
subset — Array de qualquer tipo que compartilha um supertipo comum com set, contendo elementos que devem ser verificados para determinar se são um subconjunto de set. Array(T)

Valor retornado

1, se set contiver todos os elementos de subset.
0, caso contrário.

Gera uma exceção NO_COMMON_TYPE se os elementos de set e subset não compartilharem um supertipo comum. Exemplos Arrays vazios

Query

SELECT hasAll([], [])

Response

Arrays com valores NULL

Query

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

Response

Arrays com valores de um tipo diferente

Query

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

Response

Arrays com valores String

Query

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

Response

Arrays sem um tipo em comum

Query

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

Response

Lança uma exceção NO_COMMON_TYPE

Array de arrays

Query

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

Response

hasAny

Introduzido em: v1.1.0 Verifica se dois arrays têm algum elemento em comum.

Null é processado como um valor.
A ordem dos valores em ambos os arrays não importa.

Sintaxe

hasAny(arr_x, arr_y)

Argumentos

arr_x — Array de qualquer tipo com um conjunto de elementos. Array(T)
arr_y — Array de qualquer tipo que tenha um supertipo comum com o array arr_x. Array(T)

Valor retornado

1, se arr_x e arr_y tiverem pelo menos um elemento em comum.
0, caso contrário.

Gera uma exceção NO_COMMON_TYPE se algum dos elementos dos dois arrays não tiver um supertipo comum. Exemplos Um array está vazio

Query

SELECT hasAny([1], [])

Response

Arrays com valores NULL

Query

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

Response

Arrays que contêm valores de tipos diferentes

Query

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

Response

Arrays sem um tipo em comum

Query

SELECT hasAny([[1, 2], [3, 4]], ['a', 'c'])

Response

Lança uma exceção `NO_COMMON_TYPE`

Array de Arrays

Query

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

Response

hasSubstr

Introduzido em: v20.6.0 Verifica se todos os elementos de array2 aparecem em array1 exatamente na mesma ordem. Portanto, a função retornará 1 se, e somente se, array1 = prefixo + array2 + sufixo. Em outras palavras, a função verifica se todos os elementos de array2 estão contidos em array1, como na função hasAll. Além disso, verifica se os elementos aparecem na mesma ordem em array1 e array2.

A função retornará 1 se array2 estiver vazio.
NULL é processado como um valor. Em outras palavras, hasSubstr([1, 2, NULL, 3, 4], [2,3]) retornará 0. No entanto, hasSubstr([1, 2, NULL, 3, 4], [2,NULL,3]) retornará 1
A ordem dos valores em ambos os arrays importa.

Gera uma exceção NO_COMMON_TYPE se algum elemento dos dois arrays não tiver um supertipo comum. Sintaxe

hasSubstr(arr1, arr2)

Argumentos

arr1 — Array de qualquer tipo com um conjunto de elementos. Array(T)
arr2 — Array de qualquer tipo com um conjunto de elementos. Array(T)

Valor retornado Retorna 1 se o array arr1 contiver o array arr2. Caso contrário, retorna 0. UInt8 Exemplos Ambos os arrays estão vazios

Query

SELECT hasSubstr([], [])

Response

Arrays com valores NULL

Query

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

Response

Arrays com valores de um tipo diferente

Query

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

Response

Arrays com strings

Query

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

Response

Arrays com ordem válida

Query

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

Response

Arrays com ordenação inválida

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 sem tipo comum

Query

SELECT hasSubstr([1, 2, NULL, 3, 4], ['a'])

Response

Lança uma exceção `NO_COMMON_TYPE`

indexOf

Introduzido em: v1.1.0 Retorna o índice do primeiro elemento com valor ‘x’ (a partir de 1), se ele estiver no array. Se o array não contiver o valor pesquisado, a função retorna 0. Elementos definidos como NULL são tratados como valores normais. Sintaxe

indexOf(arr, x)

Argumentos

arr — Um array no qual buscar x. Array(T)
x — Valor do primeiro elemento em arr correspondente a x cujo índice deve ser retornado. UInt64

Valor retornado Retorna o índice (numerado a partir de 1) da primeira ocorrência de x em arr, se existir. Caso contrário, retorna 0. UInt64 Exemplos Exemplo básico

Query

SELECT indexOf([5, 4, 1, 3], 3)

Response

Array com valores NULL

Query

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

Response

indexOfAssumeSorted

Introduzido em: v24.12.0 Retorna o índice do primeiro elemento com valor ‘x’ (a partir de 1) se ele estiver no array. Se o array não contiver o valor pesquisado, a função retornará 0.

Ao contrário da função indexOf, esta função pressupõe que o array está ordenado em ordem crescente. Se o array não estiver ordenado, os resultados serão indefinidos.

Sintaxe

indexOfAssumeSorted(arr, x)

Argumentos

arr — Um array ordenado no qual será feita a busca. Array(T)
x — Valor do primeiro elemento correspondente em arr ordenado cujo índice deve ser retornado. UInt64

Valor retornado Retorna o índice (contado a partir de um) da primeira ocorrência de x em arr, se ela existir. Caso contrário, retorna 0. UInt64 Exemplos Exemplo básico

Query

SELECT indexOfAssumeSorted([1, 3, 3, 3, 4, 4, 5], 4)

Response

kql_array_sort_asc

Introduzido em: v23.10.0 Ordena um ou mais arrays em ordem crescente. O primeiro array é ordenado, e os arrays subsequentes são reorganizados para seguir a ordem do primeiro array após a ordenação. Os valores NULL são colocados no final. Esta é uma função de compatibilidade com KQL (Kusto Query Language). Sintaxe

kql_array_sort_asc(array1[, array2, ..., nulls_last])

Argumentos

array1 — O array a ser ordenado. Array(T)
array2 — Opcional. Arrays adicionais a serem reordenados de acordo com a ordenação de array1. Array(T)
nulls_last — Opcional. Um valor booleano que indica se os valores NULL devem aparecer por último. O padrão é true. UInt8

Valor retornado Retorna uma tupla de arrays ordenados em ordem crescente. Tuple(Array, ...) Exemplos Uso básico

Query

SELECT kql_array_sort_asc([3, 1, 2])

Response

([1, 2, 3])

kql_array_sort_desc

Introduzido em: v23.10.0 Ordena um ou mais arrays em ordem decrescente. O primeiro array é ordenado, e os arrays subsequentes são reordenados para corresponder à ordem do primeiro array após a ordenação. Os valores NULL são colocados no final. Esta é uma função de compatibilidade com KQL (Kusto Query Language). Sintaxe

kql_array_sort_desc(array1[, array2, ..., nulls_last])

Argumentos

array1 — O array a ser ordenado. Array(T)
array2 — Arrays adicionais opcionais a serem reordenados de acordo com a ordem de array1. Array(T)
nulls_last — Booleano opcional que indica se os valores nulos devem aparecer por último. O padrão é true. UInt8

Valor retornado Retorna uma tupla de arrays ordenados em ordem decrescente. Tuple(Array, ...) Exemplos Uso básico

Query

SELECT kql_array_sort_desc([3, 1, 2])

Response

([3, 2, 1])

length

Introduzido em: v1.1.0 Calcula o comprimento de uma string ou array.

Para argumentos String ou FixedString: calcula o número de bytes da string.
Para argumentos Array: calcula o número de elementos do array.
Se aplicada a um argumento FixedString, a função é uma expressão constante.

Observe que o número de bytes em uma string não é o mesmo que o número de “pontos de código” Unicode, nem o mesmo que o número de “clusters de grafemas” Unicode (o que normalmente chamamos de “caracteres”), nem o mesmo que a largura visível da string. Não há problema em haver bytes NULL ASCII em strings, e eles também serão contados. Sintaxe

length(x)

Aliases: OCTET_LENGTH Argumentos

x — Valor para o qual se calcula o número de bytes (para String/FixedString) ou de elementos (para Array). String ou FixedString ou Array(T)

Valor retornado Retorna o número de bytes na String/FixedString x / o número de elementos no array x UInt64 Exemplos Exemplo com String

Query

SELECT length('Hello, world!')

Response

Exemplo de Array

Query

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

Response

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

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

exemplo de ascii_vs_utf8

Query

SELECT 'ábc' AS str, length(str), lengthUTF8(str)

Response

┌─str─┬─length(str)──┬─lengthUTF8(str)─┐
│ ábc │            4 │               3 │
└─────┴──────────────┴─────────────────┘

notEmpty

Introduzido em: v1.1.0 Verifica se o array de entrada não está vazio. Um array é considerado não vazio se contiver pelo menos um elemento.

Pode ser otimizada ativando a configuração optimize_functions_to_subcolumns. Com optimize_functions_to_subcolumns = 1, a função lê apenas a subcoluna size0, em vez de ler e processar toda a coluna do tipo array. A consulta SELECT notEmpty(arr) FROM table é transformada em SELECT arr.size0 != 0 FROM TABLE.

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

notEmpty(arr)

Argumentos

arr — Array de entrada. Array(T)

Valor retornado Retorna 1 para um array não vazio ou 0 para um array vazio UInt8 Exemplos Exemplo de uso

Query

SELECT notEmpty([1,2]);

Response

range

Introduzido em: v1.1.0 Retorna um array de números de start até end - 1, com passo step. Os tipos compatíveis são:

UInt8/16/32/64
Int8/16/32/64]
Todos os argumentos start, end e step devem ser de um dos tipos compatíveis acima. Os elementos do array retornado serão de um supertipo dos argumentos.
É lançada uma exceção se a função retornar um array com comprimento total maior que o número de elementos especificado pela configuração function_range_max_elements_in_block.
Retorna NULL se algum argumento tiver o tipo Nullable(nothing). É lançada uma exceção se algum argumento tiver o valor NULL (tipo Nullable(T)).

Sintaxe

range([start, ] end [, step])

Argumentos

start — Opcional. O primeiro elemento do array. Obrigatório se step for usado. Valor padrão: 0. - end — Obrigatório. O número-limite antes do qual o array é construído. - step — Opcional. Determina o passo entre cada elemento do array. Valor padrão: 1.

Valor retornado Array de números de start a end - 1, com passo step. Array(T) Exemplos Exemplo 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

Introduzido em: v1.1.0 Cria um array com um único valor. Sintaxe

replicate(x, arr)

Argumentos

x — O valor usado para preencher o array de resultado. Any
arr — Um array. Array(T)

Valor retornado Retorna um array com o mesmo tamanho de arr, preenchido com o valor x. Array(T) Exemplos Exemplo de uso

Query

SELECT replicate(1, ['a', 'b', 'c']);

Response

┌─replicate(1, ['a', 'b', 'c'])───┐
│ [1, 1, 1]                       │
└─────────────────────────────────┘

reverse

Introduzido em: v1.1.0 Inverte a ordem dos elementos da array de entrada ou dos caracteres da string de entrada. Sintaxe

reverse(arr | str)

Argumentos

arr | str — O array ou a string de entrada. Array(T) ou String

Valor retornado Retorna um array ou uma string com a ordem dos elementos ou dos caracteres invertida. Exemplos Inverter um array

Query

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

Response

[4, 3, 2, 1]

Inverter string

Query

SELECT reverse('abcd');

Response

'dcba'

Funções de distância

Todas as funções suportadas estão descritas na documentação sobre funções de distância.

​array

​arrayAUCPR

​arrayAll

​arrayAutocorrelation

​arrayAvg

​arrayCompact

​arrayConcat

​arrayCount

​arrayCumSum

​arrayCumSumNonNegative

​arrayDifference

​arrayDistinct

​arrayDotProduct

​arrayElement

​arrayElementOrNull

​arrayEnumerate

​arrayEnumerateDense

​arrayEnumerateDenseRanked

​arrayEnumerateUniq

​arrayEnumerateUniqRanked

​arrayExcept

​arrayExists

​arrayFill

​arrayFilter

​arrayFirst

​arrayFirstIndex

​arrayFirstOrNull

​arrayFlatten

​arrayFold

​arrayIntersect

​arrayJaccardIndex

​arrayJoin

​arrayLast

​arrayLastIndex

​arrayLastOrNull

​arrayLevenshteinDistance

​arrayLevenshteinDistanceWeighted

​arrayMap

​arrayMax

​arrayMin

​arrayNormalizedGini

​arrayPartialReverseSort

​arrayPartialShuffle

​arrayPartialSort

​arrayPopBack

​arrayPopFront

​arrayProduct

​arrayPushBack

​arrayPushFront

​arrayROCAUC

​arrayRandomSample

​arrayReduce

​arrayReduceInRanges

​arrayRemove

​arrayResize

​arrayReverse

​arrayReverseFill

​arrayReverseSort

​arrayReverseSplit

​arrayRotateLeft

​arrayRotateRight

​arrayShiftLeft

​arrayShiftRight

​arrayShingles

​arrayShuffle

​arraySimilarity

​arraySlice

​arraySort

​arraySplit

​arraySum

​arraySymmetricDifference

​arrayTranspose

​arrayUnion

​arrayUniq

​arrayWithConstant

​arrayZip

​arrayZipUnaligned

​countEqual

​empty

​emptyArrayDate

array

arrayAUCPR

arrayAll

arrayAutocorrelation

arrayAvg

arrayCompact

arrayConcat

arrayCount

arrayCumSum

arrayCumSumNonNegative

arrayDifference

arrayDistinct

arrayDotProduct

arrayElement

arrayElementOrNull

arrayEnumerate

arrayEnumerateDense

arrayEnumerateDenseRanked

arrayEnumerateUniq

arrayEnumerateUniqRanked

arrayExcept

arrayExists

arrayFill

arrayFilter

arrayFirst

arrayFirstIndex

arrayFirstOrNull

arrayFlatten

arrayFold

arrayIntersect

arrayJaccardIndex

arrayJoin

arrayLast

arrayLastIndex

arrayLastOrNull

arrayLevenshteinDistance

arrayLevenshteinDistanceWeighted

arrayMap

arrayMax

arrayMin

arrayNormalizedGini

arrayPartialReverseSort

arrayPartialShuffle

arrayPartialSort

arrayPopBack

arrayPopFront

arrayProduct

arrayPushBack

arrayPushFront

arrayROCAUC

arrayRandomSample

arrayReduce

arrayReduceInRanges

arrayRemove

arrayResize

arrayReverse

arrayReverseFill

arrayReverseSort

arrayReverseSplit

arrayRotateLeft

arrayRotateRight

arrayShiftLeft

arrayShiftRight

arrayShingles

arrayShuffle

arraySimilarity

arraySlice

arraySort

arraySplit

arraySum

arraySymmetricDifference

arrayTranspose

arrayUnion

arrayUniq

arrayWithConstant

arrayZip

arrayZipUnaligned

countEqual

empty

emptyArrayDate