> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-mintlify-8a08bda2.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
> Documentação sobre funções de array
# Funções de array
{/*AUTOGENERATED_START*/}
## 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**
```sql theme={null}
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)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Uso válido**
```sql title=Query theme={null}
SELECT array(toInt32(1), toUInt16(2), toInt8(3)) AS a, toTypeName(a)
```
```response title=Response theme={null}
┌─a───────┬─toTypeName(a)─┐
│ [1,2,3] │ Array(Int32) │
└─────────┴───────────────┘
```
**Uso incorreto**
```sql title=Query theme={null}
SELECT array(toInt32(5), toDateTime('1998-06-16'), toInt8(5)) AS a, toTypeName(a)
```
```response title=Response theme={null}
Received exception from server (version 25.4.3):
Code: 386. DB::Exception: Received from localhost:9000. DB::Exception:
There is no supertype for types Int32, DateTime, Int8 ...
```
## arrayAUCPR
Introduzido em: v20.4.0
Calcula a área sob a curva de precisão-recall (PR).
Uma curva de precisão-recall é criada ao plotar a precisão no eixo y e o recall no eixo x em todos os limiares.
O valor resultante varia de 0 a 1, com valores mais altos indicando melhor desempenho do modelo.
A PR AUC é particularmente útil para conjuntos de dados desbalanceados, proporcionando uma comparação de desempenho mais clara do que a ROC AUC nesses casos.
Para mais detalhes, consulte [aqui](https://developers.google.com/machine-learning/glossary#pr-auc-area-under-the-pr-curve), [aqui](https://developers.google.com/machine-learning/crash-course/classification/roc-and-auc#expandable-1) e [aqui](https://en.wikipedia.org/wiki/Receiver_operating_characteristic#Area_under_the_curve).
**Sintaxe**
```sql theme={null}
arrayAUCPR(scores, labels[, partial_offsets])
```
**Aliases**: `arrayPRAUC`
**Argumentos**
* `cores` — Pontuações fornecidas pelo modelo de predição. [`Array((U)Int*)`](/pt-BR/reference/data-types/array) ou [`Array(Float*)`](/pt-BR/reference/data-types/array)
* `labels` — Rótulos das amostras, geralmente 1 para amostra positiva e 0 para amostra negativa. [`Array((U)Int*)`](/pt-BR/reference/data-types/array) ou [`Array(Enum)`](/pt-BR/reference/data-types/array)
* `partial_offsets` —
* Opcional. Um [`Array(T)`](/pt-BR/reference/data-types/array) de três inteiros não negativos para calcular uma área parcial sob a curva PR (equivalente a uma faixa vertical no espaço PR) em vez da AUC completa. Essa opção é útil para o cálculo distribuído da PR AUC. O array deve conter os seguintes elementos \[`higher_partitions_tp`, `higher_partitions_fp`, `total_positives`].
* `higher_partitions_tp`: O número de rótulos positivos nas partições com pontuações mais altas.
* `higher_partitions_fp`: O número de rótulos negativos nas partições com pontuações mais altas.
* `total_positives`: O número total de amostras positivas em todo o conjunto de dados.
Quando `arr_partial_offsets` é usado, `arr_scores` e `arr_labels` devem corresponder apenas a uma partição de todo o conjunto de dados, contendo um intervalo de pontuações.
O conjunto de dados deve ser dividido em partições contíguas, em que cada partição contém o subconjunto de dados cujas pontuações se enquadram em um intervalo específico.
Por exemplo:
* Uma partição pode conter todas as pontuações no intervalo \[0, 0.5).
* Outra partição pode conter pontuações no intervalo \[0.5, 1.0].
**Valor retornado**
Retorna a área sob a curva de precisão-recall (PR). [`Float64`](/pt-BR/reference/data-types/float)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT arrayAUCPR([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1]);
```
```response title=Response theme={null}
┌─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**
```sql theme={null}
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`](/pt-BR/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — O array de origem a ser processado. [`Array(T)`](/pt-BR/reference/data-types/array)
* `cond1_arr, ...` — Opcional. N arrays de condição que fornecem argumentos adicionais para a função lambda. [`Array(T)`](/pt-BR/reference/data-types/array)
**Valor retornado**
Retorna `1` se a função lambda retornar verdadeiro para todos os elementos; caso contrário, `0` [`UInt8`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Todos os elementos satisfazem a condição**
```sql title=Query theme={null}
SELECT arrayAll(x, y -> x=y, [1, 2, 3], [1, 2, 3])
```
```response title=Response theme={null}
1
```
**Nem todos os elementos coincidem**
```sql title=Query theme={null}
SELECT arrayAll(x, y -> x=y, [1, 2, 3], [1, 1, 1])
```
```response title=Response theme={null}
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**
```sql theme={null}
arrayAutocorrelation(arr, [max_lag])
```
**Argumentos**
* `arr` — Array de números. [`Array(T)`](/pt-BR/reference/data-types/array)
* `max_lag` — Opcional. Número máximo de defasagens a calcular. Deve ser um inteiro não negativo. [`Integer`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna um array de Float64. Retorna NaN se a variância for 0. [`Array(Float64)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Linear**
```sql title=Query theme={null}
SELECT arrayAutocorrelation([1, 2, 3, 4, 5]);
```
```response title=Response theme={null}
[1, 0.4, -0.1, -0.4, -0.4]
```
**Simétrico**
```sql title=Query theme={null}
SELECT arrayAutocorrelation([10, 20, 10]);
```
```response title=Response theme={null}
[1, -0.6666666666666669, 0.16666666666666674]
```
**Constante**
```sql title=Query theme={null}
SELECT arrayAutocorrelation([5, 5, 5]);
```
```response title=Response theme={null}
[nan, nan, nan]
```
**Limitado**
```sql title=Query theme={null}
SELECT arrayAutocorrelation([1, 2, 3, 4, 5], 2);
```
```response title=Response theme={null}
[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**
```sql theme={null}
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`](/pt-BR/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — O array de origem a ser processado. [`Array(T)`](/pt-BR/reference/data-types/array)
* `[, cond1_arr, ... , condN_arr]` — Opcional. N arrays de condição que fornecem argumentos adicionais para a função lambda. [`Array(T)`](/pt-BR/reference/data-types/array)
**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`](/pt-BR/reference/data-types/float)
**Exemplos**
**Exemplo básico**
```sql title=Query theme={null}
SELECT arrayAvg([1, 2, 3, 4]);
```
```response title=Response theme={null}
2.5
```
**Uso com função lambda**
```sql title=Query theme={null}
SELECT arrayAvg(x, y -> x*y, [2, 3], [2, 3]) AS res;
```
```response title=Response theme={null}
6.5
```
## arrayCompact
Introduzido em: v20.1.0
Remove elementos duplicados consecutivos de um array, incluindo valores `null`. A ordem dos valores no array resultante é determinada pela ordem dos elementos no array de origem.
**Sintaxe**
```sql theme={null}
arrayCompact(arr)
```
**Argumentos**
* `arr` — Um array do qual serão removidos os valores duplicados. [`Array(T)`](/pt-BR/reference/data-types/array)
**Valor retornado**
Retorna um array sem valores duplicados [`Array(T)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT arrayCompact([1, 1, nan, nan, 2, 3, 3, 3]);
```
```response title=Response theme={null}
[1,nan,2,3]
```
## arrayConcat
Introduzido em: v1.1.0
Combina os arrays passados como argumentos.
**Sintaxe**
```sql theme={null}
arrayConcat(arr1 [, arr2, ... , arrN])
```
**Argumentos**
* `arr1 [, arr2, ... , arrN]` — N arrays para concatenar. [`Array(T)`](/pt-BR/reference/data-types/array)
**Valor retornado**
Retorna um único array combinado a partir dos argumentos de array fornecidos. [`Array(T)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT arrayConcat([1, 2], [3, 4], [5, 6]) AS res
```
```response title=Response theme={null}
[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](/pt-BR/reference/functions/regular-functions/overview#higher-order-functions).
**Sintaxe**
```sql theme={null}
arrayCount([func, ] arr1, ...)
```
**Argumentos**
* `func` — Opcional. Função a ser aplicada a cada elemento do(s) array(s). [`Função lambda`](/pt-BR/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `arr1, ..., arrN` — N arrays. [`Array(T)`](/pt-BR/reference/data-types/array)
**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`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT arrayCount(x -> (x % 2), groupArray(number)) FROM numbers(10)
```
```response title=Response theme={null}
5
```
## arrayCumSum
Introduzido em: v1.1.0
Retorna um array com as somas parciais (acumuladas) dos elementos no array de entrada. Se uma função lambda for especificada, a soma será calculada aplicando a função lambda aos elementos do array em cada posição.
**Sintaxe**
```sql theme={null}
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`](/pt-BR/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `arr1` — O array de origem de valores numéricos. [`Array(T)`](/pt-BR/reference/data-types/array)
* `[arr2, ..., arrN]` — Opcional. Arrays adicionais do mesmo tamanho, passados como argumentos para a função lambda, se especificada. [`Array(T)`](/pt-BR/reference/data-types/array)
**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)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Uso básico**
```sql title=Query theme={null}
SELECT arrayCumSum([1, 1, 1, 1]) AS res
```
```response title=Response theme={null}
[1, 2, 3, 4]
```
**Com função lambda**
```sql title=Query theme={null}
SELECT arrayCumSum(x -> x * 2, [1, 2, 3]) AS res
```
```response title=Response theme={null}
[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**
```sql theme={null}
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`](/pt-BR/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `arr1` — O array de origem de valores numéricos. [`Array(T)`](/pt-BR/reference/data-types/array)
* `[arr2, ..., arrN]` — Opcional. Arrays adicionais do mesmo tamanho, passados como argumentos para a função lambda, se ela for especificada. [`Array(T)`](/pt-BR/reference/data-types/array)
**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)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Uso básico**
```sql title=Query theme={null}
SELECT arrayCumSumNonNegative([1, 1, -4, 1]) AS res
```
```response title=Response theme={null}
[1, 2, 0, 1]
```
**Com lambda**
```sql title=Query theme={null}
SELECT arrayCumSumNonNegative(x -> x * 2, [1, -2, 3]) AS res
```
```response title=Response theme={null}
[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**
```sql theme={null}
arrayDifference(arr)
```
**Argumentos**
* `arr` — Array para o qual serão calculadas as diferenças entre elementos adjacentes. [`Array(T)`](/pt-BR/reference/data-types/array)
**Valor retornado**
Retorna um array com as diferenças entre elementos adjacentes do array [`UInt*`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT arrayDifference([1, 2, 3, 4]);
```
```response title=Response theme={null}
[0,1,1,1]
```
**Exemplo de overflow causado pelo tipo de resultado Int64**
```sql title=Query theme={null}
SELECT arrayDifference([0, 10000000000000000000]);
```
```response title=Response theme={null}
┌─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**
```sql theme={null}
arrayDistinct(arr)
```
**Argumentos**
* `arr` — Array da qual extrair elementos distintos. [`Array(T)`](/pt-BR/reference/data-types/array)
**Valor retornado**
Retorna um array contendo os elementos distintos [`Array(T)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT arrayDistinct([1, 2, 2, 3, 1]);
```
```response title=Response theme={null}
[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**
```sql theme={null}
arrayDotProduct(v1, v2)
```
**Argumentos**
* `v1` — Primeiro vetor. [`Array((U)Int* | Float* | Decimal)`](/pt-BR/reference/data-types/array) ou [`Tuple((U)Int* | Float* | Decimal)`](/pt-BR/reference/data-types/tuple)
* `v2` — Segundo vetor. [`Array((U)Int* | Float* | Decimal)`](/pt-BR/reference/data-types/array) ou [`Tuple((U)Int* | Float* | Decimal)`](/pt-BR/reference/data-types/tuple)
**Valor retornado**
O produto escalar dos dois vetores.
O tipo de retorno é determinado pelos tipos dos argumentos. Se Arrays ou Tuples contiverem tipos de elemento mistos, o tipo do resultado será o supertipo.
[`(U)Int*`](/pt-BR/reference/data-types/int-uint) ou [`Float*`](/pt-BR/reference/data-types/float) ou [`Decimal`](/pt-BR/reference/data-types/decimal)
**Exemplos**
**Exemplo de Array**
```sql title=Query theme={null}
SELECT arrayDotProduct([1, 2, 3], [4, 5, 6]) AS res, toTypeName(res);
```
```response title=Response theme={null}
32 UInt16
```
**Exemplo de Tuple**
```sql title=Query theme={null}
SELECT dotProduct((1::UInt16, 2::UInt8, 3::Float32),(4::Int16, 5::Float32, 6::UInt8)) AS res, toTypeName(res);
```
```response title=Response theme={null}
32 Float64
```
## arrayElement
Introduzido em: v1.1.0
Obtém o elemento do array fornecido no índice `n`, em que `n` pode ser de qualquer tipo inteiro.
Se o índice estiver fora dos limites de um array, a função retornará um valor padrão (0 para números, uma string vazia para strings etc.),
exceto no caso de argumentos com um array não constante e um índice constante 0. Nesse caso, ocorrerá o erro `Array indices are 1-based`.
Arrays no ClickHouse são indexados a partir de 1.
Índices negativos são suportados. Nesse caso, o elemento correspondente é selecionado, contando a partir do final. Por exemplo, `arr[-1]` é o último item do array.
O operador `[n]` fornece a mesma funcionalidade.
**Sintaxe**
```sql theme={null}
arrayElement(arr, n)
```
**Argumentos**
* `arr` — O array em que pesquisar. [`Array(T)`](/pt-BR/reference/data-types/array). - `n` — Posição do elemento a ser obtido. [`(U)Int*`](/pt-BR/reference/data-types/int-uint).
**Valor retornado**
Retorna um único array combinado a partir dos argumentos de array fornecidos [`Array(T)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT arrayElement(arr, 2) FROM (SELECT [1, 2, 3] AS arr)
```
```response title=Response theme={null}
2
```
**Indexação com índices negativos**
```sql title=Query theme={null}
SELECT arrayElement(arr, -1) FROM (SELECT [1, 2, 3] AS arr)
```
```response title=Response theme={null}
3
```
**Uso da notação \[n]**
```sql title=Query theme={null}
SELECT arr[2] FROM (SELECT [1, 2, 3] AS arr)
```
```response title=Response theme={null}
2
```
**Índice fora dos limites do array**
```sql title=Query theme={null}
SELECT arrayElement(arr, 4) FROM (SELECT [1, 2, 3] AS arr)
```
```response title=Response theme={null}
0
```
## arrayElementOrNull
Introduzido em: v1.1.0
Obtém o elemento do array fornecido no índice `n`, em que `n` pode ser qualquer tipo inteiro.
Se o índice estiver fora dos limites do array, `NULL` será retornado em vez de um valor padrão.
Arrays no ClickHouse são indexados a partir de 1.
Índices negativos são compatíveis. Nesse caso, seleciona o elemento correspondente contado a partir do fim. Por exemplo, `arr[-1]` é o último item do array.
**Sintaxe**
```sql theme={null}
arrayElementOrNull(arrays)
```
**Argumentos**
* `arrays` — Número arbitrário de argumentos do tipo array. [`Array`](/pt-BR/reference/data-types/array)
**Valor retornado**
Retorna um único array combinado a partir dos argumentos fornecidos. [`Array(T)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT arrayElementOrNull(arr, 2) FROM (SELECT [1, 2, 3] AS arr)
```
```response title=Response theme={null}
2
```
**Indexação com índices negativos**
```sql title=Query theme={null}
SELECT arrayElementOrNull(arr, -1) FROM (SELECT [1, 2, 3] AS arr)
```
```response title=Response theme={null}
3
```
**Índice fora dos limites do array**
```sql title=Query theme={null}
SELECT arrayElementOrNull(arr, 4) FROM (SELECT [1, 2, 3] AS arr)
```
```response title=Response theme={null}
NULL
```
## arrayEnumerate
Introduzido em: v1.1.0
Retorna o Array `[1, 2, 3, ..., length (arr)]`
Essa função normalmente é usada com a cláusula [`ARRAY JOIN`](/pt-BR/reference/statements/select/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**
```sql theme={null}
arrayEnumerate(arr)
```
**Argumentos**
* `arr` — O array a ser enumerado. [`Array`](/pt-BR/reference/data-types/array)
**Valor retornado**
Retorna o array `[1, 2, 3, ..., length (arr)]`. [`Array(UInt32)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo básico com ARRAY JOIN**
```sql title=Query theme={null}
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 title=Response theme={null}
┌─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**
```sql theme={null}
arrayEnumerateDense(arr)
```
**Argumentos**
* `arr` — O array a ser enumerado. [`Array(T)`](/pt-BR/reference/data-types/array)
**Valor retornado**
Retorna um array do mesmo tamanho que `arr`, indicando onde cada elemento aparece pela primeira vez no array de origem [`Array(T)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT arrayEnumerateDense([10, 20, 10, 30])
```
```response title=Response theme={null}
[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**
```sql theme={null}
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*`](/pt-BR/reference/data-types/int-uint)
* `arr` — Array multidimensional a ser enumerado. [`Array(T)`](/pt-BR/reference/data-types/array)
* `max_array_depth` — A profundidade efetiva máxima. Deve ser menor ou igual à profundidade de `arr`. [`UInt*`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna um array que indica onde cada elemento aparece pela primeira vez no array de origem [`Array`](/pt-BR/reference/data-types/array)
**Exemplos**
**Uso básico**
```sql title=Query theme={null}
-- Com clear_depth=1 e max_array_depth=1, o resultado é idêntico ao que arrayEnumerateDense produziria.
SELECT arrayEnumerateDenseRanked(1,[10, 20, 10, 30],1);
```
```response title=Response theme={null}
[1,2,1,3]
```
**Uso com array multidimensional**
```sql title=Query theme={null}
-- Neste exemplo, arrayEnumerateDenseRanked é usado para obter um array indicando, para cada elemento do
-- array multidimensional, qual é sua posição entre os elementos de mesmo valor.
-- Para a primeira linha do array passado, [10, 10, 30, 20], a primeira linha correspondente do resultado é [1, 1, 2, 3],
-- indicando que 10 é o primeiro número encontrado nas posições 1 e 2, 30 é o segundo número encontrado na posição 3
-- e 20 é o terceiro número encontrado na posição 4.
-- Para a segunda linha, [40, 50, 10, 30], a segunda linha correspondente do resultado é [4,5,1,2], indicando que 40
-- e 50 são o quarto e o quinto números encontrados nas posições 1 e 2 dessa linha, que outro 10
-- (o primeiro número encontrado) está na posição 3 e 30 (o segundo número encontrado) está na última posição.
SELECT arrayEnumerateDenseRanked(1,[[10,10,30,20],[40,50,10,30]],2);
```
```response title=Response theme={null}
[[1,1,2,3],[4,5,1,2]]
```
**Exemplo com clear\_depth maior**
```sql title=Query theme={null}
-- Alterar clear_depth=2 faz com que a enumeração ocorra separadamente para cada linha de novo.
SELECT arrayEnumerateDenseRanked(2,[[10,10,30,20],[40,50,10,30]],2);
```
```response title=Response theme={null}
[[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**
```sql theme={null}
arrayEnumerateUniq(arr1[, arr2, ... , arrN])
```
**Argumentos**
* `arr1` — Primeiro array a ser processado. [`Array(T)`](/pt-BR/reference/data-types/array)
* `arr2, ...` — Opcional. Arrays adicionais do mesmo tamanho para unicidade de tuplas. [`Array(UInt32)`](/pt-BR/reference/data-types/array)
**Valor retornado**
Retorna um array em que cada elemento representa a posição entre os elementos com o mesmo valor ou tupla. [`Array(T)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Uso básico**
```sql title=Query theme={null}
SELECT arrayEnumerateUniq([10, 20, 10, 30]);
```
```response title=Response theme={null}
[1, 1, 2, 1]
```
**Vários arrays**
```sql title=Query theme={null}
SELECT arrayEnumerateUniq([1, 1, 1, 2, 2, 2], [1, 1, 2, 1, 1, 2]);
```
```response title=Response theme={null}
[1,2,1,1,2,1]
```
**Agregação com ARRAY JOIN**
```sql title=Query theme={null}
-- Cada ID de objetivo tem um cálculo do número de conversões (cada elemento na estrutura de dados aninhada Goals é um objetivo que foi atingido, ao qual nos referimos como uma conversão)
-- e o número de sessões. Sem o ARRAY JOIN, teríamos contado o número de sessões como sum(Sign). Mas neste caso específico,
-- as linhas foram multiplicadas pela estrutura aninhada Goals, portanto, para contar cada sessão apenas uma vez depois disso, aplicamos uma condição ao
-- valor da função arrayEnumerateUniq(Goals.ID).
SELECT
Goals.ID AS GoalID,
sum(Sign) AS Reaches,
sumIf(Sign, num = 1) AS Visits
FROM test.visits
ARRAY JOIN
Goals,
arrayEnumerateUniq(Goals.ID) AS num
WHERE CounterID = 160656
GROUP BY GoalID
ORDER BY Reaches DESC
LIMIT 10
```
```response title=Response theme={null}
┌──GoalID─┬─Reaches─┬─Visits─┐
│ 53225 │ 3214 │ 1097 │
│ 2825062 │ 3188 │ 1097 │
│ 56600 │ 2803 │ 488 │
│ 1989037 │ 2401 │ 365 │
│ 2830064 │ 2396 │ 910 │
│ 1113562 │ 2372 │ 373 │
│ 3270895 │ 2262 │ 812 │
│ 1084657 │ 2262 │ 345 │
│ 56599 │ 2260 │ 799 │
│ 3271094 │ 2256 │ 812 │
└─────────┴─────────┴────────┘
```
## arrayEnumerateUniqRanked
Introduzido em: v20.1.0
Retorna um array (ou array multidimensional) com as mesmas dimensões do array de entrada,
indicando, para cada elemento, qual é sua posição entre os elementos com o mesmo valor.
Permite enumerar um array multidimensional com a possibilidade de especificar até que profundidade procurar dentro do array.
**Sintaxe**
```sql theme={null}
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*`](/pt-BR/reference/data-types/int-uint)
* `arr` — Array N-dimensional a ser enumerado. [`Array(T)`](/pt-BR/reference/data-types/array)
* `max_array_depth` — A profundidade efetiva máxima. Inteiro positivo menor ou igual à profundidade de `arr`. [`UInt*`](/pt-BR/reference/data-types/int-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)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo 1**
```sql title=Query theme={null}
-- Com clear_depth=1 e max_array_depth=1, o resultado de arrayEnumerateUniqRanked
-- é idêntico ao que arrayEnumerateUniq retornaria para o mesmo array.
SELECT arrayEnumerateUniqRanked(1, [1, 2, 1], 1);
```
```response title=Response theme={null}
[1, 1, 2]
```
**Exemplo 2**
```sql title=Query theme={null}
-- com clear_depth=1 e max_array_depth=1, o resultado de arrayEnumerateUniqRanked
-- é idêntico ao que arrayEnumerateUniq produziria para o mesmo array.
SELECT arrayEnumerateUniqRanked(1, [[1, 2, 3], [2, 2, 1], [3]], 2);", "[[1, 1, 1], [2, 3, 2], [2]]
```
```response title=Response theme={null}
[1, 1, 2]
```
**Exemplo 3**
```sql title=Query theme={null}
-- Neste exemplo, arrayEnumerateUniqRanked é usado para obter um array indicando,
-- para cada elemento do array multidimensional, qual é sua posição entre os elementos
-- de mesmo valor. Para a primeira linha do array fornecido, [1, 2, 3], o resultado
-- correspondente é [1, 1, 1], indicando que esta é a primeira vez que 1, 2 e 3 aparecem.
-- Para a segunda linha do array fornecido, [2, 2, 1], o resultado correspondente é [2, 3, 3],
-- indicando que 2 aparece pela segunda e terceira vez, e 1 aparece
-- pela segunda vez. Da mesma forma, para a terceira linha do array fornecido [3], o
-- resultado correspondente é [2], indicando que 3 aparece pela segunda vez.
SELECT arrayEnumerateUniqRanked(1, [[1, 2, 3], [2, 2, 1], [3]], 2);
```
```response title=Response theme={null}
[[1, 1, 1], [2, 3, 2], [2]]
```
**Exemplo 4**
```sql title=Query theme={null}
-- Alterar clear_depth=2 faz com que os elementos sejam enumerados separadamente para cada linha.
SELECT arrayEnumerateUniqRanked(2,[[1, 2, 3],[2, 2, 1],[3]], 2);
```
```response title=Response theme={null}
[[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**
```sql theme={null}
arrayExcept(source, except)
```
**Argumentos**
* `source` — O array de entrada que contém os elementos a serem filtrados. [`Array(T)`](/pt-BR/reference/data-types/array)
* `except` — O array que contém os elementos a serem excluídos do resultado. [`Array(T)`](/pt-BR/reference/data-types/array)
**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)`](/pt-BR/reference/data-types/array)
**Exemplos**
**básico**
```sql title=Query theme={null}
SELECT arrayExcept([1, 2, 3, 2, 4], [3, 5])
```
```response title=Response theme={null}
[1, 2, 2, 4]
```
**with\_nulls1**
```sql title=Query theme={null}
SELECT arrayExcept([1, NULL, 2, NULL], [2])
```
```response title=Response theme={null}
[1, NULL, NULL]
```
**with\_nulls2**
```sql title=Query theme={null}
SELECT arrayExcept([1, NULL, 2, NULL], [NULL, 2, NULL])
```
```response title=Response theme={null}
[1]
```
**strings**
```sql title=Query theme={null}
SELECT arrayExcept(['apple', 'banana', 'cherry'], ['banana', 'date'])
```
```response title=Response theme={null}
['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**
```sql theme={null}
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`](/pt-BR/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — O array de origem a ser processado. [`Array(T)`](/pt-BR/reference/data-types/array)
* `[, cond1_arr, ... , condN_arr]` — Opcional. N arrays de condição que fornecem argumentos adicionais para a função lambda. [`Array(T)`](/pt-BR/reference/data-types/array)
**Valor retornado**
Retorna `1` se a função lambda retornar verdadeiro para pelo menos um elemento; caso contrário, `0`. [`UInt8`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT arrayExists(x, y -> x=y, [1, 2, 3], [0, 0, 0])
```
```response title=Response theme={null}
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**
```sql theme={null}
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`](/pt-BR/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — O array de origem a ser processado. [`função lambda`](/pt-BR/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `[, cond1_arr, ... , condN_arr]` — Opcional. N arrays de condição que fornecem argumentos adicionais à função lambda. [`Array(T)`](/pt-BR/reference/data-types/array)
**Valor retornado**
Retorna um array [`Array(T)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo com um único array**
```sql title=Query theme={null}
SELECT arrayFill(x -> not isNull(x), [1, null, 2, null]) AS res
```
```response title=Response theme={null}
[1, 1, 2, 2]
```
**Exemplo com dois arrays**
```sql title=Query theme={null}
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 title=Response theme={null}
[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**
```sql theme={null}
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`](/pt-BR/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — O array de origem a ser processado. [`Array(T)`](/pt-BR/reference/data-types/array)
* `[, cond1_arr, ... , condN_arr]` — Opcional. N arrays de condição que fornecem argumentos adicionais para a função lambda. [`Array(T)`](/pt-BR/reference/data-types/array)
**Valor retornado**
Retorna um subconjunto do array de origem [`Array(T)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo 1**
```sql title=Query theme={null}
SELECT arrayFilter(x -> x LIKE '%World%', ['Hello', 'abc World']) AS res
```
```response title=Response theme={null}
['abc World']
```
**Exemplo 2**
```sql title=Query theme={null}
SELECT
arrayFilter(
(i, x) -> x LIKE '%World%',
arrayEnumerate(arr),
['Hello', 'abc World'] AS arr)
AS res
```
```response title=Response theme={null}
[2]
```
## arrayFirst
Introduzido em: v1.1.0
Retorna o primeiro elemento no array de entrada para o qual `func(x[, y1, y2, ... yN])` retorna verdadeiro; caso contrário, retorna um valor padrão.
**Sintaxe**
```sql theme={null}
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](/pt-BR/reference/functions/regular-functions/overview#arrow-operator-and-lambda). - `source_arr` — O array de origem a ser processado. [`Array(T)`](/pt-BR/reference/data-types/array). - `[, cond1_arr, ... , condN_arr]` — Opcional. N arrays de condição que fornecem argumentos adicionais à função lambda. [`Array(T)`](/pt-BR/reference/data-types/array).
**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**
```sql title=Query theme={null}
SELECT arrayFirst(x, y -> x=y, ['a', 'b', 'c'], ['c', 'b', 'a'])
```
```response title=Response theme={null}
b
```
**Nenhuma correspondência**
```sql title=Query theme={null}
SELECT arrayFirst(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)
```
```response title=Response theme={null}
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**
```sql theme={null}
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](/pt-BR/reference/functions/regular-functions/overview#arrow-operator-and-lambda). - `source_arr` — O array de origem a ser processado. [`Array(T)`](/pt-BR/reference/data-types/array). - `[, cond1_arr, ... , condN_arr]` — Opcional. N arrays de condição que fornecem argumentos adicionais para a função lambda. [`Array(T)`](/pt-BR/reference/data-types/array).
**Valor retornado**
Retorna o índice do primeiro elemento do array de origem para o qual `func` é verdadeiro; caso contrário, retorna `0` [`UInt32`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT arrayFirstIndex(x, y -> x=y, ['a', 'b', 'c'], ['c', 'b', 'a'])
```
```response title=Response theme={null}
2
```
**Sem correspondência**
```sql title=Query theme={null}
SELECT arrayFirstIndex(x, y -> x=y, ['a', 'b', 'c'], ['d', 'e', 'f'])
```
```response title=Response theme={null}
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**
```sql theme={null}
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`](/pt-BR/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — O array de origem a ser processado. [`Array(T)`](/pt-BR/reference/data-types/array)
* `[, cond1_arr, ... , condN_arr]` — Opcional. N arrays de condição que fornecem argumentos adicionais à função lambda. [`Array(T)`](/pt-BR/reference/data-types/array)
**Valor retornado**
Retorna o primeiro elemento do array de origem para o qual `func` é verdadeiro; caso contrário, retorna `NULL`.
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT arrayFirstOrNull(x, y -> x=y, ['a', 'b', 'c'], ['c', 'b', 'a'])
```
```response title=Response theme={null}
b
```
**Sem correspondência**
```sql title=Query theme={null}
SELECT arrayFirstOrNull(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)
```
```response title=Response theme={null}
NULL Nullable(UInt8)
```
## arrayFlatten
Introduzido em: v20.1.0
Converte um array de arrays em um array plano.
Função:
* Aplica-se a qualquer nível de profundidade de arrays aninhados.
* Não altera arrays que já são planos.
O array achatado contém todos os elementos de todos os arrays de origem.
**Sintaxe**
```sql theme={null}
arrayFlatten(arr)
```
**Aliases**: `flatten`
**Argumentos**
* `arr` — Um array multidimensional. [`Array(Array(T))`](/pt-BR/reference/data-types/array)
**Valor retornado**
Retorna um array unidimensional a partir do array multidimensional [`Array(T)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT arrayFlatten([[[1]], [[2], [3]]]);
```
```response title=Response theme={null}
[1, 2, 3]
```
## arrayFold
Introduzido em: v23.10.0
Aplica uma função lambda a um ou mais arrays de mesmo tamanho e acumula o resultado em um acumulador.
**Sintaxe**
```sql theme={null}
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`](/pt-BR/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `arr1 [, arr2, arr3, ... arrN]` — N arrays sobre os quais a operação será aplicada. [`Array(T)`](/pt-BR/reference/data-types/array)
* `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**
```sql title=Query theme={null}
SELECT arrayFold(acc,x -> acc + x*2, [1, 2, 3, 4], 3::Int64) AS res;
```
```response title=Response theme={null}
23
```
**Sequência de Fibonacci**
```sql title=Query theme={null}
SELECT arrayFold(acc, x -> (acc.2, acc.2 + acc.1),range(number),(1::Int64, 0::Int64)).1 AS fibonacci FROM numbers(1,10);
```
```response title=Response theme={null}
┌─fibonacci─┐
│ 0 │
│ 1 │
│ 1 │
│ 2 │
│ 3 │
│ 5 │
│ 8 │
│ 13 │
│ 21 │
│ 34 │
└───────────┘
```
**Exemplo com vários arrays**
```sql title=Query theme={null}
SELECT arrayFold(
(acc, x, y) -> acc + (x * y),
[1, 2, 3, 4],
[10, 20, 30, 40],
0::Int64
) AS res;
```
```response title=Response theme={null}
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**
```sql theme={null}
arrayIntersect(arr, arr1, ..., arrN)
```
**Argumentos**
* `arrN` — N arrays a partir dos quais o novo array será criado. [`Array(T)`](/pt-BR/reference/data-types/array).
**Valor retornado**
Retorna um array com elementos distintos presentes em todos os N arrays [`Array(T)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT
arrayIntersect([1, 2], [1, 3], [2, 3]) AS empty_intersection,
arrayIntersect([1, 2], [1, 3], [1, 4]) AS non_empty_intersection
```
```response title=Response theme={null}
┌─empty_intersection─┬─non_empty_intersection─┐
│ [] │ [1] │
└────────────────────┴────────────────────────┘
```
## arrayJaccardIndex
Introduzido em: v23.7.0
Retorna o [índice de Jaccard](https://en.wikipedia.org/wiki/Jaccard_index) de dois arrays.
**Sintaxe**
```sql theme={null}
arrayJaccardIndex(arr_x, arr_y)
```
**Argumentos**
* `arr_x` — Primeiro array. [`Array(T)`](/pt-BR/reference/data-types/array)
* `arr_y` — Segundo array. [`Array(T)`](/pt-BR/reference/data-types/array)
**Valor retornado**
Retorna o índice de Jaccard entre `arr_x` e `arr_y` [`Float64`](/pt-BR/reference/data-types/float)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT arrayJaccardIndex([1, 2], [2, 3]) AS res
```
```response title=Response theme={null}
0.3333333333333333
```
## arrayJoin
Introduzido em: v1.1.0
A função `arrayJoin` recebe uma linha que contém um array e o expande, gerando várias linhas — uma para cada elemento do array.
Isso contrasta com as funções regulares no ClickHouse, que mapeiam valores de entrada para valores de saída dentro da mesma linha,
e com as funções de agregação, que recebem um grupo de linhas e as "comprimem" ou "reduzem" a uma única linha de resumo
(ou a um único valor dentro de uma linha de resumo, se usadas com `GROUP BY`).
Todos os valores nas colunas são simplesmente copiados, exceto os valores da coluna à qual essa função é aplicada;
eles são substituídos pelo valor correspondente do array.
**Sintaxe**
```sql theme={null}
arrayJoin(arr)
```
**Aliases**: `unnest`
**Argumentos**
* `arr` — Um array a ser expandido. [`Array(T)`](/pt-BR/reference/data-types/array)
**Valor retornado**
Retorna um conjunto de linhas geradas a partir da expansão de `arr`.
**Exemplos**
**Uso básico**
```sql title=Query theme={null}
SELECT arrayJoin([1, 2, 3] AS src) AS dst, 'Hello', src
```
```response title=Response theme={null}
┌─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**
```sql title=Query theme={null}
-- A função arrayJoin afeta todas as seções da consulta, incluindo a seção WHERE. Observe o resultado 2, mesmo que a subconsulta tenha retornado 1 linha.
SELECT sum(1) AS impressions
FROM
(
SELECT ['Istanbul', 'Berlin', 'Bobruisk'] AS cities
)
WHERE arrayJoin(cities) IN ['Istanbul', 'Berlin'];
```
```response title=Response theme={null}
┌─impressions─┐
│ 2 │
└─────────────┘
```
**Usando várias funções arrayJoin**
```sql title=Query theme={null}
- Uma consulta pode usar múltiplas funções arrayJoin. Nesse caso, a transformação é executada várias vezes e as linhas são multiplicadas.
SELECT
sum(1) AS impressions,
arrayJoin(cities) AS city,
arrayJoin(browsers) AS browser
FROM
(
SELECT
['Istanbul', 'Berlin', 'Bobruisk'] AS cities,
['Firefox', 'Chrome', 'Chrome'] AS browsers
)
GROUP BY
2,
3
```
```response title=Response theme={null}
┌─impressions─┬─city─────┬─browser─┐
│ 2 │ Istanbul │ Chrome │
│ 1 │ Istanbul │ Firefox │
│ 2 │ Berlin │ Chrome │
│ 1 │ Berlin │ Firefox │
│ 2 │ Bobruisk │ Chrome │
│ 1 │ Bobruisk │ Firefox │
└─────────────┴──────────┴─────────┘
```
**Resultados inesperados devido a otimizações**
```sql title=Query theme={null}
-- Usar múltiplos arrayJoin com a mesma expressão pode não produzir o resultado esperado devido a otimizações.
-- Para esses casos, considere modificar a expressão de array repetida com operações extras que não afetam o resultado do join.
- e.g. arrayJoin(arraySort(arr)), arrayJoin(arrayConcat(arr, []))
SELECT
arrayJoin(dice) as first_throw,
/* arrayJoin(dice) as second_throw */ -- é tecnicamente correto, mas eliminará o conjunto de resultados
arrayJoin(arrayConcat(dice, [])) as second_throw -- expressão intencionalmente alterada para forçar reavaliação
FROM (
SELECT [1, 2, 3, 4, 5, 6] as dice
);
```
```response title=Response theme={null}
┌─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**
```sql title=Query theme={null}
-- Observe a sintaxe ARRAY JOIN na consulta `SELECT` abaixo, que oferece possibilidades mais amplas.
-- ARRAY JOIN permite converter múltiplos arrays com o mesmo número de elementos de uma vez.
SELECT
sum(1) AS impressions,
city,
browser
FROM
(
SELECT
['Istanbul', 'Berlin', 'Bobruisk'] AS cities,
['Firefox', 'Chrome', 'Chrome'] AS browsers
)
ARRAY JOIN
cities AS city,
browsers AS browser
GROUP BY
2,
3
```
```response title=Response theme={null}
┌─impressions─┬─city─────┬─browser─┐
│ 1 │ Istanbul │ Firefox │
│ 1 │ Berlin │ Chrome │
│ 1 │ Bobruisk │ Chrome │
└─────────────┴──────────┴─────────┘
```
**Uso de Tuple**
```sql title=Query theme={null}
-- Você também pode usar Tuple
SELECT
sum(1) AS impressions,
(arrayJoin(arrayZip(cities, browsers)) AS t).1 AS city,
t.2 AS browser
FROM
(
SELECT
['Istanbul', 'Berlin', 'Bobruisk'] AS cities,
['Firefox', 'Chrome', 'Chrome'] AS browsers
)
GROUP BY
2,
3
```
```response title=Response theme={null}
┌─impressions─┬─city─────┬─browser─┐
│ 1 │ Istanbul │ Firefox │
│ 1 │ Berlin │ Chrome │
│ 1 │ Bobruisk │ Chrome │
└─────────────┴──────────┴─────────┘
```
## arrayLast
Introduzido em: v1.1.0
Retorna o último elemento no array de origem para o qual uma função lambda `func(x [, y1, y2, ... yN])` retorna true; caso contrário, retorna um valor padrão.
**Sintaxe**
```sql theme={null}
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](/pt-BR/reference/functions/regular-functions/overview#arrow-operator-and-lambda). - `source` — O array de origem a ser processado. [`Array(T)`](/pt-BR/reference/data-types/array). - `[, cond1, ... , condN]` — Opcional. N arrays de condição que fornecem argumentos adicionais à função lambda. [`Array(T)`](/pt-BR/reference/data-types/array).
**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**
```sql title=Query theme={null}
SELECT arrayLast(x, y -> x=y, ['a', 'b', 'c'], ['a', 'b', 'c'])
```
```response title=Response theme={null}
c
```
**Nenhuma correspondência**
```sql title=Query theme={null}
SELECT arrayFirst(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)
```
```response title=Response theme={null}
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**
```sql theme={null}
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`](/pt-BR/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — O array de origem a ser processado. [`Array(T)`](/pt-BR/reference/data-types/array)
* `[, cond1_arr, ... , condN_arr]` — Opcional. N arrays de condição que fornecem argumentos adicionais para a função lambda. [`Array(T)`](/pt-BR/reference/data-types/array)
**Valor retornado**
Retorna o índice do último elemento do array de origem para o qual `func` é verdadeiro; caso contrário, retorna `0` [`UInt32`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT arrayLastIndex(x, y -> x=y, ['a', 'b', 'c'], ['a', 'b', 'c']);
```
```response title=Response theme={null}
3
```
**Nenhuma correspondência**
```sql title=Query theme={null}
SELECT arrayLastIndex(x, y -> x=y, ['a', 'b', 'c'], ['d', 'e', 'f']);
```
```response title=Response theme={null}
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**
```sql theme={null}
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](/pt-BR/reference/functions/regular-functions/overview#arrow-operator-and-lambda). - `source_arr` — O array de origem a ser processado. [`Array(T)`](/pt-BR/reference/data-types/array). - `[, cond1_arr, ... , condN_arr]` — Opcional. N arrays de condição que fornecem argumentos adicionais para a função lambda. [`Array(T)`](/pt-BR/reference/data-types/array).
**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**
```sql title=Query theme={null}
SELECT arrayLastOrNull(x, y -> x=y, ['a', 'b', 'c'], ['a', 'b', 'c'])
```
```response title=Response theme={null}
c
```
**Nenhuma correspondência**
```sql title=Query theme={null}
SELECT arrayLastOrNull(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)
```
```response title=Response theme={null}
NULL Nullable(UInt8)
```
## arrayLevenshteinDistance
Introduzido em: v25.4.0
Calcula a distância de Levenshtein entre dois arrays.
**Sintaxe**
```sql theme={null}
arrayLevenshteinDistance(from, to)
```
**Argumentos**
* `from` — O primeiro array. [`Array(T)`](/pt-BR/reference/data-types/array). - `to` — O segundo array. [`Array(T)`](/pt-BR/reference/data-types/array).
**Valor retornado**
Distância de Levenshtein entre o primeiro array e o segundo array. [`Float64`](/pt-BR/reference/data-types/float)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT arrayLevenshteinDistance([1, 2, 4], [1, 2, 3])
```
```response title=Response theme={null}
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**
```sql theme={null}
arrayLevenshteinDistanceWeighted(from, to, from_weights, to_weights)
```
**Argumentos**
* `from` — primeiro array. [`Array(T)`](/pt-BR/reference/data-types/array). - `to` — segundo array. [`Array(T)`](/pt-BR/reference/data-types/array). - `from_weights` — pesos do primeiro array. [`Array((U)Int*|Float*)`](/pt-BR/reference/data-types/array)
* `to_weights` — pesos do segundo array. [`Array((U)Int*|Float*)`](/pt-BR/reference/data-types/array)
**Valor retornado**
Distância de Levenshtein entre os dois arrays, com pesos personalizados para cada elemento [`Float64`](/pt-BR/reference/data-types/float)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT arrayLevenshteinDistanceWeighted(['A', 'B', 'C'], ['A', 'K', 'L'], [1.0, 2, 3], [3.0, 4, 5])
```
```response title=Response theme={null}
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**
```sql theme={null}
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`](/pt-BR/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `arr` — N arrays a serem processados. [`Array(T)`](/pt-BR/reference/data-types/array)
**Valor retornado**
Retorna um array com os resultados da função lambda [`Array(T)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT arrayMap(x -> (x + 2), [1, 2, 3]) as res;
```
```response title=Response theme={null}
[3, 4, 5]
```
**Criando uma tupla com elementos de arrays diferentes**
```sql title=Query theme={null}
SELECT arrayMap((x, y) -> (x, y), [1, 2, 3], [4, 5, 6]) AS res
```
```response title=Response theme={null}
[(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**
```sql theme={null}
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`](/pt-BR/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — O array de origem a ser processado. [`Array(T)`](/pt-BR/reference/data-types/array)
* `[, cond1_arr, ... , condN_arr]` — Opcional. N arrays de condição que fornecem argumentos adicionais para a função lambda. [`Array(T)`](/pt-BR/reference/data-types/array)
**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**
```sql title=Query theme={null}
SELECT arrayMax([5, 3, 2, 7]);
```
```response title=Response theme={null}
7
```
**Uso com função lambda**
```sql title=Query theme={null}
SELECT arrayMax(x, y -> x/y, [4, 8, 12, 16], [1, 2, 1, 2]);
```
```response title=Response theme={null}
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**
```sql theme={null}
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`](/pt-BR/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — O array de origem a ser processado. [`Array(T)`](/pt-BR/reference/data-types/array)
* `cond1_arr, ...` — Opcional. N arrays de condição que fornecem argumentos adicionais para a função lambda. [`Array(T)`](/pt-BR/reference/data-types/array)
**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**
```sql title=Query theme={null}
SELECT arrayMin([5, 3, 2, 7]);
```
```response title=Response theme={null}
2
```
**Uso com função lambda**
```sql title=Query theme={null}
SELECT arrayMin(x, y -> x/y, [4, 8, 12, 16], [1, 2, 1, 2]);
```
```response title=Response theme={null}
4
```
## arrayNormalizedGini
Introduzido em: v25.1.0
Calcula o coeficiente de Gini normalizado.
**Sintaxe**
```sql theme={null}
arrayNormalizedGini(predicted, label)
```
**Argumentos**
* `predicted` — O valor previsto. [`Array(T)`](/pt-BR/reference/data-types/array)
* `label` — O valor real. [`Array(T)`](/pt-BR/reference/data-types/array)
**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)`](/pt-BR/reference/data-types/tuple)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT arrayNormalizedGini([0.9, 0.3, 0.8, 0.7],[6, 1, 0, 2]);
```
```response title=Response theme={null}
(0.18055555555555558, 0.2638888888888889, 0.6842105263157896)
```
## arrayPartialReverseSort
Introduzido em: v23.2.0
Esta função é igual a `arrayReverseSort`, mas com o argumento adicional `limit`, que permite ordenação parcial.
Para manter apenas os elementos ordenados, use `arrayResize`.
**Sintaxe**
```sql theme={null}
arrayPartialReverseSort([f,] arr [, arr1, ... ,arrN], limit)
```
**Argumentos**
* `f(arr[, arr1, ... ,arrN])` — A função lambda a ser aplicada aos elementos do array `x`. [`Função lambda`](/pt-BR/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `arr` — Array a ser ordenado. [`Array(T)`](/pt-BR/reference/data-types/array)
* `arr1, ... ,arrN` — N arrays adicionais, caso `f` aceite vários argumentos. [`Array(T)`](/pt-BR/reference/data-types/array)
* `limit` — Valor do índice até o qual a ordenação ocorrerá. [`(U)Int*`](/pt-BR/reference/data-types/int-uint)
**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**
```sql title=Query theme={null}
SELECT arrayPartialReverseSort(2, [5, 9, 1, 3])
```
```response title=Response theme={null}
[9, 5, 1, 3]
```
**simple\_string**
```sql title=Query theme={null}
SELECT arrayPartialReverseSort(2, ['expenses','lasso','embolism','gladly'])
```
```response title=Response theme={null}
['lasso','gladly','expenses','embolism']
```
**retain\_sorted**
```sql title=Query theme={null}
SELECT arrayResize(arrayPartialReverseSort(2, [5, 9, 1, 3]), 2)
```
```response title=Response theme={null}
[9, 5]
```
**lambda\_simple**
```sql title=Query theme={null}
SELECT arrayPartialReverseSort((x) -> -x, 2, [5, 9, 1, 3])
```
```response title=Response theme={null}
[1, 3, 5, 9]
```
**lambda\_complex**
```sql title=Query theme={null}
SELECT arrayPartialReverseSort((x, y) -> -y, 1, [0, 1, 2], [1, 2, 3]) as res
```
```response title=Response theme={null}
[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`](#arrayShuffle) completo.
**Sintaxe**
```sql theme={null}
arrayPartialShuffle(arr [, limit[, seed]])
```
**Argumentos**
* `arr` — O array a ser embaralhado. [`Array(T)`](/pt-BR/reference/data-types/array)
* `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*`](/pt-BR/reference/data-types/int-uint)
* `limit` — Opcional. O número que limita as trocas de elementos, no intervalo `[1..N]`. [`(U)Int*`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Array com elementos parcialmente embaralhados. [`Array(T)`](/pt-BR/reference/data-types/array)
**Exemplos**
**no\_limit1**
```sql title=Query theme={null}
SELECT arrayPartialShuffle([1, 2, 3, 4], 0)
```
```response title=Response theme={null}
[2, 4, 3, 1]
```
**no\_limit2**
```sql title=Query theme={null}
SELECT arrayPartialShuffle([1, 2, 3, 4])
```
```response title=Response theme={null}
[4, 1, 3, 2]
```
**random\_seed**
```sql title=Query theme={null}
SELECT arrayPartialShuffle([1, 2, 3, 4], 2)
```
```response title=Response theme={null}
[3, 4, 1, 2]
```
**explicit\_seed**
```sql title=Query theme={null}
SELECT arrayPartialShuffle([1, 2, 3, 4], 2, 41)
```
```response title=Response theme={null}
[3, 2, 1, 4]
```
**materializar**
```sql title=Query theme={null}
SELECT arrayPartialShuffle(materialize([1, 2, 3, 4]), 2, 42), arrayPartialShuffle([1, 2, 3], 2, 42) FROM numbers(10)
```
```response title=Response theme={null}
┌─arrayPartial⋯4]), 2, 42)─┬─arrayPartial⋯ 3], 2, 42)─┐
│ [3,2,1,4] │ [3,2,1] │
│ [3,2,1,4] │ [3,2,1] │
│ [4,3,2,1] │ [3,2,1] │
│ [1,4,3,2] │ [3,2,1] │
│ [3,4,1,2] │ [3,2,1] │
│ [1,2,3,4] │ [3,2,1] │
│ [1,4,3,2] │ [3,2,1] │
│ [1,4,3,2] │ [3,2,1] │
│ [3,1,2,4] │ [3,2,1] │
│ [1,3,2,4] │ [3,2,1] │
└──────────────────────────┴──────────────────────────┘
```
## arrayPartialSort
Introduzido em: v23.2.0
Esta função é igual a `arraySort`, mas com um argumento adicional, `limit`, que permite ordenação parcial.
Para manter apenas os elementos classificados, use `arrayResize`.
**Sintaxe**
```sql theme={null}
arrayPartialSort([f,] arr [, arr1, ... ,arrN], limit)
```
**Argumentos**
* `f(arr[, arr1, ... ,arrN])` — A função lambda a ser aplicada aos elementos do array `x`. [`Função lambda`](/pt-BR/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `arr` — Array a ser ordenado. [`Array(T)`](/pt-BR/reference/data-types/array)
* `arr1, ... ,arrN` — N arrays adicionais, quando `f` aceita vários argumentos. [`Array(T)`](/pt-BR/reference/data-types/array)
* `limit` — Valor do índice até o qual a ordenação ocorrerá. [`(U)Int*`](/pt-BR/reference/data-types/int-uint)
**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**
```sql title=Query theme={null}
SELECT arrayPartialSort(2, [5, 9, 1, 3])
```
```response title=Response theme={null}
[1, 3, 5, 9]
```
**simple\_string**
```sql title=Query theme={null}
SELECT arrayPartialSort(2, ['expenses', 'lasso', 'embolism', 'gladly'])
```
```response title=Response theme={null}
['embolism', 'expenses', 'gladly', 'lasso']
```
**retain\_sorted**
```sql title=Query theme={null}
SELECT arrayResize(arrayPartialSort(2, [5, 9, 1, 3]), 2)
```
```response title=Response theme={null}
[1, 3]
```
**lambda\_simple**
```sql title=Query theme={null}
SELECT arrayPartialSort((x) -> -x, 2, [5, 9, 1, 3])
```
```response title=Response theme={null}
[9, 5, 1, 3]
```
**lambda\_complex**
```sql title=Query theme={null}
SELECT arrayPartialSort((x, y) -> -y, 1, [0, 1, 2], [1, 2, 3]) as res
```
```response title=Response theme={null}
[2, 1, 0]
```
## arrayPopBack
Introduzido em: v1.1.0
Remove o último elemento da array.
**Sintaxe**
```sql theme={null}
arrayPopBack(arr)
```
**Argumentos**
* `arr` — O array do qual o último elemento será removido. [`Array(T)`](/pt-BR/reference/data-types/array)
**Valor retornado**
Retorna um array idêntico a `arr`, mas sem o último elemento de `arr` [`Array(T)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT arrayPopBack([1, 2, 3]) AS res;
```
```response title=Response theme={null}
[1, 2]
```
## arrayPopFront
Introduzido em: v1.1.0
Remove o primeiro elemento do array.
**Sintaxe**
```sql theme={null}
arrayPopFront(arr)
```
**Argumentos**
* `arr` — O array do qual o primeiro elemento será removido. [`Array(T)`](/pt-BR/reference/data-types/array)
**Valor retornado**
Retorna um array idêntico a `arr`, mas sem o seu primeiro elemento [`Array(T)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT arrayPopFront([1, 2, 3]) AS res;
```
```response title=Response theme={null}
[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**
```sql theme={null}
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`](/pt-BR/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — O array de origem a ser processado. [`Array(T)`](/pt-BR/reference/data-types/array)
* `[, cond1_arr, ... , condN_arr]` — Opcional. N arrays condicionais que fornecem argumentos adicionais para a função lambda. [`Array(T)`](/pt-BR/reference/data-types/array)
**Valor retornado**
Retorna o produto dos elementos no array de origem ou, se fornecida, o produto dos elementos resultantes da função lambda. [`Float64`](/pt-BR/reference/data-types/float)
**Exemplos**
**Exemplo básico**
```sql title=Query theme={null}
SELECT arrayProduct([1, 2, 3, 4]);
```
```response title=Response theme={null}
24
```
**Uso com função lambda**
```sql title=Query theme={null}
SELECT arrayProduct(x, y -> x+y, [2, 2], [2, 2]) AS res;
```
```response title=Response theme={null}
16
```
## arrayPushBack
Introduzido em: v1.1.0
Adiciona um item ao final do array.
**Sintaxe**
```sql theme={null}
arrayPushBack(arr, x)
```
**Argumentos**
* `arr` — O array ao qual o valor `x` será adicionado ao final. [`Array(T)`](/pt-BR/reference/data-types/array)
* `x` —
* Valor único a ser adicionado ao final do array. [`Array(T)`](/pt-BR/reference/data-types/array).
- 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](/pt-BR/reference/data-types).
**Valor retornado**
Retorna um array idêntico a `arr`, mas com um valor adicional `x` no final do array [`Array(T)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT arrayPushBack(['a'], 'b') AS res;
```
```response title=Response theme={null}
['a','b']
```
## arrayPushFront
Introduzido em: v1.1.0
Adiciona um elemento no início do array.
**Sintaxe**
```sql theme={null}
arrayPushFront(arr, x)
```
**Argumentos**
* `arr` — O array ao qual o valor `x` será adicionado ao final. [`Array(T)`](/pt-BR/reference/data-types/array). - `x` —
* Valor único a ser adicionado ao início do array. [`Array(T)`](/pt-BR/reference/data-types/array).
- 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](/pt-BR/reference/data-types).
**Valor retornado**
Retorna um array idêntico a `arr`, mas com um valor adicional `x` no início do array [`Array(T)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT arrayPushFront(['b'], 'a') AS res;
```
```response title=Response theme={null}
['a','b']
```
## arrayROCAUC
Introduzido em: v20.4.0
Calcula a área sob a curva ROC (receiver operating characteristic).
Uma curva ROC é gerada ao traçar a Taxa de Verdadeiros Positivos (TPR) no eixo y e a Taxa de Falsos Positivos (FPR) no eixo x para todos os limiares.
O valor resultante varia de zero a um, e valores mais altos indicam melhor desempenho do modelo.
A ROC AUC (também conhecida simplesmente como AUC) é um conceito de aprendizado de máquina.
Para mais detalhes, consulte [aqui](https://developers.google.com/machine-learning/glossary#pr-auc-area-under-the-pr-curve), [aqui](https://developers.google.com/machine-learning/crash-course/classification/roc-and-auc#expandable-1) e [aqui](https://en.wikipedia.org/wiki/Receiver_operating_characteristic#Area_under_the_curve).
**Sintaxe**
```sql theme={null}
arrayROCAUC(scores, labels[, scale[, partial_offsets]])
```
**Aliases**: `arrayAUC`
**Argumentos**
* `scores` — Pontuações geradas pelo modelo de predição. [`Array((U)Int*)`](/pt-BR/reference/data-types/array) ou [`Array(Float*)`](/pt-BR/reference/data-types/array)
* `labels` — Rótulos das amostras, geralmente 1 para amostra positiva e 0 para amostra negativa. [`Array((U)Int*)`](/pt-BR/reference/data-types/array) ou [`Enum`](/pt-BR/reference/data-types/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`](/pt-BR/reference/data-types/boolean)
* `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](/pt-BR/reference/data-types/array) de [Integers](/pt-BR/reference/data-types/int-uint) não negativos. Opcional.
* `higher_partitions_tp`: O número de rótulos positivos nas partições com pontuações mais altas.
* `higher_partitions_fp`: O número de rótulos negativos nas partições com pontuações mais altas.
* `total_positives`: O número total de amostras positivas em todo o conjunto de dados.
* `total_negatives`: O número total de amostras negativas em todo o conjunto de dados.
Quando `arr_partial_offsets` é usado, `arr_scores` e `arr_labels` devem corresponder apenas a uma partição de todo o conjunto de dados, contendo um intervalo de pontuações.
O conjunto de dados deve ser dividido em partições contíguas, em que cada partição contém o subconjunto de dados cujas pontuações estão dentro de um intervalo específico.
Por exemplo:
* Uma partição pode conter todas as pontuações no intervalo \[0, 0.5).
* Outra partição pode conter pontuações no intervalo \[0.5, 1.0].
**Valor retornado**
Retorna a área sob a curva ROC (receiver operating characteristic). [`Float64`](/pt-BR/reference/data-types/float)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT arrayROCAUC([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1]);
```
```response title=Response theme={null}
0.75
```
## arrayRandomSample
Introduzido em: v23.10.0
Retorna um subconjunto com `samples` elementos aleatórios de um array de entrada. Se `samples` exceder o tamanho do array de entrada, o tamanho da amostra será limitado ao tamanho do array, ou seja, todos os elementos do array serão retornados, mas a ordem deles não é garantida. A função pode lidar tanto com arrays simples quanto com arrays aninhados.
**Sintaxe**
```sql theme={null}
arrayRandomSample(arr, samples)
```
**Argumentos**
* `arr` — O array de entrada ou array multidimensional do qual serão amostrados os elementos. [`Array(T)`](/pt-BR/reference/data-types/array)
* `samples` — O número de elementos a incluir na amostra aleatória. [`(U)Int*`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Um array contendo uma amostra aleatória de elementos do array de entrada [`Array(T)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT arrayRandomSample(['apple', 'banana', 'cherry', 'date'], 2) as res;
```
```response title=Response theme={null}
['cherry','apple']
```
**Usando um array multidimensional**
```sql title=Query theme={null}
SELECT arrayRandomSample([[1, 2], [3, 4], [5, 6]], 2) as res;
```
```response title=Response theme={null}
[[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**
```sql theme={null}
arrayReduce(agg_f, arr1[, arr2, ... , arrN])
```
**Argumentos**
* `agg_f` — O nome de uma função de agregação, que deve ser uma constante. [`String`](/pt-BR/reference/data-types/string)
* `arr1[, arr2, ... , arrN]` — N arrays correspondentes aos argumentos de `agg_f`. [`Array(T)`](/pt-BR/reference/data-types/array)
**Valor retornado**
Retorna o resultado da função de agregação
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT arrayReduce('max', [1, 2, 3]);
```
```response title=Response theme={null}
┌─arrayReduce('max', [1, 2, 3])─┐
│ 3 │
└───────────────────────────────┘
```
**Exemplo com função de agregação usando vários argumentos**
```sql title=Query theme={null}
--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 title=Response theme={null}
┌─arrayReduce('maxIf', [3, 5], [1, 0])─┐
│ 3 │
└──────────────────────────────────────┘
```
**Exemplo com uma função de agregação paramétrica**
```sql title=Query theme={null}
SELECT arrayReduce('uniqUpTo(3)', [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
```
```response title=Response theme={null}
┌─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**
```sql theme={null}
arrayReduceInRanges(agg_f, ranges, arr1[, arr2, ... ,arrN])
```
**Argumentos**
* `agg_f` — O nome da função de agregação a ser usada. [`String`](/pt-BR/reference/data-types/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)`](/pt-BR/reference/data-types/array) ou [`Tuple(T)`](/pt-BR/reference/data-types/tuple)
* `arr1[, arr2, ... ,arrN]` — N arrays como argumentos da função de agregação. [`Array(T)`](/pt-BR/reference/data-types/array)
**Valor retornado**
Retorna um array contendo os resultados da função de agregação nos intervalos especificados [`Array(T)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT arrayReduceInRanges(
'sum',
[(1, 5), (2, 3), (3, 4), (4, 4)],
[1000000, 200000, 30000, 4000, 500, 60, 7]
) AS res
```
```response title=Response theme={null}
┌─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**
```sql theme={null}
arrayRemove(arr, elem)
```
**Aliases**: `array_remove`
**Argumentos**
* `arr` — Array(T) - `elem` — T
**Valor retornado**
Retorna um subconjunto do array de origem [`Array(T)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo 1**
```sql title=Query theme={null}
SELECT arrayRemove([1, 2, 2, 3], 2)
```
```response title=Response theme={null}
[1, 3]
```
**Exemplo 2**
```sql title=Query theme={null}
SELECT arrayRemove(['a', NULL, 'b', NULL], NULL)
```
```response title=Response theme={null}
['a', 'b']
```
## arrayResize
Introduzido em: v1.1.0
Altera o tamanho do array.
**Sintaxe**
```sql theme={null}
arrayResize(arr, size[, extender])
```
**Argumentos**
* `arr` — Array a ser redimensionado. [`Array(T)`](/pt-BR/reference/data-types/array)
* `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)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo 1**
```sql title=Query theme={null}
SELECT arrayResize([1], 3);
```
```response title=Response theme={null}
[1,0,0]
```
**Exemplo 2**
```sql title=Query theme={null}
SELECT arrayResize([1], 3, NULL);
```
```response title=Response theme={null}
[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**
```sql theme={null}
arrayReverse(arr)
```
**Argumentos**
* `arr` — O array a ser revertido. [`Array(T)`](/pt-BR/reference/data-types/array)
**Valor retornado**
Retorna um array do mesmo tamanho que o array original, com os elementos em ordem inversa [`Array(T)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT arrayReverse([1, 2, 3])
```
```response title=Response theme={null}
[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**
```sql theme={null}
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`](/pt-BR/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — O array de origem a ser processado. [`Array(T)`](/pt-BR/reference/data-types/array)
* `[, cond1_arr, ... , condN_arr]` — Opcional. N arrays de condição que fornecem argumentos adicionais para a função lambda. [`Array(T)`](/pt-BR/reference/data-types/array)
**Valor retornado**
Retorna um array com os elementos do array de origem substituídos pelos resultados da função lambda. [`Array(T)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo com um único array**
```sql title=Query theme={null}
SELECT arrayReverseFill(x -> not isNull(x), [1, null, 2, null]) AS res
```
```response title=Response theme={null}
[1, 2, 2, NULL]
```
**Exemplo com dois arrays**
```sql title=Query theme={null}
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 title=Response theme={null}
[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](/pt-BR/reference/functions/regular-functions/overview#higher-order-functions).
**Sintaxe**
```sql theme={null}
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)`](/pt-BR/reference/data-types/array) - `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)`](/pt-BR/reference/data-types/array).
**Exemplos**
**Exemplo 1**
```sql title=Query theme={null}
SELECT arrayReverseSort((x, y) -> y, [4, 3, 5], ['a', 'b', 'c']) AS res;
```
```response title=Response theme={null}
[5,3,4]
```
**Exemplo 2**
```sql title=Query theme={null}
SELECT arrayReverseSort((x, y) -> -y, [4, 3, 5], [1, 2, 3]) AS res;
```
```response title=Response theme={null}
[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**
```sql theme={null}
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`](/pt-BR/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — O array de origem a ser processado. [`Função lambda`](/pt-BR/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `[, cond1_arr, ... , condN_arr]` — Opcional. N arrays de condição que fornecem argumentos adicionais para a função lambda. [`Array(T)`](/pt-BR/reference/data-types/array)
**Valor retornado**
Retorna um array de arrays. [`Array(Array(T))`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT arrayReverseSplit((x, y) -> y, [1, 2, 3, 4, 5], [1, 0, 0, 1, 0]) AS res
```
```response title=Response theme={null}
[[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**
```sql theme={null}
arrayRotateLeft(arr, n)
```
**Argumentos**
* `arr` — O array cujos elementos serão rotacionados.[`Array(T)`](/pt-BR/reference/data-types/array). - `n` — Número de elementos a rotacionar. [`(U)Int8/16/32/64`](/pt-BR/reference/data-types/int-uint).
**Valor retornado**
Um array rotacionado para a esquerda pelo número especificado de elementos [`Array(T)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT arrayRotateLeft([1,2,3,4,5,6], 2) as res;
```
```response title=Response theme={null}
[3,4,5,6,1,2]
```
**Valor negativo de n**
```sql title=Query theme={null}
SELECT arrayRotateLeft([1,2,3,4,5,6], -2) as res;
```
```response title=Response theme={null}
[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**
```sql theme={null}
arrayRotateRight(arr, n)
```
**Argumentos**
* `arr` — O array cujos elementos serão rotacionados.[`Array(T)`](/pt-BR/reference/data-types/array). - `n` — Número de elementos a serem rotacionados. [`(U)Int8/16/32/64`](/pt-BR/reference/data-types/int-uint).
**Valor retornado**
Um array rotacionado para a direita pelo número especificado de elementos [`Array(T)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT arrayRotateRight([1,2,3,4,5,6], 2) as res;
```
```response title=Response theme={null}
[5,6,1,2,3,4]
```
**Valor negativo de n**
```sql title=Query theme={null}
SELECT arrayRotateRight([1,2,3,4,5,6], -2) as res;
```
```response title=Response theme={null}
[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**
```sql theme={null}
arrayShiftLeft(arr, n[, default])
```
**Argumentos**
* `arr` — O array cujos elementos devem ser deslocados.[`Array(T)`](/pt-BR/reference/data-types/array). - `n` — Número de elementos a serem deslocados.[`(U)Int8/16/32/64`](/pt-BR/reference/data-types/int-uint). - `default` — Opcional. Valor padrão dos novos elementos.
**Valor retornado**
Um array deslocado para a esquerda pelo número especificado de elementos [`Array(T)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT arrayShiftLeft([1,2,3,4,5,6], 2) as res;
```
```response title=Response theme={null}
[3,4,5,6,0,0]
```
**Valor negativo de n**
```sql title=Query theme={null}
SELECT arrayShiftLeft([1,2,3,4,5,6], -2) as res;
```
```response title=Response theme={null}
[0,0,1,2,3,4]
```
**Usando um valor padrão**
```sql title=Query theme={null}
SELECT arrayShiftLeft([1,2,3,4,5,6], 2, 42) as res;
```
```response title=Response theme={null}
[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**
```sql theme={null}
arrayShiftRight(arr, n[, default])
```
**Argumentos**
* `arr` — O array cujos elementos devem ser deslocados. [`Array(T)`](/pt-BR/reference/data-types/array)
* `n` — Número de elementos a serem deslocados. [`(U)Int8/16/32/64`](/pt-BR/reference/data-types/int-uint)
* `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)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT arrayShiftRight([1, 2, 3, 4, 5, 6], 2) as res;
```
```response title=Response theme={null}
[0, 0, 1, 2, 3, 4]
```
**Valor negativo de n**
```sql title=Query theme={null}
SELECT arrayShiftRight([1, 2, 3, 4, 5, 6], -2) as res;
```
```response title=Response theme={null}
[3, 4, 5, 6, 0, 0]
```
**Usando um valor padrão**
```sql title=Query theme={null}
SELECT arrayShiftRight([1, 2, 3, 4, 5, 6], 2, 42) as res;
```
```response title=Response theme={null}
[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**
```sql theme={null}
arrayShingles(arr, l)
```
**Argumentos**
* `arr` — Array a partir do qual será gerado um array de shingles. [`Array(T)`](/pt-BR/reference/data-types/array)
* `l` — O comprimento de cada shingle. [`(U)Int*`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Um array com os shingles gerados [`Array(T)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT arrayShingles([1, 2, 3, 4], 3) as res;
```
```response title=Response theme={null}
[[1, 2, 3], [2, 3, 4]]
```
## arrayShuffle
Introduzido em: v23.2.0
Retorna um array do mesmo tamanho que o array original, com os elementos em ordem embaralhada.
Os elementos são reordenados de modo que cada permutação possível tenha a mesma probabilidade de ocorrer.
Esta função não materializa constantes.
**Sintaxe**
```sql theme={null}
arrayShuffle(arr [, seed])
```
**Argumentos**
* `arr` — O array que será embaralhado. [`Array(T)`](/pt-BR/reference/data-types/array)
* `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*`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Array com os elementos embaralhados [`Array(T)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo sem seed (resultados instáveis)**
```sql title=Query theme={null}
SELECT arrayShuffle([1, 2, 3, 4]);
```
```response title=Response theme={null}
[1,4,2,3]
```
**Exemplo sem seed (resultados estáveis)**
```sql title=Query theme={null}
SELECT arrayShuffle([1, 2, 3, 4], 41);
```
```response title=Response theme={null}
[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**
```sql theme={null}
arraySimilarity(from, to, from_weights, to_weights)
```
**Argumentos**
* `from` — primeiro array [`Array(T)`](/pt-BR/reference/data-types/array)
* `to` — segundo array [`Array(T)`](/pt-BR/reference/data-types/array)
* `from_weights` — pesos do primeiro array. [`Array((U)Int*|Float*)`](/pt-BR/reference/data-types/array)
* `to_weights` — pesos do segundo array. [`Array((U)Int*|Float*)`](/pt-BR/reference/data-types/array)
**Valor retornado**
Retorna a similaridade entre `0` e `1` entre os dois arrays, com base na distância de Levenshtein ponderada [`Float64`](/pt-BR/reference/data-types/float)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT arraySimilarity(['A', 'B', 'C'], ['A', 'K', 'L'], [1.0, 2, 3], [3.0, 4, 5]);
```
```response title=Response theme={null}
0.2222222222222222
```
## arraySlice
Introduzido em: v1.1.0
Retorna uma parte do array, incluindo elementos `NULL`.
**Sintaxe**
```sql theme={null}
arraySlice(arr, offset [, length])
```
**Argumentos**
* `arr` — Array a ser fatiado. [`Array(T)`](/pt-BR/reference/data-types/array)
* `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*`](/pt-BR/reference/data-types/int-uint)
* `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*`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna uma fatia do array com `length` elementos a partir do `offset` especificado [`Array(T)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT arraySlice([1, 2, NULL, 4, 5], 2, 3) AS res;
```
```response title=Response theme={null}
[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](/pt-BR/reference/functions/regular-functions/overview#higher-order-functions).
**Sintaxe**
```sql theme={null}
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)`](/pt-BR/reference/data-types/array) - `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)`](/pt-BR/reference/data-types/array).
**Exemplos**
**Exemplo 1**
```sql title=Query theme={null}
SELECT arraySort([1, 3, 3, 0]);
```
```response title=Response theme={null}
[0,1,3,3]
```
**Exemplo 2**
```sql title=Query theme={null}
SELECT arraySort(['hello', 'world', '!']);
```
```response title=Response theme={null}
['!','hello','world']
```
**Exemplo 3**
```sql title=Query theme={null}
SELECT arraySort([1, nan, 2, NULL, 3, nan, -4, NULL, inf, -inf]);
```
```response title=Response theme={null}
[-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**
```sql theme={null}
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](/pt-BR/reference/functions/regular-functions/overview#arrow-operator-and-lambda). - `source_arr` — O array de origem a ser dividido [`Array(T)`](/pt-BR/reference/data-types/array). - `[, cond1_arr, ... , condN_arr]` — Opcional. N arrays de condição que fornecem argumentos adicionais para a função lambda. [`Array(T)`](/pt-BR/reference/data-types/array).
**Valor retornado**
Retorna um array de arrays [`Array(Array(T))`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT arraySplit((x, y) -> y, [1, 2, 3, 4, 5], [1, 0, 0, 1, 0]) AS res
```
```response title=Response theme={null}
[[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**
```sql theme={null}
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`](/pt-BR/reference/functions/regular-functions/overview#arrow-operator-and-lambda)
* `source_arr` — O array de origem a ser processado. [`Array(T)`](/pt-BR/reference/data-types/array)
* `, cond1_arr, ... , condN_arr]` — Opcional. N arrays de condição que fornecem argumentos adicionais para a função lambda. [`Array(T)`](/pt-BR/reference/data-types/array)
**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**
```sql title=Query theme={null}
SELECT arraySum([1, 2, 3, 4]);
```
```response title=Response theme={null}
10
```
**Uso com função lambda**
```sql title=Query theme={null}
SELECT arraySum(x, y -> x+y, [1, 1, 1, 1], [1, 1, 1, 1]);
```
```response title=Response theme={null}
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 entrada. O resultado contém apenas valores únicos.
A diferença simétrica de *mais de dois conjuntos* é [definida matematicamente](https://en.wikipedia.org/wiki/Symmetric_difference#n-ary_symmetric_difference)
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**
```sql theme={null}
arraySymmetricDifference(arr1, arr2, ... , arrN)
```
**Argumentos**
* `arrN` — N arrays a partir dos quais o novo array é criado. [`Array(T)`](/pt-BR/reference/data-types/array).
**Valor retornado**
Retorna um array de elementos distintos que não estão presentes em todos os arrays de origem [`Array(T)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
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 title=Response theme={null}
┌─empty_symmetric_difference─┬─non_empty_symmetric_difference─┐
│ [] │ [3,2] │
└────────────────────────────┴────────────────────────────────┘
```
## arrayTranspose
Introduzido em: v26.4.0
Transpõe um array de duas dimensões.
Todos os arrays internos devem ter o mesmo comprimento.
**Sintaxe**
```sql theme={null}
arrayTranspose(arr)
```
**Argumentos**
* `arr` — Um array bidimensional a ser transposto. Todos os arrays internos devem ter o mesmo comprimento. [`Array(Array(T))`](/pt-BR/reference/data-types/array)
**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))`](/pt-BR/reference/data-types/array)
**Exemplos**
**Matriz quadrada**
```sql title=Query theme={null}
SELECT arrayTranspose([[1, 2], [3, 4]])
```
```response title=Response theme={null}
[[1, 3], [2, 4]]
```
**Matriz não quadrada**
```sql title=Query theme={null}
SELECT arrayTranspose([[1, 2, 3], [4, 5, 6]])
```
```response title=Response theme={null}
[[1, 4], [2, 5], [3, 6]]
```
**Elementos de String**
```sql title=Query theme={null}
SELECT arrayTranspose([['a', 'b'], ['c', 'd']])
```
```response title=Response theme={null}
[['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**
```sql theme={null}
arrayUnion(arr1, arr2, ..., arrN)
```
**Argumentos**
* `arrN` — N arrays usados para criar o novo array. [`Array(T)`](/pt-BR/reference/data-types/array)
**Valor retornado**
Retorna um array com elementos distintos dos arrays de origem [`Array(T)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
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 title=Response theme={null}
┌─num_example─┬─str_example────┬─null_example─┐
│ [10,-2,1] │ ['hello','hi'] │ [3,2,1,NULL] │
└─────────────┴────────────────┴──────────────┘
```
## arrayUniq
Introduzido em: v1.1.0
Quando é passado um único argumento, conta o número de elementos distintos no array.
Quando são passados vários argumentos, conta o número de **tuplas** distintas formadas pelos elementos nas posições correspondentes de vários arrays.
Por exemplo, `SELECT arrayUniq([1,2], [3,4], [5,6])` formará as seguintes tuplas:
* Posição 1: (1,3,5)
* Posição 2: (2,4,6)
Em seguida, contará o número de tuplas únicas. Neste caso, `2`.
Todos os arrays passados devem ter o mesmo comprimento.
Se você quiser obter uma lista de itens únicos em um array, pode usar `arrayReduce('groupUniqArray', arr)`.
**Sintaxe**
```sql theme={null}
arrayUniq(arr1[, arr2, ..., arrN])
```
**Argumentos**
* `arr1` — Array em que se conta o número de elementos únicos. [`Array(T)`](/pt-BR/reference/data-types/array)
* `[, 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)`](/pt-BR/reference/data-types/array)
**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`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Argumento único**
```sql title=Query theme={null}
SELECT arrayUniq([1, 1, 2, 2])
```
```response title=Response theme={null}
2
```
**Vários argumentos**
```sql title=Query theme={null}
SELECT arrayUniq([1, 2, 3, 1], [4, 5, 6, 4])
```
```response title=Response theme={null}
3
```
## arrayWithConstant
Introduzido em: v20.1.0
Cria um array de tamanho `length` preenchido com a constante `x`.
**Sintaxe**
```sql theme={null}
arrayWithConstant(N, x)
```
**Argumentos**
* `length` — Número de elementos do array. [`(U)Int*`](/pt-BR/reference/data-types/int-uint)
* `x` — O valor dos `N` elementos do array, de qualquer tipo.
**Valor retornado**
Retorna um Array com `N` elementos com valor `x`. [`Array(T)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT arrayWithConstant(3, 1)
```
```response title=Response theme={null}
[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**
```sql theme={null}
arrayZip(arr1, arr2, ... , arrN)
```
**Argumentos**
* `arr1, arr2, ... , arrN` — N arrays a serem combinados em um único array. [`Array(T)`](/pt-BR/reference/data-types/array)
**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)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT arrayZip(['a', 'b', 'c'], [5, 2, 1]);
```
```response title=Response theme={null}
[('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**
```sql theme={null}
arrayZipUnaligned(arr1, arr2, ..., arrN)
```
**Argumentos**
* `arr1, arr2, ..., arrN` — N arrays a serem combinados em um único array. [`Array(T)`](/pt-BR/reference/data-types/array)
**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)`](/pt-BR/reference/data-types/array) ou [`Tuple(T1, T2, ...)`](/pt-BR/reference/data-types/tuple)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT arrayZipUnaligned(['a'], [1, 2, 3]);
```
```response title=Response theme={null}
[('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**
```sql theme={null}
countEqual(arr, x)
```
**Argumentos**
* `arr` — Array em que será feita a busca. [`Array(T)`](/pt-BR/reference/data-types/array)
* `x` — Valor no array a ser contado. Qualquer tipo.
**Valor retornado**
Retorna o número de elementos do array iguais a `x` [`UInt64`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT countEqual([1, 2, NULL, NULL], NULL)
```
```response title=Response theme={null}
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`](/pt-BR/reference/settings/session-settings#optimize_functions_to_subcolumns). Com `optimize_functions_to_subcolumns = 1`, a função lê apenas a subcoluna [size0](/pt-BR/reference/data-types/array#array-size), 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**
```sql theme={null}
empty(arr)
```
**Argumentos**
* `arr` — Array de entrada. [`Array(T)`](/pt-BR/reference/data-types/array)
**Valor retornado**
Retorna `1` para um array vazio ou `0` para um array não vazio [`UInt8`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT empty([]);
```
```response title=Response theme={null}
1
```
## emptyArrayDate
Introduzido em: v1.1.0
Retorna um array de Date vazio
**Sintaxe**
```sql theme={null}
emptyArrayDate()
```
**Argumentos**
* Nenhum.
**Valor retornado**
Um array vazio de Date. [`Array(T)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT emptyArrayDate
```
```response title=Response theme={null}
[]
```
## emptyArrayDateTime
Introduzido em: v1.1.0
Retorna um array vazio de DateTime
**Sintaxe**
```sql theme={null}
emptyArrayDateTime()
```
**Argumentos**
* Nenhum.
**Valor retornado**
Um array DateTime vazio. [`Array(T)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT emptyArrayDateTime
```
```response title=Response theme={null}
[]
```
## emptyArrayFloat32
Introduzido em: v1.1.0
Retorna um array Float32 vazio
**Sintaxe**
```sql theme={null}
emptyArrayFloat32()
```
**Argumentos**
* Nenhum.
**Valor retornado**
Um array vazio de Float32. [`Array(T)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT emptyArrayFloat32
```
```response title=Response theme={null}
[]
```
## emptyArrayFloat64
Introduzido em: v1.1.0
Retorna um array Float64 vazio
**Sintaxe**
```sql theme={null}
emptyArrayFloat64()
```
**Argumentos**
* Nenhum.
**Valor retornado**
Um array vazio de Float64. [`Array(T)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT emptyArrayFloat64
```
```response title=Response theme={null}
[]
```
## emptyArrayInt16
Introduzido em: v1.1.0
Retorna um array(Int16) vazio
**Sintaxe**
```sql theme={null}
emptyArrayInt16()
```
**Argumentos**
* Nenhum.
**Valor retornado**
Um array Int16 vazio. [`Array(T)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT emptyArrayInt16
```
```response title=Response theme={null}
[]
```
## emptyArrayInt32
Introduzido em: v1.1.0
Retorna um array Int32 vazio
**Sintaxe**
```sql theme={null}
emptyArrayInt32()
```
**Argumentos**
* Nenhum.
**Valor retornado**
Um array vazio de Int32. [`Array(T)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT emptyArrayInt32
```
```response title=Response theme={null}
[]
```
## emptyArrayInt64
Introduzido em: v1.1.0
Retorna um array Int64 vazio
**Sintaxe**
```sql theme={null}
emptyArrayInt64()
```
**Argumentos**
* Nenhum.
**Valor de retorno**
Um array Int64 vazio. [`Array(T)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT emptyArrayInt64
```
```response title=Response theme={null}
[]
```
## emptyArrayInt8
Introduzido em: v1.1.0
Retorna um array(Int8) vazio
**Sintaxe**
```sql theme={null}
emptyArrayInt8()
```
**Argumentos**
* Nenhum.
**Valor retornado**
Um array vazio de Int8. [`Array(T)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT emptyArrayInt8
```
```response title=Response theme={null}
[]
```
## emptyArrayString
Introduzido em: v1.1.0
Retorna um array vazio de String
**Sintaxe**
```sql theme={null}
emptyArrayString()
```
**Argumentos**
* Nenhum.
**Valor retornado**
Um array vazio de `String`. [`Array(T)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT emptyArrayString
```
```response title=Response theme={null}
[]
```
## emptyArrayToSingle
Introduzido em: v1.1.0
Aceita um array vazio e retorna um array com um único elemento, igual ao valor padrão.
**Sintaxe**
```sql theme={null}
emptyArrayToSingle(arr)
```
**Argumentos**
* `arr` — Um array vazio. [`Array(T)`](/pt-BR/reference/data-types/array)
**Valor retornado**
Um array com um único valor do tipo padrão do Array. [`Array(T)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo básico**
```sql title=Query theme={null}
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 title=Response theme={null}
┌─emptyArrayToSingle(a)─┬─emptyArrayToSingle(b)─┬─emptyArrayToSingle(c)───┐
│ [0] │ [''] │ ['1970-01-01 01:00:00'] │
└───────────────────────┴───────────────────────┴─────────────────────────┘
```
## emptyArrayUInt16
Introduzido em: v1.1.0
Retorna um array vazio de UInt16
**Sintaxe**
```sql theme={null}
emptyArrayUInt16()
```
**Argumentos**
* Nenhum.
**Valor retornado**
Um array vazio de UInt16. [`Array(T)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT emptyArrayUInt16
```
```response title=Response theme={null}
[]
```
## emptyArrayUInt32
Introduzido em: v1.1.0
Retorna um array vazio de UInt32
**Sintaxe**
```sql theme={null}
emptyArrayUInt32()
```
**Argumentos**
* Nenhum.
**Valor retornado**
Um array vazio de UInt32. [`Array(T)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT emptyArrayUInt32
```
```response title=Response theme={null}
[]
```
## emptyArrayUInt64
Introduzido em: v1.1.0
Retorna um array vazio de UInt64
**Sintaxe**
```sql theme={null}
emptyArrayUInt64()
```
**Argumentos**
* Nenhum.
**Valor retornado**
Um array UInt64 vazio. [`Array(T)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT emptyArrayUInt64
```
```response title=Response theme={null}
[]
```
## emptyArrayUInt8
Introduzido em: v1.1.0
Retorna um array UInt8 vazio
**Sintaxe**
```sql theme={null}
emptyArrayUInt8()
```
**Argumentos**
* Nenhum.
**Valor retornado**
Um array UInt8 vazio. [`Array(T)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT emptyArrayUInt8
```
```response title=Response theme={null}
[]
```
## 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**
```sql theme={null}
has(haystack, needle)
```
**Argumentos**
* `haystack` — O array, map ou JSON de origem. [`Array`](/pt-BR/reference/data-types/array) ou [`Map`](/pt-BR/reference/data-types/map) ou [`JSON`](/pt-BR/reference/data-types/newjson)
* `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`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Uso básico de Array**
```sql title=Query theme={null}
SELECT has([1, 2, 3], 2)
```
```response title=Response theme={null}
1
```
**Array não encontrado**
```sql title=Query theme={null}
SELECT has([1, 2, 3], 4)
```
```response title=Response theme={null}
0
```
**Uso básico do map**
```sql title=Query theme={null}
SELECT has(map('a', 1, 'b', 2), 'b')
```
```response title=Response theme={null}
1
```
**Caminho JSON**
```sql title=Query theme={null}
SELECT has('{"a": {"b": 1}}'::JSON, 'a.b')
```
```response title=Response theme={null}
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**
```sql theme={null}
hasAll(set, subset)
```
**Argumentos**
* `set` — Array de qualquer tipo com um conjunto de elementos. [`Array(T)`](/pt-BR/reference/data-types/array)
* `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)`](/pt-BR/reference/data-types/array)
**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**
```sql title=Query theme={null}
SELECT hasAll([], [])
```
```response title=Response theme={null}
1
```
**Arrays com valores NULL**
```sql title=Query theme={null}
SELECT hasAll([1, Null], [Null])
```
```response title=Response theme={null}
1
```
**Arrays com valores de um tipo diferente**
```sql title=Query theme={null}
SELECT hasAll([1.0, 2, 3, 4], [1, 3])
```
```response title=Response theme={null}
1
```
**Arrays com valores String**
```sql title=Query theme={null}
SELECT hasAll(['a', 'b'], ['a'])
```
```response title=Response theme={null}
1
```
**Arrays sem um tipo em comum**
```sql title=Query theme={null}
SELECT hasAll([1], ['a'])
```
```response title=Response theme={null}
Lança uma exceção NO_COMMON_TYPE
```
**Array de arrays**
```sql title=Query theme={null}
SELECT hasAll([[1, 2], [3, 4]], [[1, 2], [3, 5]])
```
```response title=Response theme={null}
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**
```sql theme={null}
hasAny(arr_x, arr_y)
```
**Argumentos**
* `arr_x` — Array de qualquer tipo com um conjunto de elementos. [`Array(T)`](/pt-BR/reference/data-types/array)
* `arr_y` — Array de qualquer tipo que tenha um supertipo comum com o array `arr_x`. [`Array(T)`](/pt-BR/reference/data-types/array)
**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**
```sql title=Query theme={null}
SELECT hasAny([1], [])
```
```response title=Response theme={null}
0
```
**Arrays com valores NULL**
```sql title=Query theme={null}
SELECT hasAny([Null], [Null, 1])
```
```response title=Response theme={null}
1
```
**Arrays que contêm valores de tipos diferentes**
```sql title=Query theme={null}
SELECT hasAny([-128, 1., 512], [1])
```
```response title=Response theme={null}
1
```
**Arrays sem um tipo em comum**
```sql title=Query theme={null}
SELECT hasAny([[1, 2], [3, 4]], ['a', 'c'])
```
```response title=Response theme={null}
Lança uma exceção `NO_COMMON_TYPE`
```
**Array de Arrays**
```sql title=Query theme={null}
SELECT hasAll([[1, 2], [3, 4]], [[1, 2], [1, 2]])
```
```response title=Response theme={null}
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**
```sql theme={null}
hasSubstr(arr1, arr2)
```
**Argumentos**
* `arr1` — Array de qualquer tipo com um conjunto de elementos. [`Array(T)`](/pt-BR/reference/data-types/array)
* `arr2` — Array de qualquer tipo com um conjunto de elementos. [`Array(T)`](/pt-BR/reference/data-types/array)
**Valor retornado**
Retorna `1` se o array `arr1` contiver o array `arr2`. Caso contrário, retorna `0`. [`UInt8`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Ambos os arrays estão vazios**
```sql title=Query theme={null}
SELECT hasSubstr([], [])
```
```response title=Response theme={null}
1
```
**Arrays com valores NULL**
```sql title=Query theme={null}
SELECT hasSubstr([1, Null], [Null])
```
```response title=Response theme={null}
1
```
**Arrays com valores de um tipo diferente**
```sql title=Query theme={null}
SELECT hasSubstr([1.0, 2, 3, 4], [1, 3])
```
```response title=Response theme={null}
0
```
**Arrays com strings**
```sql title=Query theme={null}
SELECT hasSubstr(['a', 'b'], ['a'])
```
```response title=Response theme={null}
1
```
**Arrays com ordem válida**
```sql title=Query theme={null}
SELECT hasSubstr(['a', 'b' , 'c'], ['a', 'b'])
```
```response title=Response theme={null}
1
```
**Arrays com ordenação inválida**
```sql title=Query theme={null}
SELECT hasSubstr(['a', 'b' , 'c'], ['a', 'c'])
```
```response title=Response theme={null}
0
```
**Array de arrays**
```sql title=Query theme={null}
SELECT hasSubstr([[1, 2], [3, 4], [5, 6]], [[1, 2], [3, 4]])
```
```response title=Response theme={null}
1
```
**Arrays sem tipo comum**
```sql title=Query theme={null}
SELECT hasSubstr([1, 2, NULL, 3, 4], ['a'])
```
```response title=Response theme={null}
Lança uma exceção `NO_COMMON_TYPE`
```
## indexOf
Introduzido em: v1.1.0
Retorna o índice do primeiro elemento com valor 'x' (a partir de 1), se ele estiver no array.
Se o array não contiver o valor pesquisado, a função retorna `0`.
Elementos definidos como `NULL` são tratados como valores normais.
**Sintaxe**
```sql theme={null}
indexOf(arr, x)
```
**Argumentos**
* `arr` — Um array no qual buscar `x`. [`Array(T)`](/pt-BR/reference/data-types/array)
* `x` — Valor do primeiro elemento em `arr` correspondente a `x` cujo índice deve ser retornado. [`UInt64`](/pt-BR/reference/data-types/int-uint)
**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`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo básico**
```sql title=Query theme={null}
SELECT indexOf([5, 4, 1, 3], 3)
```
```response title=Response theme={null}
4
```
**Array com valores NULL**
```sql title=Query theme={null}
SELECT indexOf([1, 3, NULL, NULL], NULL)
```
```response title=Response theme={null}
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**
```sql theme={null}
indexOfAssumeSorted(arr, x)
```
**Argumentos**
* `arr` — Um array ordenado no qual será feita a busca. [`Array(T)`](/pt-BR/reference/data-types/array)
* `x` — Valor do primeiro elemento correspondente em `arr` ordenado cujo índice deve ser retornado. [`UInt64`](/pt-BR/reference/data-types/int-uint)
**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`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo básico**
```sql title=Query theme={null}
SELECT indexOfAssumeSorted([1, 3, 3, 3, 4, 4, 5], 4)
```
```response title=Response theme={null}
5
```
## kql\_array\_sort\_asc
Introduzido em: v23.10.0
Ordena um ou mais arrays em ordem crescente. O primeiro array é ordenado, e os arrays subsequentes são reorganizados para seguir a ordem do primeiro array após a ordenação. Os valores NULL são colocados no final. Esta é uma função de compatibilidade com KQL (Kusto Query Language).
**Sintaxe**
```sql theme={null}
kql_array_sort_asc(array1[, array2, ..., nulls_last])
```
**Argumentos**
* `array1` — O array a ser ordenado. [`Array(T)`](/pt-BR/reference/data-types/array)
* `array2` — Opcional. Arrays adicionais a serem reordenados de acordo com a ordenação de `array1`. [`Array(T)`](/pt-BR/reference/data-types/array)
* `nulls_last` — Opcional. Um valor booleano que indica se os valores NULL devem aparecer por último. O padrão é true. [`UInt8`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna uma tupla de arrays ordenados em ordem crescente. [`Tuple(Array, ...)`](/pt-BR/reference/data-types/tuple)
**Exemplos**
**Uso básico**
```sql title=Query theme={null}
SELECT kql_array_sort_asc([3, 1, 2])
```
```response title=Response theme={null}
([1, 2, 3])
```
## kql\_array\_sort\_desc
Introduzido em: v23.10.0
Ordena um ou mais arrays em ordem decrescente. O primeiro array é ordenado, e os arrays subsequentes são reordenados para corresponder à ordem do primeiro array após a ordenação. Os valores NULL são colocados no final. Esta é uma função de compatibilidade com KQL (Kusto Query Language).
**Sintaxe**
```sql theme={null}
kql_array_sort_desc(array1[, array2, ..., nulls_last])
```
**Argumentos**
* `array1` — O array a ser ordenado. [`Array(T)`](/pt-BR/reference/data-types/array)
* `array2` — Arrays adicionais opcionais a serem reordenados de acordo com a ordem de `array1`. [`Array(T)`](/pt-BR/reference/data-types/array)
* `nulls_last` — Booleano opcional que indica se os valores nulos devem aparecer por último. O padrão é true. [`UInt8`](/pt-BR/reference/data-types/int-uint)
**Valor retornado**
Retorna uma tupla de arrays ordenados em ordem decrescente. [`Tuple(Array, ...)`](/pt-BR/reference/data-types/tuple)
**Exemplos**
**Uso básico**
```sql title=Query theme={null}
SELECT kql_array_sort_desc([3, 1, 2])
```
```response title=Response theme={null}
([3, 2, 1])
```
## length
Introduzido em: v1.1.0
Calcula o comprimento de uma string ou array.
* Para argumentos String ou FixedString: calcula o número de bytes da string.
* Para argumentos Array: calcula o número de elementos do array.
* Se aplicada a um argumento FixedString, a função é uma expressão constante.
Observe que o número de bytes em uma string não é o mesmo que o número de
"pontos de código" Unicode, nem o mesmo que o número de "clusters de grafemas" Unicode
(o que normalmente chamamos de "caracteres"), nem o mesmo que a largura visível da string.
Não há problema em haver bytes NULL ASCII em strings, e eles também serão contados.
**Sintaxe**
```sql theme={null}
length(x)
```
**Aliases**: `OCTET_LENGTH`
**Argumentos**
* `x` — Valor para o qual se calcula o número de bytes (para String/FixedString) ou de elementos (para Array). [`String`](/pt-BR/reference/data-types/string) ou [`FixedString`](/pt-BR/reference/data-types/fixedstring) ou [`Array(T)`](/pt-BR/reference/data-types/array)
**Valor retornado**
Retorna o número de bytes na String/FixedString `x` / o número de elementos no array `x` [`UInt64`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo com String**
```sql title=Query theme={null}
SELECT length('Hello, world!')
```
```response title=Response theme={null}
13
```
**Exemplo de Array**
```sql title=Query theme={null}
SELECT length(['Hello', 'world'])
```
```response title=Response theme={null}
2
```
**exemplo de constexpr**
```sql title=Query theme={null}
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 title=Response theme={null}
┌─str────┬─str_length_is_constant─┬─fixed_str_length_is_constant─┐
│ hello0 │ 0 │ 1 │
│ hello1 │ 0 │ 1 │
│ hello2 │ 0 │ 1 │
└────────┴────────────────────────┴──────────────────────────────┘
```
**exemplo de Unicode**
```sql title=Query theme={null}
SELECT 'ёлка' AS str1, length(str1), lengthUTF8(str1), normalizeUTF8NFKD(str1) AS str2, length(str2), lengthUTF8(str2)
```
```response title=Response theme={null}
┌─str1─┬─length(str1)─┬─lengthUTF8(str1)─┬─str2─┬─length(str2)─┬─lengthUTF8(str2)─┐
│ ёлка │ 8 │ 4 │ ёлка │ 10 │ 5 │
└──────┴──────────────┴──────────────────┴──────┴──────────────┴──────────────────┘
```
**exemplo de ascii\_vs\_utf8**
```sql title=Query theme={null}
SELECT 'ábc' AS str, length(str), lengthUTF8(str)
```
```response title=Response theme={null}
┌─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`](/pt-BR/reference/settings/session-settings#optimize_functions_to_subcolumns). Com `optimize_functions_to_subcolumns = 1`, a função lê apenas a subcoluna [size0](/pt-BR/reference/data-types/array#array-size), 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**
```sql theme={null}
notEmpty(arr)
```
**Argumentos**
* `arr` — Array de entrada. [`Array(T)`](/pt-BR/reference/data-types/array)
**Valor retornado**
Retorna `1` para um array não vazio ou `0` para um array vazio [`UInt8`](/pt-BR/reference/data-types/int-uint)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT notEmpty([1,2]);
```
```response title=Response theme={null}
1
```
## 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`](/pt-BR/reference/settings/session-settings#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**
```sql theme={null}
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)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT range(5), range(1, 5), range(1, 5, 2), range(-1, 5, 2);
```
```response title=Response theme={null}
┌─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**
```sql theme={null}
replicate(x, arr)
```
**Argumentos**
* `x` — O valor usado para preencher o array de resultado. [`Any`](/pt-BR/reference/data-types)
* `arr` — Um array. [`Array(T)`](/pt-BR/reference/data-types/array)
**Valor retornado**
Retorna um array com o mesmo tamanho de `arr`, preenchido com o valor `x`. [`Array(T)`](/pt-BR/reference/data-types/array)
**Exemplos**
**Exemplo de uso**
```sql title=Query theme={null}
SELECT replicate(1, ['a', 'b', 'c']);
```
```response title=Response theme={null}
┌─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**
```sql theme={null}
reverse(arr | str)
```
**Argumentos**
* `arr | str` — O array ou a string de entrada. [`Array(T)`](/pt-BR/reference/data-types/array) ou [`String`](/pt-BR/reference/data-types/string)
**Valor retornado**
Retorna um array ou uma string com a ordem dos elementos ou dos caracteres invertida.
**Exemplos**
**Inverter um array**
```sql title=Query theme={null}
SELECT reverse([1, 2, 3, 4]);
```
```response title=Response theme={null}
[4, 3, 2, 1]
```
**Inverter string**
```sql title=Query theme={null}
SELECT reverse('abcd');
```
```response title=Response theme={null}
'dcba'
```
## Funções de distância
Todas as funções suportadas estão descritas na [documentação sobre funções de distância](/pt-BR/reference/functions/regular-functions/distance-functions).