Funções de array

Documentação sobre funções de array

​

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

┌─a───────────────────────────┬─toTypeName(a)─────────────────────────┐
│ [5,'1998-06-16 00:00:00',5] │ Array(Variant(DateTime, Int32, 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 menos que uma pontuação seja NaN, caso em que o resultado é NaN. 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), ou NaN se alguma pontuação for NaN. 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

1

Nem todos os elementos coincidem

Query

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

Response

0

​

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

​

arrayBottomK

Introduzido em: v26.6.0

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

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

arrayBottomK é uma função de ordem superior.

Veja também:

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

Sintaxe

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

Argumentos

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

Valor retornado

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

Exemplos

simple_int

Query

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

Response

[1,2,3]

skip_nulls

Query

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

Response

[1,2,5]

fewer_than_k

Query

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

Response

[1,2]

lambda_simple

Query

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

Response

[9,5]

lambda_multi

Query

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

Response

['b','c']

​

arrayCompact

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

5

​

arrayCumSum

Introduzido em: v1.1.0

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

Sintaxe

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

Argumentos

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

Valor retornado

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

Exemplos

Uso básico

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

Valor retornado

O produto escalar dos dois vetores.

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. Dois arrays BFloat16 acumulam em Float32 e retornam Float32 (a mesma regra que para dois arrays Float32).

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

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

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

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

O operador [n] fornece a mesma funcionalidade.

O primeiro argumento também pode ser:

• um Map: m['key'] retorna o valor armazenado para key ou o valor padrão do tipo do valor quando a chave está ausente.
• um QBit: q[n] reconstrói o n-ésimo elemento do vetor com a precisão total do tipo de elemento QBit, lendo apenas os planos de bits do grupo de stride que o contém.
• um JSON ou um Nullable(JSON): json['key'] retorna o valor armazenado no caminho key, que deve ser uma string constante, exatamente como faz a notação de ponto json.key. Para um Nullable(JSON), o resultado segue as mesmas regras de nulidade de json.key: um caminho que pode representar NULL (Dynamic ou um caminho tipado que pode ser encapsulado em Nullable) produz NULL para as linhas NULL externas, enquanto um caminho tipado não nulo, como Array ou Map, mantém ali seu valor padrão. A chave também pode ser um Nullable(String) constante; uma chave NULL produz NULL. O acesso aninhado pode ser encadeado: json['a']['b'].

Sintaxe

arrayElement(arr, n)

Argumentos

• arr — O valor do qual ler um elemento. Array(T), Map(K, V), QBit, JSON ou Nullable(JSON). - n — Posição do elemento a ser obtido ou um array de posições. As posições podem ser Nullable. (U)Int* ou Array((U)Int*). Para um argumento Map, uma chave do tipo K; para um argumento JSON, um caminho constante do tipo String.

Valor retornado

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

Exemplos

Exemplo de uso

Query

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

Response

2

Indexação com índices negativos

Query

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

Response

3

Uso da notação [n]

Query

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

Response

2

Índice fora dos limites do array

Query

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

Response

0

Array de índices

Query

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

Response

[20,40,10]

Acesso a chave de map

Query

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

Response

2

Acesso a JSON por colchetes

Query

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

Response

42

​

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, desde que o tipo de resultado possa ser Nullable. Para tipos de elemento que ainda não são Nullable e não podem ser envolvidos por Nullable (como Array, Map), o valor padrão do tipo de elemento será retornado.

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

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.

O primeiro argumento também pode ser um Map: uma chave ausente resulta em NULL em vez do valor padrão do tipo do valor, desde que esse tipo possa ser encapsulado em Nullable. JSON não é compatível aqui; use arrayElement nesse caso.

Sintaxe

arrayElementOrNull(arr, n)

Argumentos

• arr — O valor do qual ler um elemento. Array(T) ou Map(K, V). - n — Posição do elemento a ser obtido ou um array de posições. As posições podem ser Nullable. (U)Int* ou Array((U)Int*). Para um argumento Map, uma chave do tipo K.

Valor retornado

Quando n é escalar, retorna Nullable(T) se T puder ser encapsulado em Nullable; caso contrário, T. Quando n é um array, retorna Array(Nullable(T)) se T puder ser encapsulado em Nullable; caso contrário, Array(T). Para um Map, a mesma regra se aplica ao tipo de valor V. Any ou Nullable(T) ou Array(T) ou Array(Nullable(T))

Exemplos

Exemplo de uso

Query

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

Response

2

Indexação com índices negativos

Query

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

Response

3

Índice fora dos limites do array

Query

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

Response

\N

Array de índices

Query

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

Response

[10,NULL,20]

Chave ausente no map

Query

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

Response

\N

​

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

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

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

Response

[1,2,1,3]

Uso com array multidimensional

Query

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

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

Response

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

Exemplo com clear_depth maior

Query

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

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

Response

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

​

arrayEnumerateUniq

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

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

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

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

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

Response

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

​

arrayEnumerateUniqRanked

Introduzido em: v20.1.0

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

Sintaxe

arrayEnumerateUniqRanked(clear_depth, arr, max_array_depth)

Argumentos

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

Valor retornado

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

Exemplos

Exemplo 1

Query

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

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

Response

[1,1,2]

Exemplo 2

Query

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

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

Response

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

Exemplo 3

Query

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

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

Response

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

Exemplo 4

Query

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

Response

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

​

arrayExcept

Introduzido em: v25.9.0

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

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

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

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

Sintaxe

arrayExcept(source, except)

Argumentos

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

Valor retornado

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

Exemplos

básico

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

0

​

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 origem para o qual func(x[, y1, y2, ... yN]) retorna true; caso contrário, retorna um valor padrão.

Sintaxe

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

Argumentos

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

Valor retornado

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

Exemplos

Exemplo de uso

Query

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

Response

b

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

2

Sem correspondência

Query

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

Response

0

​

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

b

Sem correspondência

Query

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

Response

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

​

arrayFlattenedLength

Introduzido em: v26.9.0

Retorna o número total de elementos de um array multidimensional, como se ele tivesse sido achatado com a função arrayFlatten.

Função:

• Aplica-se a arrays aninhados com qualquer profundidade.
• É equivalente a length para arrays que já estão achatados.
• Considera apenas o aninhamento de Array. Os elementos são contados no primeiro nível que não é um array. Portanto, os elementos de um Map, Tuple, Dynamic ou Variant aninhado não são contados individualmente, mesmo que eles próprios contenham arrays.

É o equivalente a cardinality no PostgreSQL, enquanto no ClickHouse cardinality é um alias de length e conta apenas os elementos do array mais externo.

Sintaxe

arrayFlattenedLength(arr)

Argumentos

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

Valor retornado

Retorna o número de elementos do array após o achatamento de todos os arrays aninhados. UInt64

Exemplos

Array aninhado

Query

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

Response

4

Aninhamento mais profundo

Query

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

Response

3

Array plano

Query

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

Response

3

Elementos que não são arrays não são percorridos

Query

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

Response

1

​

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

23

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

300

​

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.

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

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

Esta função é não determinística: pode retornar resultados diferentes para os mesmos argumentos.

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

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

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

Response

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

Usando várias funções arrayJoin

Query

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

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

Response

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

Resultados inesperados devido a otimizações

Query

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

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

Response

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

Usando a sintaxe ARRAY JOIN

Query

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

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

Response

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

Uso de Tuple

Query

-- You can also use Tuple

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

Response

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

​

arrayLast

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

c

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

3

Nenhuma correspondência

Query

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

Response

0

​

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

c

Nenhuma correspondência

Query

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

Response

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

1

​

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

14

​

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

7

Uso com função lambda

Query

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

Response

12

​

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

2

Uso com função lambda

Query

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

Response

4

​

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.

Esta função não é determinística: pode retornar resultados diferentes para os mesmos argumentos.

Sintaxe

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

Argumentos

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

Valor retornado

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

Exemplos

simple_int

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.

Esta função é não determinística: pode retornar resultados diferentes para os mesmos argumentos.

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

[2,3,4,1]

random_seed

Query

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

Response

[3, 4, 1, 2]

explicit_seed

Query

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

Response

[3,2,1,4]

materializar

Query

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

Response

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

​

arrayPartialSort

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 ordenados, use arrayResize.

Esta função é não determinística: pode retornar resultados diferentes para os mesmos argumentos.

Sintaxe

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

Argumentos

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

Valor retornado

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

Exemplos

simple_int

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_ordenado

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

24

Uso com função lambda

Query

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

Response

16

​

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. Com scale definido como true, que é o padrão, o valor resultante varia de zero a um, e valores mais altos indicam melhor desempenho do modelo; o resultado é NaN quando a ROC AUC é indefinida, por exemplo, quando não há rótulos positivos ou não há rótulos negativos. Uma pontuação NaN sempre produz um resultado NaN.

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). Retorna NaN se alguma pontuação for NaN e, quando scale for true, também quando a ROC AUC é indefinida porque não há rótulos positivos ou não há rótulos negativos. 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.

Esta função é não determinística: pode retornar resultados diferentes para os mesmos argumentos.

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:

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

arrayReverseSort é uma função de ordem superior.

Sintaxe

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

Argumentos

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

Valor retornado

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

Exemplos

Exemplo 1

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.

Esta função é não determinística: pode retornar resultados diferentes para os mesmos argumentos.

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.

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

Sintaxe

arraySlice(arr, offset [, length])

Argumentos

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

Valor retornado

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

Exemplos

Exemplo de uso

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:

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

arraySort é uma função de ordem superior.

Sintaxe

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

Argumentos

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

Valor retornado

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

Exemplos

Exemplo 1

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

10

Uso com função lambda

Query

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

Response

8

​

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

​

arrayTopK

Introduzido em: v26.6.0

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

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

arrayTopK é uma função de ordem superior.

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

Sintaxe

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

Argumentos

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

Valor retornado

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

Exemplos

simple_int

Query

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

Response

[7,5,3]

skip_nulls

Query

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

Response

[7,5,2]

fewer_than_k

Query

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

Response

[2,1]

lambda_simple

Query

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

Response

[1,3]

lambda_multi

Query

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

Response

['a','c']

​

arrayTranspose

Introduzido em: v26.4.0

Transpõe um array bidimensional.

Todos os arrays internos devem ter o mesmo comprimento.

Sintaxe

arrayTranspose(arr)

Argumentos

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

Valor retornado

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

Exemplos

Matriz quadrada

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 únicos no array. Quando são passados vários argumentos, conta o número de tuplas únicas formadas pelos elementos nas posições correspondentes de vários arrays.

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

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

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

Todos os arrays passados devem ter o mesmo comprimento.

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

2

Vários argumentos

Query

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

Response

3

​

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 origem agrupados em tuplas. Os tipos de dados na tupla são os mesmos dos arrays de entrada e seguem a mesma ordem em que os arrays são passados. Array(T) ou Tuple(T1, T2, ...)

Exemplos

Exemplo de uso

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

2

​

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

1

​

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

1

Array não encontrado

Query

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

Response

0

Uso básico do map

Query

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

Response

1

Caminho JSON

Query

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

Response

1

​

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

1

Arrays com valores NULL

Query

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

Response

1

Arrays com valores de um tipo diferente

Query

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

Response

1

Arrays com valores String

Query

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

Response

1

Arrays sem um tipo em comum

Query

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

Response

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

Array de arrays

Query

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

Response

0

​

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

0

Arrays com valores NULL

Query

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

Response

1

Arrays que contêm valores de tipos diferentes

Query

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

Response

1

Arrays sem um tipo em comum

Query

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

Response

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

Array de Arrays

Query

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

Response

1

​

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

1

Arrays com valores NULL

Query

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

Response

1

Arrays com valores de um tipo diferente

Query

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

Response

0

Arrays com strings

Query

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

Response

1

Arrays com ordem válida

Query

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

Response

1

Arrays com ordenação inválida

Query

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

Response

0

Array de arrays

Query

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

Response

1

Arrays sem tipo comum

Query

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

Response

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

​

indexOf

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.

Elementos NaN não seguem a regra de NULL acima. Uma comparação escalar entre dois valores NaN (NaN = NaN) é 0, mas indexOf ainda pode reportar um elemento NaN como encontrado. Esse comportamento é um detalhe de implementação. Não dependa de um comportamento específico. Para encontrar um, teste-o: arrayFirstIndex(x -> isNaN(x), arr) retorna sua posição; arrayExists(x -> isNaN(x), arr), uma flag.

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

4

Array com valores NULL

Query

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

Response

3

​

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

5

​

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.
• Para argumentos QBit: calcula a dimensão do vetor.
• Se aplicada a um argumento FixedString ou QBit, 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, CARDINALITY

Argumentos

• x — Valor para o qual se calcula o número de bytes (para String/FixedString), de elementos (para Array) ou a dimensão (para QBit). String ou FixedString ou Array(T) ou QBit

Valor retornado

Retorna o número de bytes na String/FixedString x, o número de elementos no array x ou a dimensão do QBit x UInt64

Exemplos

Exemplo com String

Query

SELECT length('Hello, world!')

Response

13

Exemplo de Array

Query

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

Response

2

Exemplo de QBit

Query

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

Response

8

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

1

​

notHas

Introduzido em: v26.8.0

Retorna se o array não contém o elemento especificado, se o map não contém a chave especificada ou se o objeto JSON não contém o caminho especificado. É a negação de has.

Sintaxe

notHas(haystack, needle)

Argumentos

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

Valor retornado

Retorna 1 se o haystack não contiver o needle especificado; caso contrário, retorna 0. UInt8

Exemplos

Uso básico de Array

Query

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

Response

0

Array não encontrada

Query

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

Response

1

Uso básico de map

Query

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

Response

1

Uso básico de JSON

Query

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

Response

0

​

randomHadamardTransform

Introduzido em: v26.7.0

Aplica uma transformada de Hadamard aleatorizada a um vetor de ponto flutuante: y = (1/sqrt(k)) * (H * D * x), em que D é uma matriz diagonal de sinais determinísticos +/-1 escolhidos por seed, e H é a transformada de Walsh-Hadamard.

A transformada é uma rotação ortogonal que preserva a norma, distribuindo a energia de um vetor uniformemente entre as coordenadas, de modo que a distribuição por coordenada se torne aproximadamente Gaussiana e independente dos dados. Ela é útil como etapa de pré-processamento antes da quantização escalar e — quando truncada — como uma projeção aleatória de Johnson-Lindenstrauss / Hadamard aleatorizada subamostrada (SRHT).

A transformada completa (sem truncamento) mantém o comprimento da entrada. Ela é exata para os seguintes comprimentos:

• uma potência de dois (uma transformada rápida simples de Walsh-Hadamard);
• 2^k * m com m em {12, 20} (ordens que têm uma matriz de Hadamard +/-1, por exemplo 768 = 64 * 12, 1536 = 128 * 12, 3072 = 256 * 12, 2560 = 128 * 20), aplicada como a transformada de Kronecker exata H_(2^k) (x) H_m (sem multiplicações em ponto flutuante);
• 2^k * m com qualquer outro m ímpar até 64 (ordens que não têm uma matriz de Hadamard +/-1 — elas existem apenas para ordens 1, 2 e múltiplos de 4), aplicada como a transformada de Kronecker exata H_(2^k) (x) C_m, em que C_m é uma matriz ortogonal real da Transformada Discreta de Hartley. Isso cobre as famílias de embeddings restantes, como 3584 = 512 * 7, 1152 = 128 * 9, 1408 = 128 * 11.

Uma transformada completa de um comprimento cujo maior fator ímpar excede 64 não tem forma exata e exigiria preenchimento com zeros até uma potência de dois maior; ela é rejeitada com uma exceção em vez de retornar silenciosamente um vetor mais longo. Use um comprimento compatível ou passe output_dims para calcular uma projeção truncada de um comprimento arbitrário (veja abaixo).

O resultado tem o mesmo tipo de elemento da entrada; um array de entrada vazio retorna um array vazio (output_dims não se aplica a ele).

• seed (opcional, padrão 0): seleciona o padrão de sinais; a mesma seed sempre produz a mesma transformada.
• output_dims (opcional, com padrão igual ao comprimento da transformada): mantém apenas as primeiras output_dims coordenadas, convertendo a transformada em uma projeção aleatória que aceita qualquer comprimento. O fator de escala 1/sqrt(output_dims) faz com que o resultado preserve a norma na transformada completa e preserve a norma em expectativa quando truncado. Ele não deve exceder o comprimento da transformada. Como um prefixo truncado do fator de Transformada Discreta de Hartley C_m não tem a alavancagem uniforme de uma matriz de Hadamard +/-1, um output_dims truncado em um comprimento da família Hartley (ou em qualquer comprimento sem fator exato) usa a transformada com preenchimento com zeros até uma potência de dois, que de fato preserva essa propriedade.

Sintaxe

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

Argumentos

• vector — Vetor a ser transformado. Array(BFloat16) ou Array(Float32) ou Array(Float64)
• seed — Opcional. Semente usada para os sinais determinísticos de +/-1 (padrão: 0). UInt*
• output_dims — Opcional. Trunca o resultado para este número de coordenadas iniciais (padrão: o comprimento total da transformada, que é igual ao comprimento da entrada para qualquer dimensão compatível). Passar output_dims também habilita a transformada para comprimentos que não têm uma forma exata de transformada completa. UInt*

Valor retornado

O vetor transformado (com o mesmo tipo de elemento da entrada). Seu comprimento é o comprimento da transformada (o comprimento da entrada para uma transformada completa de uma dimensão compatível), opcionalmente truncado para output_dims. Array(BFloat16) ou Array(Float32) ou Array(Float64)

Exemplos

Transformada completa para um comprimento que é potência de dois

Query

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

Response

4

A norma é mantida

Query

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

Response

0

Projeção truncada para 3 dimensões (aceita qualquer comprimento)

Query

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

Response

3

Transformada exata para dimensão 2^k * m mantém o comprimento da entrada (sem padding)

Query

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

Response

1152

​

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.