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])
x1 — Valor constante de qualquer tipo T. Se apenas este argumento for fornecido, o array será do tipo T. - [, x2, ..., xN] — N valores constantes adicionais que compartilham um supertipo comum com x1
Valor retornado
Retorna um array, em que ‘T’ é o tipo comum mais específico entre os argumentos fornecidos. Array(T)
Exemplos
Uso válido
SELECT array(toInt32(1), toUInt16(2), toInt8(3)) AS a, toTypeName(a)
┌─a───────┬─toTypeName(a)─┐
│ [1,2,3] │ Array(Int32) │
└─────────┴───────────────┘
SELECT array(toInt32(5), toDateTime('1998-06-16'), toInt8(5)) AS a, toTypeName(a)
Received exception from server (version 25.4.3):
Code: 386. DB::Exception: Received from localhost:9000. DB::Exception:
There is no supertype for types Int32, DateTime, Int8 ...
arrayAUCPR(scores, labels[, partial_offsets])
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].
Float64
Exemplos
Exemplo de uso
SELECT arrayAUCPR([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1]);
┌─arrayAUCPR([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1])─┐
│ 0.8333333333333333 │
└─────────────────────────────────────────────────┘
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])
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 lambdasource_arr — O array de origem a ser processado. Array(T)cond1_arr, ... — Opcional. N arrays de condição que fornecem argumentos adicionais para a função lambda. Array(T)
Valor retornado
Retorna 1 se a função lambda retornar verdadeiro para todos os elementos; caso contrário, 0 UInt8
Exemplos
Todos os elementos satisfazem a condição
SELECT arrayAll(x, y -> x=y, [1, 2, 3], [1, 2, 3])
SELECT arrayAll(x, y -> x=y, [1, 2, 3], [1, 1, 1])
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])
arr — Array de números. Array(T)max_lag — Opcional. Número máximo de defasagens a calcular. Deve ser um inteiro não negativo. Integer
Valor retornado
Retorna um array de Float64. Retorna NaN se a variância for 0. Array(Float64)
Exemplos
Linear
SELECT arrayAutocorrelation([1, 2, 3, 4, 5]);
[1, 0.4, -0.1, -0.4, -0.4]
SELECT arrayAutocorrelation([10, 20, 10]);
[1, -0.6666666666666669, 0.16666666666666674]
SELECT arrayAutocorrelation([5, 5, 5]);
SELECT arrayAutocorrelation([1, 2, 3, 4, 5], 2);
func for especificada, retorna a média dos elementos resultantes da lambda.
Sintaxe
arrayAvg([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])
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 lambdasource_arr — O array de origem a ser processado. Array(T)[, cond1_arr, ... , condN_arr] — Opcional. N arrays de condição que fornecem argumentos adicionais para a função lambda. Array(T)
Valor retornado
Retorna a média dos elementos no array de origem ou, se fornecida, a média dos resultados da função lambda. Float64
Exemplos
Exemplo básico
SELECT arrayAvg([1, 2, 3, 4]);
SELECT arrayAvg(x, y -> x*y, [2, 3], [2, 3]) AS res;
null. A ordem dos valores no array resultante é determinada pela ordem dos elementos no array de origem.
Sintaxe
Argumentos
arr — Um array do qual serão removidos os valores duplicados. Array(T)
Valor retornado
Retorna um array sem valores duplicados Array(T)
Exemplos
Exemplo de uso
SELECT arrayCompact([1, 1, nan, nan, 2, 3, 3, 3]);
arrayConcat(arr1 [, arr2, ... , arrN])
arr1 [, arr2, ... , arrN] — N arrays para concatenar. Array(T)
Valor retornado
Retorna um único array combinado a partir dos argumentos de array fornecidos. Array(T)
Exemplos
Exemplo de uso
SELECT arrayConcat([1, 2], [3, 4], [5, 6]) AS res
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, ...)
func — Opcional. Função a ser aplicada a cada elemento do(s) array(s). Função lambdaarr1, ..., arrN — N arrays. Array(T)
Valor retornado
Retorna o número de elementos para os quais func retorna verdadeiro. Caso contrário, retorna o número de elementos não zero no array. UInt32
Exemplos
Exemplo de uso
SELECT arrayCount(x -> (x % 2), groupArray(number)) FROM numbers(10)
arrayCumSum([func,] arr1[, arr2, ... , arrN])
func — Opcional. Uma função lambda a ser aplicada aos elementos do array em cada posição. Função lambdaarr1 — O array de origem de valores numéricos. Array(T)[arr2, ..., arrN] — Opcional. Arrays adicionais do mesmo tamanho, passados como argumentos para a função lambda, se especificada. Array(T)
Valor retornado
Retorna um array com as somas parciais dos elementos do array de origem. O tipo do resultado corresponde ao tipo numérico do array de entrada. Array(T)
Exemplos
Uso básico
SELECT arrayCumSum([1, 1, 1, 1]) AS res
SELECT arrayCumSum(x -> x * 2, [1, 2, 3]) AS res
arrayCumSumNonNegative([func,] arr1[, arr2, ... , arrN])
func — Opcional. Uma função lambda a ser aplicada aos elementos do array em cada posição. Função lambdaarr1 — O array de origem de valores numéricos. Array(T)[arr2, ..., arrN] — Opcional. Arrays adicionais do mesmo tamanho, passados como argumentos para a função lambda, se ela for especificada. Array(T)
Valor retornado
Retorna um array com as somas parciais dos elementos do array de origem, com qualquer soma acumulada negativa substituída por zero. O tipo do resultado corresponde ao tipo numérico do array de entrada. Array(T)
Exemplos
Uso básico
SELECT arrayCumSumNonNegative([1, 1, -4, 1]) AS res
SELECT arrayCumSumNonNegative(x -> x * 2, [1, -2, 3]) AS res
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
Argumentos
arr — Array para o qual serão calculadas as diferenças entre elementos adjacentes. Array(T)
Valor retornado
Retorna um array com as diferenças entre elementos adjacentes do array UInt*
Exemplos
Exemplo de uso
SELECT arrayDifference([1, 2, 3, 4]);
SELECT arrayDifference([0, 10000000000000000000]);
┌─arrayDifference([0, 10000000000000000000])─┐
│ [0,-8446744073709551616] │
└────────────────────────────────────────────┘
arr — Array da qual extrair elementos distintos. Array(T)
Valor retornado
Retorna um array contendo os elementos distintos Array(T)
Exemplos
Exemplo de uso
SELECT arrayDistinct([1, 2, 2, 3, 1]);
Os dois vetores devem ter o mesmo tamanho. Arrays e Tuples também podem conter tipos de elementos mistos.
O tipo de retorno é determinado pelos tipos dos argumentos. Se Arrays ou Tuples contiverem tipos de elemento mistos, o tipo do resultado será o supertipo.
(U)Int* ou Float* ou Decimal
Exemplos
Exemplo de Array
SELECT arrayDotProduct([1, 2, 3], [4, 5, 6]) AS res, toTypeName(res);
SELECT dotProduct((1::UInt16, 2::UInt8, 3::Float32),(4::Int16, 5::Float32, 6::UInt8)) AS res, toTypeName(res);
n, em que n pode ser de qualquer tipo inteiro.
Se o índice estiver fora dos limites de um array, a função retornará um valor padrão (0 para números, uma string vazia para strings etc.),
exceto no caso de argumentos com um array não constante e um índice constante 0. Nesse caso, ocorrerá o erro Array indices are 1-based.
Arrays no ClickHouse são indexados a partir de 1.
arr[-1] é o último item do array.
O operador [n] fornece a mesma funcionalidade.
Sintaxe
Argumentos
arr — O array em que pesquisar. Array(T). - n — Posição do elemento a ser obtido. (U)Int*.
Valor retornado
Retorna um único array combinado a partir dos argumentos de array fornecidos Array(T)
Exemplos
Exemplo de uso
SELECT arrayElement(arr, 2) FROM (SELECT [1, 2, 3] AS arr)
SELECT arrayElement(arr, -1) FROM (SELECT [1, 2, 3] AS arr)
SELECT arr[2] FROM (SELECT [1, 2, 3] AS arr)
SELECT arrayElement(arr, 4) FROM (SELECT [1, 2, 3] AS arr)
n, em que n pode ser qualquer tipo inteiro.
Se o índice estiver fora dos limites do array, NULL será retornado em vez de um valor padrão.
Arrays no ClickHouse são indexados a partir de 1.
arr[-1] é o último item do array.
Sintaxe
arrayElementOrNull(arrays)
arrays — Número arbitrário de argumentos do tipo array. Array
Valor retornado
Retorna um único array combinado a partir dos argumentos fornecidos. Array(T)
Exemplos
Exemplo de uso
SELECT arrayElementOrNull(arr, 2) FROM (SELECT [1, 2, 3] AS arr)
SELECT arrayElementOrNull(arr, -1) FROM (SELECT [1, 2, 3] AS arr)
SELECT arrayElementOrNull(arr, 4) FROM (SELECT [1, 2, 3] AS arr)
[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
Argumentos
arr — O array a ser enumerado. Array
Valor retornado
Retorna o array [1, 2, 3, ..., length (arr)]. Array(UInt32)
Exemplos
Exemplo básico com ARRAY JOIN
CREATE TABLE test
(
`id` UInt8,
`tag` Array(String),
`version` Array(String)
)
ENGINE = MergeTree
ORDER BY id;
INSERT INTO test VALUES (1, ['release-stable', 'dev', 'security'], ['2.4.0', '2.6.0-alpha', '2.4.0-sec1']);
SELECT
id,
tag,
version,
seq
FROM test
ARRAY JOIN
tag,
version,
arrayEnumerate(tag) AS seq
┌─id─┬─tag────────────┬─version─────┬─seq─┐
│ 1 │ release-stable │ 2.4.0 │ 1 │
│ 1 │ dev │ 2.6.0-alpha │ 2 │
│ 1 │ security │ 2.4.0-sec1 │ 3 │
└────┴────────────────┴─────────────┴─────┘
arr, indicando onde cada elemento aparece pela primeira vez no array de origem Array(T)
Exemplos
Exemplo de uso
SELECT arrayEnumerateDense([10, 20, 10, 30])
arrayEnumerateDenseRanked
arrayEnumerateDenseRanked(clear_depth, arr, max_array_depth)
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
-- Com clear_depth=1 e max_array_depth=1, o resultado é idêntico ao que arrayEnumerateDense produziria.
SELECT arrayEnumerateDenseRanked(1,[10, 20, 10, 30],1);
-- Neste exemplo, arrayEnumerateDenseRanked é usado para obter um array indicando, para cada elemento do
-- array multidimensional, qual é sua posição entre os elementos de mesmo valor.
-- Para a primeira linha do array passado, [10, 10, 30, 20], a primeira linha correspondente do resultado é [1, 1, 2, 3],
-- indicando que 10 é o primeiro número encontrado nas posições 1 e 2, 30 é o segundo número encontrado na posição 3
-- e 20 é o terceiro número encontrado na posição 4.
-- Para a segunda linha, [40, 50, 10, 30], a segunda linha correspondente do resultado é [4,5,1,2], indicando que 40
-- e 50 são o quarto e o quinto números encontrados nas posições 1 e 2 dessa linha, que outro 10
-- (o primeiro número encontrado) está na posição 3 e 30 (o segundo número encontrado) está na última posição.
SELECT arrayEnumerateDenseRanked(1,[[10,10,30,20],[40,50,10,30]],2);
-- Alterar clear_depth=2 faz com que a enumeração ocorra separadamente para cada linha de novo.
SELECT arrayEnumerateDenseRanked(2,[[10,10,30,20],[40,50,10,30]],2);
[[1, 1, 2, 3], [1, 2, 3, 4]]
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])
arr1 — Primeiro array a ser processado. Array(T)arr2, ... — Opcional. Arrays adicionais do mesmo tamanho para unicidade de tuplas. Array(UInt32)
Valor retornado
Retorna um array em que cada elemento representa a posição entre os elementos com o mesmo valor ou tupla. Array(T)
Exemplos
Uso básico
SELECT arrayEnumerateUniq([10, 20, 10, 30]);
SELECT arrayEnumerateUniq([1, 1, 1, 2, 2, 2], [1, 1, 2, 1, 1, 2]);
-- Cada ID de objetivo tem um cálculo do número de conversões (cada elemento na estrutura de dados aninhada Goals é um objetivo que foi atingido, ao qual nos referimos como uma conversão)
-- e o número de sessões. Sem o ARRAY JOIN, teríamos contado o número de sessões como sum(Sign). Mas neste caso específico,
-- as linhas foram multiplicadas pela estrutura aninhada Goals, portanto, para contar cada sessão apenas uma vez depois disso, aplicamos uma condição ao
-- valor da função arrayEnumerateUniq(Goals.ID).
SELECT
Goals.ID AS GoalID,
sum(Sign) AS Reaches,
sumIf(Sign, num = 1) AS Visits
FROM test.visits
ARRAY JOIN
Goals,
arrayEnumerateUniq(Goals.ID) AS num
WHERE CounterID = 160656
GROUP BY GoalID
ORDER BY Reaches DESC
LIMIT 10
┌──GoalID─┬─Reaches─┬─Visits─┐
│ 53225 │ 3214 │ 1097 │
│ 2825062 │ 3188 │ 1097 │
│ 56600 │ 2803 │ 488 │
│ 1989037 │ 2401 │ 365 │
│ 2830064 │ 2396 │ 910 │
│ 1113562 │ 2372 │ 373 │
│ 3270895 │ 2262 │ 812 │
│ 1084657 │ 2262 │ 345 │
│ 56599 │ 2260 │ 799 │
│ 3271094 │ 2256 │ 812 │
└─────────┴─────────┴────────┘
arrayEnumerateUniqRanked(clear_depth, arr, max_array_depth)
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
-- Com clear_depth=1 e max_array_depth=1, o resultado de arrayEnumerateUniqRanked
-- é idêntico ao que arrayEnumerateUniq retornaria para o mesmo array.
SELECT arrayEnumerateUniqRanked(1, [1, 2, 1], 1);
-- com clear_depth=1 e max_array_depth=1, o resultado de arrayEnumerateUniqRanked
-- é idêntico ao que arrayEnumerateUniq produziria para o mesmo array.
SELECT arrayEnumerateUniqRanked(1, [[1, 2, 3], [2, 2, 1], [3]], 2);", "[[1, 1, 1], [2, 3, 2], [2]]
-- Neste exemplo, arrayEnumerateUniqRanked é usado para obter um array indicando,
-- para cada elemento do array multidimensional, qual é sua posição entre os elementos
-- de mesmo valor. Para a primeira linha do array fornecido, [1, 2, 3], o resultado
-- correspondente é [1, 1, 1], indicando que esta é a primeira vez que 1, 2 e 3 aparecem.
-- Para a segunda linha do array fornecido, [2, 2, 1], o resultado correspondente é [2, 3, 3],
-- indicando que 2 aparece pela segunda e terceira vez, e 1 aparece
-- pela segunda vez. Da mesma forma, para a terceira linha do array fornecido [3], o
-- resultado correspondente é [2], indicando que 3 aparece pela segunda vez.
SELECT arrayEnumerateUniqRanked(1, [[1, 2, 3], [2, 2, 1], [3]], 2);
[[1, 1, 1], [2, 3, 2], [2]]
-- Alterar clear_depth=2 faz com que os elementos sejam enumerados separadamente para cada linha.
SELECT arrayEnumerateUniqRanked(2,[[1, 2, 3],[2, 2, 1],[3]], 2);
[[1, 1, 1], [1, 2, 1], [1]]
source que não estão presentes em except, preservando a ordem original.
Esta função realiza uma operação de diferença de conjuntos entre dois arrays. Para cada elemento em source, ela verifica se esse elemento existe em except (usando comparação exata). Caso não exista, o elemento é incluído no resultado.
A operação mantém as seguintes propriedades:
- A ordem dos elementos de
source é preservada
- Duplicatas em
source são preservadas se não existirem em except
- NULL é tratado como um valor distinto
Sintaxe
arrayExcept(source, except)
source — O array de entrada que contém os elementos a serem filtrados. Array(T)except — O array que contém os elementos a serem excluídos do resultado. Array(T)
Valor retornado
Retorna um array do mesmo tipo que o array de entrada, contendo os elementos de source que não foram encontrados em except. Array(T)
Exemplos
básico
SELECT arrayExcept([1, 2, 3, 2, 4], [3, 5])
SELECT arrayExcept([1, NULL, 2, NULL], [2])
SELECT arrayExcept([1, NULL, 2, NULL], [NULL, 2, NULL])
SELECT arrayExcept(['apple', 'banana', 'cherry'], ['banana', 'date'])
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])
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 lambdasource_arr — O array de origem a ser processado. Array(T)[, cond1_arr, ... , condN_arr] — Opcional. N arrays de condição que fornecem argumentos adicionais para a função lambda. Array(T)
Valor retornado
Retorna 1 se a função lambda retornar verdadeiro para pelo menos um elemento; caso contrário, 0. UInt8
Exemplos
Exemplo de uso
SELECT arrayExists(x, y -> x=y, [1, 2, 3], [0, 0, 0])
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])
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 lambdasource_arr — O array de origem a ser processado. função lambda[, cond1_arr, ... , condN_arr] — Opcional. N arrays de condição que fornecem argumentos adicionais à função lambda. Array(T)
Valor retornado
Retorna um array Array(T)
Exemplos
Exemplo com um único array
SELECT arrayFill(x -> not isNull(x), [1, null, 2, null]) AS res
SELECT arrayFill(x, y, z -> x > y AND x < z, [5, 3, 6, 2], [4, 7, 1, 3], [10, 2, 8, 5]) AS res
arrayFilter(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])]
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 lambdasource_arr — O array de origem a ser processado. Array(T)[, cond1_arr, ... , condN_arr] — Opcional. N arrays de condição que fornecem argumentos adicionais para a função lambda. Array(T)
Valor retornado
Retorna um subconjunto do array de origem Array(T)
Exemplos
Exemplo 1
SELECT arrayFilter(x -> x LIKE '%World%', ['Hello', 'abc World']) AS res
SELECT
arrayFilter(
(i, x) -> x LIKE '%World%',
arrayEnumerate(arr),
['Hello', 'abc World'] AS arr)
AS res
func(x[, y1, y2, ... yN]) retorna verdadeiro; caso contrário, retorna um valor padrão.
Sintaxe
arrayFirst(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])
func(x[, y1, ..., yN]) — Uma função lambda que opera nos elementos do array de origem (x) e dos arrays de condição (y). Função lambda. - source_arr — O array de origem a ser processado. Array(T). - [, cond1_arr, ... , condN_arr] — Opcional. N arrays de condição que fornecem argumentos adicionais à função lambda. Array(T).
Valor retornado
Retorna o primeiro elemento do array de origem para o qual λ é verdadeiro; caso contrário, retorna o valor padrão de T.
Exemplos
Exemplo de uso
SELECT arrayFirst(x, y -> x=y, ['a', 'b', 'c'], ['c', 'b', 'a'])
SELECT arrayFirst(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)
func(x[, y1, y2, ... yN]) retorna verdadeiro; caso contrário, retorna ‘0’.
Sintaxe
arrayFirstIndex(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])
func(x[, y1, ..., yN]) — Uma função lambda que opera nos elementos do array de origem (x) e dos arrays de condição (y). Função lambda. - source_arr — O array de origem a ser processado. Array(T). - [, cond1_arr, ... , condN_arr] — Opcional. N arrays de condição que fornecem argumentos adicionais para a função lambda. Array(T).
Valor retornado
Retorna o índice do primeiro elemento do array de origem para o qual func é verdadeiro; caso contrário, retorna 0 UInt32
Exemplos
Exemplo de uso
SELECT arrayFirstIndex(x, y -> x=y, ['a', 'b', 'c'], ['c', 'b', 'a'])
SELECT arrayFirstIndex(x, y -> x=y, ['a', 'b', 'c'], ['d', 'e', 'f'])
func(x[, y1, y2, ... yN]) retorna true; caso contrário, retorna NULL.
Sintaxe
arrayFirstOrNull(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])
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 lambdasource_arr — O array de origem a ser processado. Array(T)[, cond1_arr, ... , condN_arr] — Opcional. N arrays de condição que fornecem argumentos adicionais à função lambda. Array(T)
Valor retornado
Retorna o primeiro elemento do array de origem para o qual func é verdadeiro; caso contrário, retorna NULL.
Exemplos
Exemplo de uso
SELECT arrayFirstOrNull(x, y -> x=y, ['a', 'b', 'c'], ['c', 'b', 'a'])
SELECT arrayFirstOrNull(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)
- 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
Aliases: flatten
Argumentos
Valor retornado
Retorna um array unidimensional a partir do array multidimensional Array(T)
Exemplos
Exemplo de uso
SELECT arrayFlatten([[[1]], [[2], [3]]]);
arrayFold(λ(acc, x1 [, x2, x3, ... xN]), arr1 [, arr2, arr3, ... arrN], acc)
λ(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 lambdaarr1 [, arr2, arr3, ... arrN] — N arrays sobre os quais a operação será aplicada. Array(T)acc — Valor do acumulador com o mesmo tipo do valor de retorno da função lambda.
Valor retornado
Retorna o valor final de acc.
Exemplos
Exemplo de uso
SELECT arrayFold(acc,x -> acc + x*2, [1, 2, 3, 4], 3::Int64) AS res;
SELECT arrayFold(acc, x -> (acc.2, acc.2 + acc.1),range(number),(1::Int64, 0::Int64)).1 AS fibonacci FROM numbers(1,10);
┌─fibonacci─┐
│ 0 │
│ 1 │
│ 1 │
│ 2 │
│ 3 │
│ 5 │
│ 8 │
│ 13 │
│ 21 │
│ 34 │
└───────────┘
SELECT arrayFold(
(acc, x, y) -> acc + (x * y),
[1, 2, 3, 4],
[10, 20, 30, 40],
0::Int64
) AS res;
arrayIntersect(arr, arr1, ..., arrN)
arrN — N arrays a partir dos quais o novo array será criado. Array(T).
Valor retornado
Retorna um array com elementos distintos presentes em todos os N arrays Array(T)
Exemplos
Exemplo de uso
SELECT
arrayIntersect([1, 2], [1, 3], [2, 3]) AS empty_intersection,
arrayIntersect([1, 2], [1, 3], [1, 4]) AS non_empty_intersection
┌─empty_intersection─┬─non_empty_intersection─┐
│ [] │ [1] │
└────────────────────┴────────────────────────┘
arrayJaccardIndex(arr_x, arr_y)
arr_x e arr_y Float64
Exemplos
Exemplo de uso
SELECT arrayJaccardIndex([1, 2], [2, 3]) AS res
arrayJoin recebe uma linha que contém um array e o expande, gerando várias linhas — uma para cada elemento do array.
Isso contrasta com as funções regulares no ClickHouse, que mapeiam valores de entrada para valores de saída dentro da mesma linha,
e com as funções de agregação, que recebem um grupo de linhas e as “comprimem” ou “reduzem” a uma única linha de resumo
(ou a um único valor dentro de uma linha de resumo, se usadas com GROUP BY).
Todos os valores nas colunas são simplesmente copiados, exceto os valores da coluna à qual essa função é aplicada;
eles são substituídos pelo valor correspondente do array.
Sintaxe
Aliases: unnest
Argumentos
arr — Um array a ser expandido. Array(T)
Valor retornado
Retorna um conjunto de linhas geradas a partir da expansão de arr.
Exemplos
Uso básico
SELECT arrayJoin([1, 2, 3] AS src) AS dst, 'Hello', src
┌─dst─┬─\'Hello\'─┬─src─────┐
│ 1 │ Hello │ [1,2,3] │
│ 2 │ Hello │ [1,2,3] │
│ 3 │ Hello │ [1,2,3] │
└─────┴───────────┴─────────┘
-- A função arrayJoin afeta todas as seções da consulta, incluindo a seção WHERE. Observe o resultado 2, mesmo que a subconsulta tenha retornado 1 linha.
SELECT sum(1) AS impressions
FROM
(
SELECT ['Istanbul', 'Berlin', 'Bobruisk'] AS cities
)
WHERE arrayJoin(cities) IN ['Istanbul', 'Berlin'];
┌─impressions─┐
│ 2 │
└─────────────┘
- Uma consulta pode usar múltiplas funções arrayJoin. Nesse caso, a transformação é executada várias vezes e as linhas são multiplicadas.
SELECT
sum(1) AS impressions,
arrayJoin(cities) AS city,
arrayJoin(browsers) AS browser
FROM
(
SELECT
['Istanbul', 'Berlin', 'Bobruisk'] AS cities,
['Firefox', 'Chrome', 'Chrome'] AS browsers
)
GROUP BY
2,
3
┌─impressions─┬─city─────┬─browser─┐
│ 2 │ Istanbul │ Chrome │
│ 1 │ Istanbul │ Firefox │
│ 2 │ Berlin │ Chrome │
│ 1 │ Berlin │ Firefox │
│ 2 │ Bobruisk │ Chrome │
│ 1 │ Bobruisk │ Firefox │
└─────────────┴──────────┴─────────┘
-- Usar múltiplos arrayJoin com a mesma expressão pode não produzir o resultado esperado devido a otimizações.
-- Para esses casos, considere modificar a expressão de array repetida com operações extras que não afetam o resultado do join.
- e.g. arrayJoin(arraySort(arr)), arrayJoin(arrayConcat(arr, []))
SELECT
arrayJoin(dice) as first_throw,
/* arrayJoin(dice) as second_throw */ -- é tecnicamente correto, mas eliminará o conjunto de resultados
arrayJoin(arrayConcat(dice, [])) as second_throw -- expressão intencionalmente alterada para forçar reavaliação
FROM (
SELECT [1, 2, 3, 4, 5, 6] as dice
);
┌─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 │
└─────────────┴──────────────┘
-- Observe a sintaxe ARRAY JOIN na consulta `SELECT` abaixo, que oferece possibilidades mais amplas.
-- ARRAY JOIN permite converter múltiplos arrays com o mesmo número de elementos de uma vez.
SELECT
sum(1) AS impressions,
city,
browser
FROM
(
SELECT
['Istanbul', 'Berlin', 'Bobruisk'] AS cities,
['Firefox', 'Chrome', 'Chrome'] AS browsers
)
ARRAY JOIN
cities AS city,
browsers AS browser
GROUP BY
2,
3
┌─impressions─┬─city─────┬─browser─┐
│ 1 │ Istanbul │ Firefox │
│ 1 │ Berlin │ Chrome │
│ 1 │ Bobruisk │ Chrome │
└─────────────┴──────────┴─────────┘
-- Você também pode usar Tuple
SELECT
sum(1) AS impressions,
(arrayJoin(arrayZip(cities, browsers)) AS t).1 AS city,
t.2 AS browser
FROM
(
SELECT
['Istanbul', 'Berlin', 'Bobruisk'] AS cities,
['Firefox', 'Chrome', 'Chrome'] AS browsers
)
GROUP BY
2,
3
┌─impressions─┬─city─────┬─browser─┐
│ 1 │ Istanbul │ Firefox │
│ 1 │ Berlin │ Chrome │
│ 1 │ Bobruisk │ Chrome │
└─────────────┴──────────┴─────────┘
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])
func(x[, y1, ..., yN]) — Uma função lambda que opera sobre elementos do array de origem (x) e arrays de condição (y). Função lambda. - source — O array de origem a ser processado. Array(T). - [, cond1, ... , condN] — Opcional. N arrays de condição que fornecem argumentos adicionais à função lambda. Array(T).
Valor retornado
Retorna o último elemento do array de origem para o qual func é verdadeiro; caso contrário, retorna o valor padrão de T.
Exemplos
Exemplo de uso
SELECT arrayLast(x, y -> x=y, ['a', 'b', 'c'], ['a', 'b', 'c'])
SELECT arrayFirst(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)
func(x[, y1, y2, ... yN]) retorna true; caso contrário, retorna ‘0’.
Sintaxe
arrayLastIndex(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])
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 lambdasource_arr — O array de origem a ser processado. Array(T)[, cond1_arr, ... , condN_arr] — Opcional. N arrays de condição que fornecem argumentos adicionais para a função lambda. Array(T)
Valor retornado
Retorna o índice do último elemento do array de origem para o qual func é verdadeiro; caso contrário, retorna 0 UInt32
Exemplos
Exemplo de uso
SELECT arrayLastIndex(x, y -> x=y, ['a', 'b', 'c'], ['a', 'b', 'c']);
SELECT arrayLastIndex(x, y -> x=y, ['a', 'b', 'c'], ['d', 'e', 'f']);
func(x [, y1, y2, ... yN]) retorna true; caso contrário, retorna NULL.
Sintaxe
arrayLastOrNull(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])
func(x [, y1, ..., yN]) — Uma função lambda que opera sobre os elementos do array de origem (x) e dos arrays de condição (y). Função lambda. - source_arr — O array de origem a ser processado. Array(T). - [, cond1_arr, ... , condN_arr] — Opcional. N arrays de condição que fornecem argumentos adicionais para a função lambda. Array(T).
Valor retornado
Retorna o último elemento do array de origem para o qual λ não for verdadeiro; caso contrário, retorna NULL.
Exemplos
Exemplo de uso
SELECT arrayLastOrNull(x, y -> x=y, ['a', 'b', 'c'], ['a', 'b', 'c'])
SELECT arrayLastOrNull(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)
arrayLevenshteinDistance(from, to)
Float64
Exemplos
Exemplo de uso
SELECT arrayLevenshteinDistance([1, 2, 4], [1, 2, 3])
arrayLevenshteinDistanceWeighted
arrayLevenshteinDistanceWeighted(from, to, from_weights, to_weights)
Float64
Exemplos
Exemplo de uso
SELECT arrayLevenshteinDistanceWeighted(['A', 'B', 'C'], ['A', 'K', 'L'], [1.0, 2, 3], [3.0, 4, 5])
func — Uma função lambda que opera sobre os elementos do array de origem (x) e dos arrays de condição (y). Função lambdaarr — N arrays a serem processados. Array(T)
Valor retornado
Retorna um array com os resultados da função lambda Array(T)
Exemplos
Exemplo de uso
SELECT arrayMap(x -> (x + 2), [1, 2, 3]) as res;
SELECT arrayMap((x, y) -> (x, y), [1, 2, 3], [4, 5, 6]) AS res
func for especificada, retorna o maior elemento entre os resultados da lambda.
Sintaxe
arrayMax([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])
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 lambdasource_arr — O array de origem a ser processado. Array(T)[, cond1_arr, ... , condN_arr] — Opcional. N arrays de condição que fornecem argumentos adicionais para a função lambda. Array(T)
Valor retornado
Retorna o maior elemento do array de origem ou, se fornecida, o maior elemento entre os resultados da função lambda.
Exemplos
Exemplo básico
SELECT arrayMax([5, 3, 2, 7]);
SELECT arrayMax(x, y -> x/y, [4, 8, 12, 16], [1, 2, 1, 2]);
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])
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 lambdasource_arr — O array de origem a ser processado. Array(T)cond1_arr, ... — Opcional. N arrays de condição que fornecem argumentos adicionais para a função lambda. Array(T)
Valor retornado
Retorna o menor elemento do array de origem ou, se fornecida, o menor elemento entre os resultados da função lambda.
Exemplos
Exemplo básico
SELECT arrayMin([5, 3, 2, 7]);
SELECT arrayMin(x, y -> x/y, [4, 8, 12, 16], [1, 2, 1, 2]);
arrayNormalizedGini(predicted, label)
Tuple(Float64, Float64, Float64)
Exemplos
Exemplo de uso
SELECT arrayNormalizedGini([0.9, 0.3, 0.8, 0.7],[6, 1, 0, 2]);
(0.18055555555555558, 0.2638888888888889, 0.6842105263157896)
arrayReverseSort, mas com o argumento adicional limit, que permite ordenação parcial.
Para manter apenas os elementos ordenados, use arrayResize.
arrayPartialReverseSort([f,] arr [, arr1, ... ,arrN], limit)
f(arr[, arr1, ... ,arrN]) — A função lambda a ser aplicada aos elementos do array x. Função lambdaarr — Array a ser ordenado. Array(T)arr1, ... ,arrN — N arrays adicionais, caso f aceite vários argumentos. Array(T)limit — Valor do índice até o qual a ordenação ocorrerá. (U)Int*
Valor retornado
Retorna um array do mesmo tamanho que o array original, em que os elementos no intervalo [1..limit] são ordenados
em ordem decrescente. Os elementos restantes (limit..N] ficam em ordem não especificada.
Exemplos
simple_int
SELECT arrayPartialReverseSort(2, [5, 9, 1, 3])
SELECT arrayPartialReverseSort(2, ['expenses','lasso','embolism','gladly'])
['lasso','gladly','expenses','embolism']
SELECT arrayResize(arrayPartialReverseSort(2, [5, 9, 1, 3]), 2)
SELECT arrayPartialReverseSort((x) -> -x, 2, [5, 9, 1, 3])
SELECT arrayPartialReverseSort((x, y) -> -y, 1, [0, 1, 2], [1, 2, 3]) as res
[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. arrayPartialShuffle(arr [, limit[, seed]])
arr — O array a ser embaralhado. Array(T)seed — Opcional. A semente usada na geração de números aleatórios. Se não for fornecida, uma semente aleatória será usada. (U)Int*limit — Opcional. O número que limita as trocas de elementos, no intervalo [1..N]. (U)Int*
Valor retornado
Array com elementos parcialmente embaralhados. Array(T)
Exemplos
no_limit1
SELECT arrayPartialShuffle([1, 2, 3, 4], 0)
SELECT arrayPartialShuffle([1, 2, 3, 4])
SELECT arrayPartialShuffle([1, 2, 3, 4], 2)
SELECT arrayPartialShuffle([1, 2, 3, 4], 2, 41)
SELECT arrayPartialShuffle(materialize([1, 2, 3, 4]), 2, 42), arrayPartialShuffle([1, 2, 3], 2, 42) FROM numbers(10)
┌─arrayPartial⋯4]), 2, 42)─┬─arrayPartial⋯ 3], 2, 42)─┐
│ [3,2,1,4] │ [3,2,1] │
│ [3,2,1,4] │ [3,2,1] │
│ [4,3,2,1] │ [3,2,1] │
│ [1,4,3,2] │ [3,2,1] │
│ [3,4,1,2] │ [3,2,1] │
│ [1,2,3,4] │ [3,2,1] │
│ [1,4,3,2] │ [3,2,1] │
│ [1,4,3,2] │ [3,2,1] │
│ [3,1,2,4] │ [3,2,1] │
│ [1,3,2,4] │ [3,2,1] │
└──────────────────────────┴──────────────────────────┘
arraySort, mas com um argumento adicional, limit, que permite ordenação parcial.
Para manter apenas os elementos classificados, use arrayResize.
arrayPartialSort([f,] arr [, arr1, ... ,arrN], limit)
f(arr[, arr1, ... ,arrN]) — A função lambda a ser aplicada aos elementos do array x. Função lambdaarr — Array a ser ordenado. Array(T)arr1, ... ,arrN — N arrays adicionais, quando f aceita vários argumentos. Array(T)limit — Valor do índice até o qual a ordenação ocorrerá. (U)Int*
Valor retornado
Retorna um array do mesmo tamanho que o array original, em que os elementos no intervalo [1..limit] são ordenados
em ordem crescente. Os elementos restantes (limit..N] ficam em ordem não especificada.
Exemplos
simple_int
SELECT arrayPartialSort(2, [5, 9, 1, 3])
SELECT arrayPartialSort(2, ['expenses', 'lasso', 'embolism', 'gladly'])
['embolism', 'expenses', 'gladly', 'lasso']
SELECT arrayResize(arrayPartialSort(2, [5, 9, 1, 3]), 2)
SELECT arrayPartialSort((x) -> -x, 2, [5, 9, 1, 3])
SELECT arrayPartialSort((x, y) -> -y, 1, [0, 1, 2], [1, 2, 3]) as res
arr — O array do qual o último elemento será removido. Array(T)
Valor retornado
Retorna um array idêntico a arr, mas sem o último elemento de arr Array(T)
Exemplos
Exemplo de uso
SELECT arrayPopBack([1, 2, 3]) AS res;
arr — O array do qual o primeiro elemento será removido. Array(T)
Valor retornado
Retorna um array idêntico a arr, mas sem o seu primeiro elemento Array(T)
Exemplos
Exemplo de uso
SELECT arrayPopFront([1, 2, 3]) AS res;
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])
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 lambdasource_arr — O array de origem a ser processado. Array(T)[, cond1_arr, ... , condN_arr] — Opcional. N arrays condicionais que fornecem argumentos adicionais para a função lambda. Array(T)
Valor retornado
Retorna o produto dos elementos no array de origem ou, se fornecida, o produto dos elementos resultantes da função lambda. Float64
Exemplos
Exemplo básico
SELECT arrayProduct([1, 2, 3, 4]);
SELECT arrayProduct(x, y -> x+y, [2, 2], [2, 2]) AS res;
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.arr, mas com um valor adicional x no final do array Array(T)
Exemplos
Exemplo de uso
SELECT arrayPushBack(['a'], 'b') AS res;
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.arr, mas com um valor adicional x no início do array Array(T)
Exemplos
Exemplo de uso
SELECT arrayPushFront(['b'], 'a') AS res;
arrayROCAUC(scores, labels[, scale[, partial_offsets]])
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 Enumscale — 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. Boolpartial_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].
Float64
Exemplos
Exemplo de uso
SELECT arrayROCAUC([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1]);
samples elementos aleatórios de um array de entrada. Se samples exceder o tamanho do array de entrada, o tamanho da amostra será limitado ao tamanho do array, ou seja, todos os elementos do array serão retornados, mas a ordem deles não é garantida. A função pode lidar tanto com arrays simples quanto com arrays aninhados.
Sintaxe
arrayRandomSample(arr, samples)
arr — O array de entrada ou array multidimensional do qual serão amostrados os elementos. Array(T)samples — O número de elementos a incluir na amostra aleatória. (U)Int*
Valor retornado
Um array contendo uma amostra aleatória de elementos do array de entrada Array(T)
Exemplos
Exemplo de uso
SELECT arrayRandomSample(['apple', 'banana', 'cherry', 'date'], 2) as res;
SELECT arrayRandomSample([[1, 2], [3, 4], [5, 6]], 2) as res;
'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])
agg_f — O nome de uma função de agregação, que deve ser uma constante. Stringarr1[, arr2, ... , arrN] — N arrays correspondentes aos argumentos de agg_f. Array(T)
Valor retornado
Retorna o resultado da função de agregação
Exemplos
Exemplo de uso
SELECT arrayReduce('max', [1, 2, 3]);
┌─arrayReduce('max', [1, 2, 3])─┐
│ 3 │
└───────────────────────────────┘
--Se uma função de agregação recebe múltiplos argumentos, ela deve ser aplicada a múltiplos arrays de mesmo tamanho.
SELECT arrayReduce('maxIf', [3, 5], [1, 0]);
┌─arrayReduce('maxIf', [3, 5], [1, 0])─┐
│ 3 │
└──────────────────────────────────────┘
SELECT arrayReduce('uniqUpTo(3)', [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
┌─arrayReduce('uniqUpTo(3)', [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])─┐
│ 4 │
└─────────────────────────────────────────────────────────────┘
arrayReduce(agg_func, arraySlice(arr1, index, length), ...).
Sintaxe
arrayReduceInRanges(agg_f, ranges, arr1[, arr2, ... ,arrN])
agg_f — O nome da função de agregação a ser usada. Stringranges — O intervalo no qual agregar. Um array de tuplas (i, r) contendo o índice i a partir do qual começar e o intervalo r no qual agregar. Array(T) ou Tuple(T)arr1[, arr2, ... ,arrN] — N arrays como argumentos da função de agregação. Array(T)
Valor retornado
Retorna um array contendo os resultados da função de agregação nos intervalos especificados Array(T)
Exemplos
Exemplo de uso
SELECT arrayReduceInRanges(
'sum',
[(1, 5), (2, 3), (3, 4), (4, 4)],
[1000000, 200000, 30000, 4000, 500, 60, 7]
) AS res
┌─res─────────────────────────┐
│ [1234500,234000,34560,4567] │
└─────────────────────────────┘
array_remove
Argumentos
arr — Array(T) - elem — T
Valor retornado
Retorna um subconjunto do array de origem Array(T)
Exemplos
Exemplo 1
SELECT arrayRemove([1, 2, 2, 3], 2)
SELECT arrayRemove(['a', NULL, 'b', NULL], NULL)
arrayResize(arr, size[, extender])
arr — Array a ser redimensionado. Array(T)size —
-O novo tamanho do array.
Se size for menor que o tamanho original do array, o array será truncado à direita.
Se size for maior que o tamanho inicial do array, o array será estendido à direita com valores de extender ou com valores padrão do tipo de dado dos itens do array.extender — Valor a ser usado para estender o array. Pode ser NULL.
Valor retornado
Um array de tamanho size. Array(T)
Exemplos
Exemplo 1
SELECT arrayResize([1], 3);
SELECT arrayResize([1], 3, NULL);
A função reverse(arr) realiza a mesma operação, mas também funciona com outros tipos de dados
além de Arrays.
Array(T)
Exemplos
Exemplo de uso
SELECT arrayReverse([1, 2, 3])
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])
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 lambdasource_arr — O array de origem a ser processado. Array(T)[, cond1_arr, ... , condN_arr] — Opcional. N arrays de condição que fornecem argumentos adicionais para a função lambda. Array(T)
Valor retornado
Retorna um array com os elementos do array de origem substituídos pelos resultados da função lambda. Array(T)
Exemplos
Exemplo com um único array
SELECT arrayReverseFill(x -> not isNull(x), [1, null, 2, null]) AS res
SELECT arrayReverseFill(x, y, z -> x > y AND x < z, [5, 3, 6, 2], [4, 7, 1, 3], [10, 2, 8, 5]) AS res;
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:
-InfInfNaNNULL
arrayReverseSort é uma função de ordem superior.
Sintaxe
arrayReverseSort([f,] arr [, arr1, ... ,arrN)
f(y1[, y2 ... yN]) — A função lambda a ser aplicada aos elementos do array x. - arr — Um array a ser classificado. Array(T) - arr1, ..., yN — Opcional. N arrays adicionais, caso f aceite vários argumentos.
Valor retornado
Retorna o array x classificado em ordem decrescente se nenhuma função lambda for fornecida; caso contrário,
retorna um array classificado de acordo com a lógica da função lambda fornecida e, em seguida, invertido. Array(T).
Exemplos
Exemplo 1
SELECT arrayReverseSort((x, y) -> y, [4, 3, 5], ['a', 'b', 'c']) AS res;
SELECT arrayReverseSort((x, y) -> -y, [4, 3, 5], [1, 2, 3]) AS res;
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])
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 lambdasource_arr — O array de origem a ser processado. Função lambda[, cond1_arr, ... , condN_arr] — Opcional. N arrays de condição que fornecem argumentos adicionais para a função lambda. Array(T)
Valor retornado
Retorna um array de arrays. Array(Array(T))
Exemplos
Exemplo de uso
SELECT arrayReverseSplit((x, y) -> y, [1, 2, 3, 4, 5], [1, 0, 0, 1, 0]) AS res
n são tratados como uma rotação para a direita pelo valor absoluto de n.
Sintaxe
Argumentos
Valor retornado
Um array rotacionado para a esquerda pelo número especificado de elementos Array(T)
Exemplos
Exemplo de uso
SELECT arrayRotateLeft([1,2,3,4,5,6], 2) as res;
SELECT arrayRotateLeft([1,2,3,4,5,6], -2) as res;
n equivalem a uma rotação para a esquerda pelo valor absoluto de n.
Sintaxe
Argumentos
arr — O array cujos elementos serão rotacionados.Array(T). - n — Número de elementos a serem rotacionados. (U)Int8/16/32/64.
Valor retornado
Um array rotacionado para a direita pelo número especificado de elementos Array(T)
Exemplos
Exemplo de uso
SELECT arrayRotateRight([1,2,3,4,5,6], 2) as res;
SELECT arrayRotateRight([1,2,3,4,5,6], -2) as res;
arrayShiftLeft(arr, n[, default])
arr — O array cujos elementos devem ser deslocados.Array(T). - n — Número de elementos a serem deslocados.(U)Int8/16/32/64. - default — Opcional. Valor padrão dos novos elementos.
Valor retornado
Um array deslocado para a esquerda pelo número especificado de elementos Array(T)
Exemplos
Exemplo de uso
SELECT arrayShiftLeft([1,2,3,4,5,6], 2) as res;
SELECT arrayShiftLeft([1,2,3,4,5,6], -2) as res;
SELECT arrayShiftLeft([1,2,3,4,5,6], 2, 42) as res;
arrayShiftRight(arr, n[, default])
arr — O array cujos elementos devem ser deslocados. Array(T)n — Número de elementos a serem deslocados. (U)Int8/16/32/64default — Opcional. Valor padrão para os novos elementos.
Valor retornado
Um array deslocado para a direita pelo número de elementos especificado Array(T)
Exemplos
Exemplo de uso
SELECT arrayShiftRight([1, 2, 3, 4, 5, 6], 2) as res;
SELECT arrayShiftRight([1, 2, 3, 4, 5, 6], -2) as res;
SELECT arrayShiftRight([1, 2, 3, 4, 5, 6], 2, 42) as res;
arr — Array a partir do qual será gerado um array de shingles. Array(T)l — O comprimento de cada shingle. (U)Int*
Valor retornado
Um array com os shingles gerados Array(T)
Exemplos
Exemplo de uso
SELECT arrayShingles([1, 2, 3, 4], 3) as res;
Esta função não materializa constantes.
arrayShuffle(arr [, seed])
arr — O array que será embaralhado. Array(T)seed (optional) — Opcional. A semente usada na geração de números aleatórios. Se não for fornecida, uma semente aleatória será usada. (U)Int*
Valor retornado
Array com os elementos embaralhados Array(T)
Exemplos
Exemplo sem seed (resultados instáveis)
SELECT arrayShuffle([1, 2, 3, 4]);
SELECT arrayShuffle([1, 2, 3, 4], 41);
0 a 1 com base na distância de Levenshtein ponderada.
Sintaxe
arraySimilarity(from, to, from_weights, to_weights)
0 e 1 entre os dois arrays, com base na distância de Levenshtein ponderada Float64
Exemplos
Exemplo de uso
SELECT arraySimilarity(['A', 'B', 'C'], ['A', 'K', 'L'], [1.0, 2, 3], [3.0, 4, 5]);
NULL.
Sintaxe
arraySlice(arr, offset [, length])
arr — Array a ser fatiado. Array(T)offset — Deslocamento a partir da borda do array. Um valor positivo indica um deslocamento à esquerda, e um valor negativo indica um recuo à direita. A numeração dos elementos do array começa em 1. (U)Int*length — O tamanho da fatia desejada. Se você especificar um valor negativo, a função retornará uma fatia aberta [offset, array_length - length]. Se você omitir o valor, a função retornará a fatia [offset, the_end_of_array]. (U)Int*
Valor retornado
Retorna uma fatia do array com length elementos a partir do offset especificado Array(T)
Exemplos
Exemplo de uso
SELECT arraySlice([1, 2, NULL, 4, 5], 2, 3) AS res;
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:
-InfInfNaNNULL
arraySort é uma função de ordem superior.
Sintaxe
arraySort([f,] arr [, arr1, ... ,arrN])
f(y1[, y2 ... yN]) — A função lambda a ser aplicada aos elementos do array x. - arr — Um array a ser ordenado. Array(T) - arr1, ..., yN — Opcional. N arrays adicionais, caso f aceite vários argumentos.
Valor retornado
Retorna o array arr ordenado em ordem crescente se nenhuma função lambda for fornecida; caso contrário,
retorna um array ordenado de acordo com a lógica da função lambda fornecida. Array(T).
Exemplos
Exemplo 1
SELECT arraySort([1, 3, 3, 0]);
SELECT arraySort(['hello', 'world', '!']);
SELECT arraySort([1, nan, 2, NULL, 3, nan, -4, NULL, inf, -inf]);
[-inf,-4,1,2,3,inf,nan,nan,NULL,NULL]
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])
func(x[, y1, ..., yN]) — Uma função lambda que opera sobre os elementos do array de origem (x) e dos arrays de condição (y).Função lambda. - source_arr — O array de origem a ser dividido Array(T). - [, cond1_arr, ... , condN_arr] — Opcional. N arrays de condição que fornecem argumentos adicionais para a função lambda. Array(T).
Valor retornado
Retorna um array de arrays Array(Array(T))
Exemplos
Exemplo de uso
SELECT arraySplit((x, y) -> y, [1, 2, 3, 4, 5], [1, 0, 0, 1, 0]) AS res
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])
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 lambdasource_arr — O array de origem a ser processado. Array(T), cond1_arr, ... , condN_arr] — Opcional. N arrays de condição que fornecem argumentos adicionais para a função lambda. Array(T)
Valor retornado
Retorna a soma dos elementos do array de origem ou, se fornecida, a soma dos elementos resultantes da função lambda.
Exemplos
Exemplo básico
SELECT arraySum([1, 2, 3, 4]);
SELECT arraySum(x, y -> x+y, [1, 1, 1, 1], [1, 1, 1, 1]);
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. arraySymmetricDifference(arr1, arr2, ... , arrN)
arrN — N arrays a partir dos quais o novo array é criado. Array(T).
Valor retornado
Retorna um array de elementos distintos que não estão presentes em todos os arrays de origem Array(T)
Exemplos
Exemplo de uso
SELECT
arraySymmetricDifference([1, 2], [1, 2], [1, 2]) AS empty_symmetric_difference,
arraySymmetricDifference([1, 2], [1, 2], [1, 3]) AS non_empty_symmetric_difference;
┌─empty_symmetric_difference─┬─non_empty_symmetric_difference─┐
│ [] │ [3,2] │
└────────────────────────────┴────────────────────────────────┘
arr — Um array bidimensional a ser transposto. Todos os arrays internos devem ter o mesmo comprimento. Array(Array(T))
Valor retornado
Um array bidimensional transposto em que o elemento [i][j] do resultado é igual ao elemento [j][i] do array de entrada. Array(Array(T))
Exemplos
Matriz quadrada
SELECT arrayTranspose([[1, 2], [3, 4]])
SELECT arrayTranspose([[1, 2, 3], [4, 5, 6]])
SELECT arrayTranspose([['a', 'b'], ['c', 'd']])
arrayUnion(arr1, arr2, ..., arrN)
arrN — N arrays usados para criar o novo array. Array(T)
Valor retornado
Retorna um array com elementos distintos dos arrays de origem Array(T)
Exemplos
Exemplo de uso
SELECT
arrayUnion([-2, 1], [10, 1], [-2], []) as num_example,
arrayUnion(['hi'], [], ['hello', 'hi']) as str_example,
arrayUnion([1, 3, NULL], [2, 3, NULL]) as null_example
┌─num_example─┬─str_example────┬─null_example─┐
│ [10,-2,1] │ ['hello','hi'] │ [3,2,1,NULL] │
└─────────────┴────────────────┴──────────────┘
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).
arrayUniq(arr1[, arr2, ..., arrN])
arr1 — Array em que se conta o número de elementos únicos. Array(T)[, arr2, ..., arrN] — Opcional. Arrays adicionais usadas para contar o número de tuplas únicas de elementos nas posições correspondentes em vários arrays. Array(T)
Valor retornado
Para um único argumento, retorna o número de
elementos únicos. Para vários argumentos, retorna o número de tuplas únicas formadas por
elementos nas posições correspondentes entre os arrays.
UInt32
Exemplos
Argumento único
SELECT arrayUniq([1, 1, 2, 2])
SELECT arrayUniq([1, 2, 3, 1], [4, 5, 6, 4])
length preenchido com a constante x.
Sintaxe
Argumentos
length — Número de elementos do array. (U)Int*x — O valor dos N elementos do array, de qualquer tipo.
Valor retornado
Retorna um Array com N elementos com valor x. Array(T)
Exemplos
Exemplo de uso
SELECT arrayWithConstant(3, 1)
arrayZip(arr1, arr2, ... , arrN)
arr1, arr2, ... , arrN — N arrays a serem combinados em um único array. Array(T)
Valor retornado
Retorna um array com elementos dos arrays de origem agrupados em tuplas. Os tipos de dados na tupla são os mesmos dos arrays de entrada e seguem a mesma ordem em que os arrays são passados Array(T)
Exemplos
Exemplo de uso
SELECT arrayZip(['a', 'b', 'c'], [5, 2, 1]);
[('a', 5), ('b', 2), ('c', 1)]
arrayZipUnaligned(arr1, arr2, ..., arrN)
arr1, arr2, ..., arrN — N arrays a serem combinados em um único array. Array(T)
Valor retornado
Retorna um array com elementos dos arrays de entrada agrupados em tuplas. Os tipos de dados na tupla são os mesmos dos arrays de entrada e seguem a mesma ordem em que os arrays são passados. Array(T) ou Tuple(T1, T2, ...)
Exemplos
Exemplo de uso
SELECT arrayZipUnaligned(['a'], [1, 2, 3]);
[('a', 1),(NULL, 2),(NULL, 3)]
x. Equivalente a arrayCount(elem -> elem = x, arr).
Elementos NULL são tratados como valores distintos.
Sintaxe
Argumentos
arr — Array em que será feita a busca. Array(T)x — Valor no array a ser contado. Qualquer tipo.
Valor retornado
Retorna o número de elementos do array iguais a x UInt64
Exemplos
Exemplo de uso
SELECT countEqual([1, 2, NULL, NULL], NULL)
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;. 1 para um array vazio ou 0 para um array não vazio UInt8
Exemplos
Exemplo de uso
Introduzido em: v1.1.0
Retorna um array de Date vazio
Sintaxe
Argumentos
Valor retornado
Um array vazio de Date. Array(T)
Exemplos
Exemplo de uso
Introduzido em: v1.1.0
Retorna um array vazio de DateTime
Sintaxe
Argumentos
Valor retornado
Um array DateTime vazio. Array(T)
Exemplos
Exemplo de uso
SELECT emptyArrayDateTime
Array(T)
Exemplos
Exemplo de uso
Introduzido em: v1.1.0
Retorna um array Float64 vazio
Sintaxe
Argumentos
Valor retornado
Um array vazio de Float64. Array(T)
Exemplos
Exemplo de uso
Introduzido em: v1.1.0
Retorna um array(Int16) vazio
Sintaxe
Argumentos
Valor retornado
Um array Int16 vazio. Array(T)
Exemplos
Exemplo de uso
Introduzido em: v1.1.0
Retorna um array Int32 vazio
Sintaxe
Argumentos
Valor retornado
Um array vazio de Int32. Array(T)
Exemplos
Exemplo de uso
Introduzido em: v1.1.0
Retorna um array Int64 vazio
Sintaxe
Argumentos
Valor de retorno
Um array Int64 vazio. Array(T)
Exemplos
Exemplo de uso
Introduzido em: v1.1.0
Retorna um array(Int8) vazio
Sintaxe
Argumentos
Valor retornado
Um array vazio de Int8. Array(T)
Exemplos
Exemplo de uso
Introduzido em: v1.1.0
Retorna um array vazio de String
Sintaxe
Argumentos
Valor retornado
Um array vazio de String. Array(T)
Exemplos
Exemplo de uso
Introduzido em: v1.1.0
Aceita um array vazio e retorna um array com um único elemento, igual ao valor padrão.
Sintaxe
Argumentos
Valor retornado
Um array com um único valor do tipo padrão do Array. Array(T)
Exemplos
Exemplo básico
CREATE TABLE test (
a Array(Int32),
b Array(String),
c Array(DateTime)
)
ENGINE = MergeTree
ORDER BY tuple();
INSERT INTO test VALUES ([], [], []);
SELECT emptyArrayToSingle(a), emptyArrayToSingle(b), emptyArrayToSingle(c) FROM test;
┌─emptyArrayToSingle(a)─┬─emptyArrayToSingle(b)─┬─emptyArrayToSingle(c)───┐
│ [0] │ [''] │ ['1970-01-01 01:00:00'] │
└───────────────────────┴───────────────────────┴─────────────────────────┘
Array(T)
Exemplos
Exemplo de uso
Introduzido em: v1.1.0
Retorna um array vazio de UInt32
Sintaxe
Argumentos
Valor retornado
Um array vazio de UInt32. Array(T)
Exemplos
Exemplo de uso
Introduzido em: v1.1.0
Retorna um array vazio de UInt64
Sintaxe
Argumentos
Valor retornado
Um array UInt64 vazio. Array(T)
Exemplos
Exemplo de uso
Introduzido em: v1.1.0
Retorna um array UInt8 vazio
Sintaxe
Argumentos
Valor retornado
Um array UInt8 vazio. Array(T)
Exemplos
Exemplo de uso
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
Argumentos
haystack — O array, map ou JSON de origem. Array ou Map ou JSONneedle — 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
Array não encontrado
Uso básico do map
SELECT has(map('a', 1, 'b', 2), 'b')
SELECT has('{"a": {"b": 1}}'::JSON, 'a.b')
- Um array vazio é subconjunto de qualquer array.
NULL é processado como um valor.- A ordem dos valores em ambos os arrays não importa.
Sintaxe
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
Arrays com valores NULL
SELECT hasAll([1, Null], [Null])
SELECT hasAll([1.0, 2, 3, 4], [1, 3])
SELECT hasAll(['a', 'b'], ['a'])
SELECT hasAll([1], ['a'])
Lança uma exceção NO_COMMON_TYPE
SELECT hasAll([[1, 2], [3, 4]], [[1, 2], [3, 5]])
Null é processado como um valor.- A ordem dos valores em ambos os arrays não importa.
Sintaxe
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
Arrays com valores NULL
SELECT hasAny([Null], [Null, 1])
SELECT hasAny([-128, 1., 512], [1])
SELECT hasAny([[1, 2], [3, 4]], ['a', 'c'])
Lança uma exceção `NO_COMMON_TYPE`
SELECT hasAll([[1, 2], [3, 4]], [[1, 2], [1, 2]])
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
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
Arrays com valores NULL
SELECT hasSubstr([1, Null], [Null])
SELECT hasSubstr([1.0, 2, 3, 4], [1, 3])
SELECT hasSubstr(['a', 'b'], ['a'])
SELECT hasSubstr(['a', 'b' , 'c'], ['a', 'b'])
SELECT hasSubstr(['a', 'b' , 'c'], ['a', 'c'])
SELECT hasSubstr([[1, 2], [3, 4], [5, 6]], [[1, 2], [3, 4]])
SELECT hasSubstr([1, 2, NULL, 3, 4], ['a'])
Lança uma exceção `NO_COMMON_TYPE`
0.
Elementos definidos como NULL são tratados como valores normais.
Sintaxe
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
SELECT indexOf([5, 4, 1, 3], 3)
SELECT indexOf([1, 3, NULL, NULL], NULL)
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.
indexOfAssumeSorted(arr, x)
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
SELECT indexOfAssumeSorted([1, 3, 3, 3, 4, 4, 5], 4)
kql_array_sort_asc(array1[, array2, ..., nulls_last])
array1 — O array a ser ordenado. Array(T)array2 — Opcional. Arrays adicionais a serem reordenados de acordo com a ordenação de array1. Array(T)nulls_last — Opcional. Um valor booleano que indica se os valores NULL devem aparecer por último. O padrão é true. UInt8
Valor retornado
Retorna uma tupla de arrays ordenados em ordem crescente. Tuple(Array, ...)
Exemplos
Uso básico
SELECT kql_array_sort_asc([3, 1, 2])
kql_array_sort_desc(array1[, array2, ..., nulls_last])
array1 — O array a ser ordenado. Array(T)array2 — Arrays adicionais opcionais a serem reordenados de acordo com a ordem de array1. Array(T)nulls_last — Booleano opcional que indica se os valores nulos devem aparecer por último. O padrão é true. UInt8
Valor retornado
Retorna uma tupla de arrays ordenados em ordem decrescente. Tuple(Array, ...)
Exemplos
Uso básico
SELECT kql_array_sort_desc([3, 1, 2])
- Para argumentos String ou FixedString: calcula o número de bytes da string.
- Para argumentos Array: calcula o número de elementos do array.
- Se aplicada a um argumento FixedString, a função é uma expressão constante.
Observe que o número de bytes em uma string não é o mesmo que o número de
“pontos de código” Unicode, nem o mesmo que o número de “clusters de grafemas” Unicode
(o que normalmente chamamos de “caracteres”), nem o mesmo que a largura visível da string.
Não há problema em haver bytes NULL ASCII em strings, e eles também serão contados.
Sintaxe
Aliases: OCTET_LENGTH
Argumentos
x — Valor para o qual se calcula o número de bytes (para String/FixedString) ou de elementos (para Array). String ou FixedString ou Array(T)
Valor retornado
Retorna o número de bytes na String/FixedString x / o número de elementos no array x UInt64
Exemplos
Exemplo com String
SELECT length('Hello, world!')
SELECT length(['Hello', 'world'])
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)
┌─str────┬─str_length_is_constant─┬─fixed_str_length_is_constant─┐
│ hello0 │ 0 │ 1 │
│ hello1 │ 0 │ 1 │
│ hello2 │ 0 │ 1 │
└────────┴────────────────────────┴──────────────────────────────┘
SELECT 'ёлка' AS str1, length(str1), lengthUTF8(str1), normalizeUTF8NFKD(str1) AS str2, length(str2), lengthUTF8(str2)
┌─str1─┬─length(str1)─┬─lengthUTF8(str1)─┬─str2─┬─length(str2)─┬─lengthUTF8(str2)─┐
│ ёлка │ 8 │ 4 │ ёлка │ 10 │ 5 │
└──────┴──────────────┴──────────────────┴──────┴──────────────┴──────────────────┘
SELECT 'ábc' AS str, length(str), lengthUTF8(str)
┌─str─┬─length(str)──┬─lengthUTF8(str)─┐
│ ábc │ 4 │ 3 │
└─────┴──────────────┴─────────────────┘
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. 1 para um array não vazio ou 0 para um array vazio UInt8
Exemplos
Exemplo de uso
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])
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
SELECT range(5), range(1, 5), range(1, 5, 2), range(-1, 5, 2);
┌─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] │
└─────────────┴─────────────┴────────────────┴─────────────────┘
x — O valor usado para preencher o array de resultado. Anyarr — 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
SELECT replicate(1, ['a', 'b', 'c']);
┌─replicate(1, ['a', 'b', 'c'])───┐
│ [1, 1, 1] │
└─────────────────────────────────┘
SELECT reverse([1, 2, 3, 4]);
