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

> Página inicial das funções de agregação com a lista completa de funções

# Funções de agregação

O ClickHouse oferece suporte a todas as funções de agregação padrão do SQL ([sum](/pt-BR/reference/functions/aggregate-functions/sum), [avg](/pt-BR/reference/functions/aggregate-functions/avg), [min](/pt-BR/reference/functions/aggregate-functions/min), [max](/pt-BR/reference/functions/aggregate-functions/max), [count](/pt-BR/reference/functions/aggregate-functions/count)), além de uma ampla variedade de outras funções de agregação.

{/*AUTOGENERATED_START*/}

| Página                                                                                                                        | Descrição                                                                                                                                                                                                                                                                                                                                             |
| ----------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [aggThrow](/pt-BR/reference/functions/aggregate-functions/aggThrow)                                                           | Esta função pode ser usada para testar a segurança contra exceções. Ela lançará uma exceção durante a criação com a probabilidade especificada.                                                                                                                                                                                                       |
| [analysisOfVariance](/pt-BR/reference/functions/aggregate-functions/analysis_of_variance)                                     | Fornece um teste estatístico para análise de variância de um fator (teste ANOVA). É um teste aplicado a vários grupos de observações com distribuição normal para determinar se todos os grupos têm a mesma média ou não.                                                                                                                             |
| [any](/pt-BR/reference/functions/aggregate-functions/any)                                                                     | Seleciona o primeiro valor encontrado em uma coluna.                                                                                                                                                                                                                                                                                                  |
| [anyHeavy](/pt-BR/reference/functions/aggregate-functions/anyHeavy)                                                           | Seleciona um valor que ocorre com frequência usando o algoritmo heavy hitters. Se houver um valor que ocorra em mais da metade dos casos em cada uma das threads de execução da consulta, esse valor será retornado. Normalmente, o resultado não é determinístico.                                                                                   |
| [anyLast](/pt-BR/reference/functions/aggregate-functions/anyLast)                                                             | Seleciona o último valor encontrado em uma coluna.                                                                                                                                                                                                                                                                                                    |
| [approx\_top\_k](/pt-BR/reference/functions/aggregate-functions/approxtopk)                                                   | Retorna um array com os valores aproximadamente mais frequentes e suas contagens na coluna especificada.                                                                                                                                                                                                                                              |
| [approx\_top\_sum](/pt-BR/reference/functions/aggregate-functions/approxtopsum)                                               | Retorna um array com os valores aproximadamente mais frequentes e suas contagens na coluna especificada.                                                                                                                                                                                                                                              |
| [argAndMax](/pt-BR/reference/functions/aggregate-functions/argAndMax)                                                         | Calcula os valores de `arg` e `val` para um valor máximo de `val`. Se houver várias linhas com `val` igual ao máximo, não é determinístico qual dos `arg` e `val` associados será retornado.                                                                                                                                                          |
| [argAndMin](/pt-BR/reference/functions/aggregate-functions/argAndMin)                                                         | Calcula os valores de `arg` e `val` para um valor mínimo de `val`. Se houver várias linhas com `val` igual ao mínimo, não é determinístico qual dos `arg` e `val` associados será retornado.                                                                                                                                                          |
| [argMax](/pt-BR/reference/functions/aggregate-functions/argMax)                                                               | Calcula o valor de `arg` para um valor máximo de `val`.                                                                                                                                                                                                                                                                                               |
| [argMin](/pt-BR/reference/functions/aggregate-functions/argMin)                                                               | Calcula o valor de `arg` para um valor mínimo de `val`. Se houver várias linhas com `val` igual ao máximo, não é determinístico qual dos `arg` associados será retornado.                                                                                                                                                                             |
| [avg](/pt-BR/reference/functions/aggregate-functions/avg)                                                                     | Calcula a média aritmética.                                                                                                                                                                                                                                                                                                                           |
| [avgWeighted](/pt-BR/reference/functions/aggregate-functions/avgWeighted)                                                     | Calcula a média aritmética ponderada.                                                                                                                                                                                                                                                                                                                 |
| [boundingRatio](/pt-BR/reference/functions/aggregate-functions/boundrat)                                                      | Função agregada que calcula a inclinação entre os pontos mais à esquerda e mais à direita de um grupo de valores.                                                                                                                                                                                                                                     |
| [categoricalInformationValue](/pt-BR/reference/functions/aggregate-functions/categoricalInformationValue)                     | Calcula o valor de `(P(tag = 1) - P(tag = 0))(log(P(tag = 1)) - log(P(tag = 0)))` para cada categoria.                                                                                                                                                                                                                                                |
| [contingency](/pt-BR/reference/functions/aggregate-functions/contingency)                                                     | A função `contingency` calcula o coeficiente de contingência, um valor que mede a associação entre duas colunas em uma tabela. O cálculo é semelhante ao da função `cramersV`, mas com um denominador diferente na raiz quadrada.                                                                                                                     |
| [corr](/pt-BR/reference/functions/aggregate-functions/corr)                                                                   | Calcula o coeficiente de correlação de Pearson.                                                                                                                                                                                                                                                                                                       |
| [corrMatrix](/pt-BR/reference/functions/aggregate-functions/corrMatrix)                                                       | Calcula a matriz de correlação para N variáveis.                                                                                                                                                                                                                                                                                                      |
| [corrStable](/pt-BR/reference/functions/aggregate-functions/corrStable)                                                       | Calcula o coeficiente de correlação de Pearson, mas usa um algoritmo numericamente estável.                                                                                                                                                                                                                                                           |
| [count](/pt-BR/reference/functions/aggregate-functions/count)                                                                 | Conta o número de linhas ou de valores não NULL.                                                                                                                                                                                                                                                                                                      |
| [covarPop](/pt-BR/reference/functions/aggregate-functions/covarPop)                                                           | Calcula a covariância populacional                                                                                                                                                                                                                                                                                                                    |
| [covarPopMatrix](/pt-BR/reference/functions/aggregate-functions/covarPopMatrix)                                               | Retorna a matriz de covariância populacional para N variáveis.                                                                                                                                                                                                                                                                                        |
| [covarPopStable](/pt-BR/reference/functions/aggregate-functions/covarPopStable)                                               | Calcula o valor da covariância populacional                                                                                                                                                                                                                                                                                                           |
| [covarSamp](/pt-BR/reference/functions/aggregate-functions/covarSamp)                                                         | Calcula o valor de `Σ((x - x̅)(y - y̅)) / (n - 1)`                                                                                                                                                                                                                                                                                                    |
| [covarSampMatrix](/pt-BR/reference/functions/aggregate-functions/covarSampMatrix)                                             | Retorna a matriz de covariância amostral para N variáveis.                                                                                                                                                                                                                                                                                            |
| [covarSampStable](/pt-BR/reference/functions/aggregate-functions/covarSampStable)                                             | Semelhante a covarSamp, mas é mais lenta e fornece um erro computacional menor.                                                                                                                                                                                                                                                                       |
| [cramersV](/pt-BR/reference/functions/aggregate-functions/cramersV)                                                           | O resultado da função `cramersV` varia de 0 (correspondente à ausência de associação entre as variáveis) a 1, e só pode atingir 1 quando cada valor é completamente determinado pelo outro. Ele pode ser visto como a associação entre duas variáveis expressa como uma porcentagem de sua variação máxima possível.                                  |
| [cramersVBiasCorrected](/pt-BR/reference/functions/aggregate-functions/cramersVBiasCorrected)                                 | Calcula o V de Cramer, mas usa correção de viés.                                                                                                                                                                                                                                                                                                      |
| [deltaSum](/pt-BR/reference/functions/aggregate-functions/deltaSum)                                                           | Soma a diferença aritmética entre linhas consecutivas.                                                                                                                                                                                                                                                                                                |
| [deltaSumTimestamp](/pt-BR/reference/functions/aggregate-functions/deltaSumTimestamp)                                         | Soma a diferença entre linhas consecutivas. Se a diferença for negativa, ela será ignorada.                                                                                                                                                                                                                                                           |
| [distinctDynamicTypes](/pt-BR/reference/functions/aggregate-functions/distinctDynamicTypes)                                   | Calcula a lista de tipos de dados distintos armazenados em uma coluna Dynamic.                                                                                                                                                                                                                                                                        |
| [distinctJSONPaths](/pt-BR/reference/functions/aggregate-functions/distinctJSONPaths)                                         | Calcula uma lista de caminhos distintos armazenados em uma coluna JSON.                                                                                                                                                                                                                                                                               |
| [distinctJSONPathsAndTypes](/pt-BR/reference/functions/aggregate-functions/distinctJSONPathsAndTypes)                         | Calcula a lista de caminhos distintos e seus tipos armazenados em JSON                                                                                                                                                                                                                                                                                |
| [entropy](/pt-BR/reference/functions/aggregate-functions/entropy)                                                             | Calcula a entropia de Shannon de uma coluna de valores.                                                                                                                                                                                                                                                                                               |
| [estimateCompressionRatio](/pt-BR/reference/functions/aggregate-functions/estimateCompressionRatio)                           | Estima a taxa de compressão de uma determinada coluna sem compactá-la.                                                                                                                                                                                                                                                                                |
| [exponentialMovingAverage](/pt-BR/reference/functions/aggregate-functions/exponentialMovingAverage)                           | Calcula a média móvel exponencial dos valores para um determinado tempo.                                                                                                                                                                                                                                                                              |
| [exponentialTimeDecayedAvg](/pt-BR/reference/functions/aggregate-functions/exponentialTimeDecayedAvg)                         | Retorna a média móvel ponderada com suavização exponencial dos valores de uma série temporal no instante `t`.                                                                                                                                                                                                                                         |
| [exponentialTimeDecayedCount](/pt-BR/reference/functions/aggregate-functions/exponentialTimeDecayedCount)                     | Retorna o decaimento exponencial cumulativo de uma série temporal no índice temporal `t`.                                                                                                                                                                                                                                                             |
| [exponentialTimeDecayedMax](/pt-BR/reference/functions/aggregate-functions/exponentialTimeDecayedMax)                         | Retorna o máximo entre a média móvel com suavização exponencial calculada no índice temporal `t` e a de `t-1`.                                                                                                                                                                                                                                        |
| [exponentialTimeDecayedSum](/pt-BR/reference/functions/aggregate-functions/exponentialTimeDecayedSum)                         | Retorna a soma dos valores da média móvel com suavização exponencial de uma série temporal no índice temporal `t`.                                                                                                                                                                                                                                    |
| [first\_value](/pt-BR/reference/functions/aggregate-functions/first_value)                                                    | É um alias de any, mas foi introduzido para compatibilidade com funções de janela, nas quais às vezes é necessário processar valores `NULL` (por padrão, todas as aggregate functions do ClickHouse ignoram valores `NULL`).                                                                                                                          |
| [flameGraph](/pt-BR/reference/functions/aggregate-functions/flame_graph)                                                      | Função agregada que cria um flamegraph usando uma lista de stacktraces.                                                                                                                                                                                                                                                                               |
| [groupArray](/pt-BR/reference/functions/aggregate-functions/groupArray)                                                       | Cria um array de valores de argumento. Os valores podem ser adicionados ao array em qualquer ordem (indeterminada).                                                                                                                                                                                                                                   |
| [groupArrayArray](/pt-BR/reference/functions/aggregate-functions/groupArrayArray)                                             | Agrega arrays em um array maior contendo esses arrays.                                                                                                                                                                                                                                                                                                |
| [groupArrayInsertAt](/pt-BR/reference/functions/aggregate-functions/groupArrayInsertAt)                                       | Insere um valor no array na posição especificada.                                                                                                                                                                                                                                                                                                     |
| [groupArrayIntersect](/pt-BR/reference/functions/aggregate-functions/groupArrayIntersect)                                     | Retorna a interseção dos arrays fornecidos (retorna todos os itens que estão presentes em todos os arrays fornecidos).                                                                                                                                                                                                                                |
| [groupArrayLast](/pt-BR/reference/functions/aggregate-functions/groupArrayLast)                                               | Cria um array com os últimos valores de argumento.                                                                                                                                                                                                                                                                                                    |
| [groupArrayMovingAvg](/pt-BR/reference/functions/aggregate-functions/groupArrayMovingAvg)                                     | Calcula a média móvel dos valores de entrada.                                                                                                                                                                                                                                                                                                         |
| [groupArrayMovingSum](/pt-BR/reference/functions/aggregate-functions/groupArrayMovingSum)                                     | Calcula a soma móvel dos valores de entrada.                                                                                                                                                                                                                                                                                                          |
| [groupArraySample](/pt-BR/reference/functions/aggregate-functions/groupArraySample)                                           | Cria um array com valores de argumento de amostra. O tamanho do array resultante é limitado a `max_size` elementos. Os valores de argumento são selecionados e adicionados ao array aleatoriamente.                                                                                                                                                   |
| [groupArraySorted](/pt-BR/reference/functions/aggregate-functions/groupArraySorted)                                           | Retorna um array com os primeiros N itens em ordem crescente.                                                                                                                                                                                                                                                                                         |
| [groupBitAnd](/pt-BR/reference/functions/aggregate-functions/groupBitAnd)                                                     | Aplica `AND` bit a bit a uma série de números.                                                                                                                                                                                                                                                                                                        |
| [groupBitmap](/pt-BR/reference/functions/aggregate-functions/groupBitmap)                                                     | Realiza cálculos de bitmap ou Aggregate a partir de uma coluna de inteiros sem sinal e retorna a cardinalidade do tipo UInt64; se o sufixo -State for adicionado, retorna um objeto bitmap                                                                                                                                                            |
| [groupBitmapAnd](/pt-BR/reference/functions/aggregate-functions/groupBitmapAnd)                                               | Calcula o AND de uma coluna bitmap e retorna a cardinalidade do tipo UInt64; se o sufixo -State for adicionado, retorna um objeto bitmap.                                                                                                                                                                                                             |
| [groupBitmapOr](/pt-BR/reference/functions/aggregate-functions/groupBitmapOr)                                                 | Calcula o OR de uma coluna bitmap e retorna a cardinalidade do tipo UInt64; se o sufixo -State for adicionado, retorna um objeto bitmap. Isso é equivalente a `groupBitmapMerge`.                                                                                                                                                                     |
| [groupBitmapXor](/pt-BR/reference/functions/aggregate-functions/groupBitmapXor)                                               | Calcula o XOR de uma coluna bitmap e retorna a cardinalidade do tipo UInt64; se usado com o sufixo -State, retorna um objeto bitmap                                                                                                                                                                                                                   |
| [groupBitOr](/pt-BR/reference/functions/aggregate-functions/groupBitOr)                                                       | Aplica `OR` bit a bit a uma série de números.                                                                                                                                                                                                                                                                                                         |
| [groupBitXor](/pt-BR/reference/functions/aggregate-functions/groupBitXor)                                                     | Aplica `XOR` bit a bit a uma série de números.                                                                                                                                                                                                                                                                                                        |
| [groupConcat](/pt-BR/reference/functions/aggregate-functions/groupConcat)                                                     | Calcula uma string concatenada a partir de um grupo de strings, opcionalmente separadas por um delimitador e opcionalmente limitadas a um número máximo de elementos.                                                                                                                                                                                 |
| [groupUniqArray](/pt-BR/reference/functions/aggregate-functions/groupUniqArray)                                               | Cria um array a partir de valores de argumento distintos.                                                                                                                                                                                                                                                                                             |
| [intervalLengthSum](/pt-BR/reference/functions/aggregate-functions/intervalLengthSum)                                         | Calcula o comprimento total da união de todos os intervalos (segmentos no eixo numérico).                                                                                                                                                                                                                                                             |
| [kolmogorovSmirnovTest](/pt-BR/reference/functions/aggregate-functions/kolmogorovSmirnovTest)                                 | Aplica o teste de Kolmogorov-Smirnov a amostras de duas populações.                                                                                                                                                                                                                                                                                   |
| [kurtPop](/pt-BR/reference/functions/aggregate-functions/kurtPop)                                                             | Calcula a curtose de uma sequência.                                                                                                                                                                                                                                                                                                                   |
| [kurtSamp](/pt-BR/reference/functions/aggregate-functions/kurtSamp)                                                           | Calcula a curtose amostral de uma sequência.                                                                                                                                                                                                                                                                                                          |
| [largestTriangleThreeBuckets](/pt-BR/reference/functions/aggregate-functions/largestTriangleThreeBuckets)                     | Aplica o algoritmo Largest-Triangle-Three-Buckets aos dados de entrada.                                                                                                                                                                                                                                                                               |
| [last\_value](/pt-BR/reference/functions/aggregate-functions/last_value)                                                      | Seleciona o último valor encontrado, semelhante a `anyLast`, mas pode aceitar NULL.                                                                                                                                                                                                                                                                   |
| [mannWhitneyUTest](/pt-BR/reference/functions/aggregate-functions/mannWhitneyUTest)                                           | Aplica o teste de postos de Mann-Whitney a amostras de duas populações.                                                                                                                                                                                                                                                                               |
| [max](/pt-BR/reference/functions/aggregate-functions/max)                                                                     | Função de agregação que calcula o valor máximo em um grupo de valores.                                                                                                                                                                                                                                                                                |
| [maxIntersections](/pt-BR/reference/functions/aggregate-functions/maxIntersections)                                           | Função de agregação que calcula o número máximo de vezes que um grupo de intervalos se cruza (se todos os intervalos se cruzarem pelo menos uma vez).                                                                                                                                                                                                 |
| [maxIntersectionsPosition](/pt-BR/reference/functions/aggregate-functions/maxIntersectionsPosition)                           | Função de agregação que calcula as posições das ocorrências da função maxIntersections.                                                                                                                                                                                                                                                               |
| [maxMap](/pt-BR/reference/functions/aggregate-functions/maxMap)                                                               | Calcula o máximo do array `value` de acordo com as chaves especificadas no array `key`.                                                                                                                                                                                                                                                               |
| [meanZTest](/pt-BR/reference/functions/aggregate-functions/meanZTest)                                                         | Aplica o teste z para médias a amostras de duas populações.                                                                                                                                                                                                                                                                                           |
| [median](/pt-BR/reference/functions/aggregate-functions/median)                                                               | As funções `median*` são aliases das funções `quantile*` correspondentes. Elas calculam a mediana de uma amostra de dados numéricos.                                                                                                                                                                                                                  |
| [min](/pt-BR/reference/functions/aggregate-functions/min)                                                                     | Função de agregação que calcula o valor mínimo em um grupo de valores.                                                                                                                                                                                                                                                                                |
| [minMap](/pt-BR/reference/functions/aggregate-functions/minMap)                                                               | Calcula o mínimo do array `value` de acordo com as chaves especificadas no array `key`.                                                                                                                                                                                                                                                               |
| [quantile](/pt-BR/reference/functions/aggregate-functions/quantile)                                                           | Calcula um quantil aproximado de uma sequência de dados numéricos.                                                                                                                                                                                                                                                                                    |
| [quantileBFloat16](/pt-BR/reference/functions/aggregate-functions/quantileBFloat16)                                           | Calcula um quantil aproximado de uma amostra composta por números bfloat16.                                                                                                                                                                                                                                                                           |
| [quantileDD](/pt-BR/reference/functions/aggregate-functions/quantileddsketch)                                                 | Calcula um quantil aproximado de uma amostra com garantias de erro relativo.                                                                                                                                                                                                                                                                          |
| [quantileDeterministic](/pt-BR/reference/functions/aggregate-functions/quantileDeterministic)                                 | Calcula um quantil aproximado de uma sequência de dados numéricos.                                                                                                                                                                                                                                                                                    |
| [quantileExact Functions](/pt-BR/reference/functions/aggregate-functions/quantileExact)                                       | funções quantileExact, quantileExactLow, quantileExactHigh, quantileExactExclusive, quantileExactInclusive                                                                                                                                                                                                                                            |
| [quantileExactExclusive](/pt-BR/reference/functions/aggregate-functions/quantileExactExclusive)                               | Calcula exatamente o quantil de uma sequência de dados numéricos.                                                                                                                                                                                                                                                                                     |
| [quantileExactHigh](/pt-BR/reference/functions/aggregate-functions/quantileExactHigh)                                         | Semelhante a quantileExact, calcula exatamente o quantil de uma sequência de dados numéricos.                                                                                                                                                                                                                                                         |
| [quantileExactInclusive](/pt-BR/reference/functions/aggregate-functions/quantileExactInclusive)                               | Calcula exatamente o quantil de uma sequência de dados numéricos.                                                                                                                                                                                                                                                                                     |
| [quantileExactLow](/pt-BR/reference/functions/aggregate-functions/quantileExactLow)                                           | Semelhante a quantileExact, calcula exatamente o [quantile](https://en.wikipedia.org/wiki/Quantile) de uma sequência de dados numéricos.                                                                                                                                                                                                              |
| [quantileExactWeighted](/pt-BR/reference/functions/aggregate-functions/quantileExactWeighted)                                 | Calcula exatamente o quantil de uma sequência de dados numéricos, levando em conta o peso de cada elemento.                                                                                                                                                                                                                                           |
| [quantileExactWeightedInterpolated](/pt-BR/reference/functions/aggregate-functions/quantileExactWeightedInterpolated)         | Calcula o quantil de uma sequência de dados numéricos usando interpolação linear, levando em conta o peso de cada elemento.                                                                                                                                                                                                                           |
| [quantileGK](/pt-BR/reference/functions/aggregate-functions/quantileGK)                                                       | Calcula o quantil de uma sequência de dados numéricos usando o algoritmo Greenwald-Khanna.                                                                                                                                                                                                                                                            |
| [quantileInterpolatedWeighted](/pt-BR/reference/functions/aggregate-functions/quantileInterpolatedWeighted)                   | Calcula o quantil de uma sequência de dados numéricos usando interpolação linear, levando em conta o peso de cada elemento.                                                                                                                                                                                                                           |
| [quantilePrometheusHistogram](/pt-BR/reference/functions/aggregate-functions/quantilePrometheusHistogram)                     | Calcula o quantil de um histograma usando interpolação linear.                                                                                                                                                                                                                                                                                        |
| [quantiles Functions](/pt-BR/reference/functions/aggregate-functions/quantiles)                                               | quantiles, quantilesExactExclusive, quantilesExactInclusive, quantilesGK                                                                                                                                                                                                                                                                              |
| [quantilesExactExclusive](/pt-BR/reference/functions/aggregate-functions/quantilesExactExclusive)                             | Calcula exatamente os quantis de uma sequência numérica de dados.                                                                                                                                                                                                                                                                                     |
| [quantilesExactInclusive](/pt-BR/reference/functions/aggregate-functions/quantilesExactInclusive)                             | Calcula exatamente os quantis de uma sequência numérica de dados.                                                                                                                                                                                                                                                                                     |
| [quantilesGK](/pt-BR/reference/functions/aggregate-functions/quantilesGK)                                                     | quantilesGK funciona de forma semelhante a quantileGK, mas permite calcular quantis em diferentes níveis simultaneamente e retorna um array.                                                                                                                                                                                                          |
| [quantilesTimingWeighted](/pt-BR/reference/functions/aggregate-functions/quantilesTimingWeighted)                             | Com a precisão determinada, calcula o quantil de uma sequência numérica de dados de acordo com o peso de cada elemento da sequência.                                                                                                                                                                                                                  |
| [quantileTDigest](/pt-BR/reference/functions/aggregate-functions/quantileTDigest)                                             | Calcula um quantil aproximado de uma sequência numérica de dados usando o algoritmo t-digest.                                                                                                                                                                                                                                                         |
| [quantileTDigestWeighted](/pt-BR/reference/functions/aggregate-functions/quantileTDigestWeighted)                             | Calcula um quantil aproximado de uma sequência numérica de dados usando o algoritmo t-digest.                                                                                                                                                                                                                                                         |
| [quantileTiming](/pt-BR/reference/functions/aggregate-functions/quantileTiming)                                               | Com a precisão determinada, calcula o quantil de uma sequência numérica de dados.                                                                                                                                                                                                                                                                     |
| [quantileTimingWeighted](/pt-BR/reference/functions/aggregate-functions/quantileTimingWeighted)                               | Com a precisão determinada, calcula o quantil de uma sequência numérica de dados de acordo com o peso de cada elemento da sequência.                                                                                                                                                                                                                  |
| [rankCorr](/pt-BR/reference/functions/aggregate-functions/rankCorr)                                                           | Calcula um coeficiente de correlação de postos.                                                                                                                                                                                                                                                                                                       |
| [simpleLinearRegression](/pt-BR/reference/functions/aggregate-functions/simpleLinearRegression)                               | Executa regressão linear simples (unidimensional).                                                                                                                                                                                                                                                                                                    |
| [singleValueOrNull](/pt-BR/reference/functions/aggregate-functions/singleValueOrNull)                                         | A função de agregação `singleValueOrNull` é usada para implementar operadores de subconsulta, como `x = ALL (SELECT ...)`. Ela verifica se há apenas um único valor distinto não `NULL` nos dados.                                                                                                                                                    |
| [skewPop](/pt-BR/reference/functions/aggregate-functions/skewPop)                                                             | Calcula a assimetria de uma sequência.                                                                                                                                                                                                                                                                                                                |
| [skewSamp](/pt-BR/reference/functions/aggregate-functions/skewSamp)                                                           | Calcula a assimetria amostral de uma sequência.                                                                                                                                                                                                                                                                                                       |
| [sparkbar](/pt-BR/reference/functions/aggregate-functions/sparkbar)                                                           | A função gera um histograma de frequência para os valores `x` e a taxa de repetição `y` desses valores no intervalo `[min_x, max_x]`.                                                                                                                                                                                                                 |
| [stddevPop](/pt-BR/reference/functions/aggregate-functions/stddevPop)                                                         | O resultado é igual à raiz quadrada de varPop.                                                                                                                                                                                                                                                                                                        |
| [stddevPopStable](/pt-BR/reference/functions/aggregate-functions/stddevPopStable)                                             | O resultado é igual à raiz quadrada de varPop. Diferentemente de stddevPop, esta função usa um algoritmo numericamente estável.                                                                                                                                                                                                                       |
| [stddevSamp](/pt-BR/reference/functions/aggregate-functions/stddevSamp)                                                       | O resultado é igual à raiz quadrada de varSamp.                                                                                                                                                                                                                                                                                                       |
| [stddevSampStable](/pt-BR/reference/functions/aggregate-functions/stddevSampStable)                                           | O resultado é igual à raiz quadrada de varSamp. Diferentemente de stddevSamp, esta função usa um algoritmo numericamente estável.                                                                                                                                                                                                                     |
| [stochasticLinearRegression](/pt-BR/reference/functions/aggregate-functions/stochasticLinearRegression)                       | Esta função implementa regressão linear estocástica. Ela oferece suporte a parâmetros personalizados para taxa de aprendizado, coeficiente de regularização L2, tamanho de mini-batch e alguns métodos de atualização de pesos (Adam, SGD simples, Momentum, Nesterov).                                                                               |
| [stochasticLogisticRegression](/pt-BR/reference/functions/aggregate-functions/stochasticLogisticRegression)                   | Esta função implementa regressão logística estocástica. Ela pode ser usada para problemas de classificação binária, oferece suporte aos mesmos parâmetros personalizados que stochasticLinearRegression e funciona da mesma forma.                                                                                                                    |
| [studentTTest](/pt-BR/reference/functions/aggregate-functions/studentTTest)                                                   | Aplica o teste t de Student a amostras de duas populações.                                                                                                                                                                                                                                                                                            |
| [studentTTestOneSample](/pt-BR/reference/functions/aggregate-functions/studentTTestOneSample)                                 | Aplica o teste t de Student de uma amostra a uma amostra e a uma média populacional conhecida.                                                                                                                                                                                                                                                        |
| [sum](/pt-BR/reference/functions/aggregate-functions/sum)                                                                     | Calcula a soma. Funciona apenas para números.                                                                                                                                                                                                                                                                                                         |
| [sumCount](/pt-BR/reference/functions/aggregate-functions/sumCount)                                                           | Calcula a soma dos números e conta o número de linhas ao mesmo tempo. A função é usada pelo otimizador de consultas do ClickHouse: se houver várias funções `sum`, `count` ou `avg` em uma consulta, elas podem ser substituídas por uma única função `sumCount` para reutilizar os cálculos. Raramente é necessário usar essa função explicitamente. |
| [sumKahan](/pt-BR/reference/functions/aggregate-functions/sumKahan)                                                           | Calcula a soma dos números com o algoritmo de soma compensada de Kahan.                                                                                                                                                                                                                                                                               |
| [sumMap](/pt-BR/reference/functions/aggregate-functions/sumMap)                                                               | Totaliza um ou mais arrays `value` de acordo com as chaves especificadas no array `key`. Retorna uma tupla de arrays: chaves em ordem classificada, seguidas pelos valores somados para as chaves correspondentes sem overflow.                                                                                                                       |
| [sumMapWithOverflow](/pt-BR/reference/functions/aggregate-functions/sumMapWithOverflow)                                       | Totaliza um array `value` de acordo com as chaves especificadas no array `key`. Retorna uma tupla de dois arrays: chaves em ordem classificada e valores somados para as chaves correspondentes. Difere da função sumMap por fazer a soma com overflow.                                                                                               |
| [sumWithOverflow](/pt-BR/reference/functions/aggregate-functions/sumWithOverflow)                                             | Calcula a soma dos números, usando o mesmo tipo de dado para o resultado e para os parâmetros de entrada. Se a soma exceder o valor máximo desse tipo de dado, ela será calculada com overflow.                                                                                                                                                       |
| [theilsU](/pt-BR/reference/functions/aggregate-functions/theilsU)                                                             | A função `theilsU` calcula o coeficiente de incerteza U de Theil, um valor que mede a associação entre duas colunas em uma tabela.                                                                                                                                                                                                                    |
| [timeSeriesChangesToGrid](/pt-BR/reference/functions/aggregate-functions/timeSeriesChangesToGrid)                             | Função de agregação que calcula mudanças no estilo PromQL ao longo de dados de séries temporais na grade especificada.                                                                                                                                                                                                                                |
| [timeSeriesDeltaToGrid](/pt-BR/reference/functions/aggregate-functions/timeSeriesDeltaToGrid)                                 | Função de agregação que calcula o delta no estilo PromQL sobre dados de séries temporais na grade especificada.                                                                                                                                                                                                                                       |
| [timeSeriesDerivToGrid](/pt-BR/reference/functions/aggregate-functions/timeSeriesDerivToGrid)                                 | Função de agregação que calcula a derivada no estilo PromQL sobre dados de séries temporais na grade especificada.                                                                                                                                                                                                                                    |
| [timeSeriesGroupArray](/pt-BR/reference/functions/aggregate-functions/timeSeriesGroupArray)                                   | Ordena séries temporais por timestamp em ordem crescente.                                                                                                                                                                                                                                                                                             |
| [timeSeriesInstantDeltaToGrid](/pt-BR/reference/functions/aggregate-functions/timeSeriesInstantDeltaToGrid)                   | Função de agregação que calcula o idelta no estilo PromQL sobre dados de séries temporais na grade especificada.                                                                                                                                                                                                                                      |
| [timeSeriesInstantRateToGrid](/pt-BR/reference/functions/aggregate-functions/timeSeriesInstantRateToGrid)                     | Função de agregação que calcula o irate no estilo PromQL sobre dados de séries temporais na grade especificada.                                                                                                                                                                                                                                       |
| [timeSeriesLastTwoSamples](/pt-BR/reference/functions/aggregate-functions/timeSeriesLastTwoSamples)                           | Função de agregação para reamostrar dados de séries temporais para o cálculo de irate e idelta no estilo PromQL                                                                                                                                                                                                                                       |
| [timeSeriesPredictLinearToGrid](/pt-BR/reference/functions/aggregate-functions/timeSeriesPredictLinearToGrid)                 | Função de agregação que calcula a predição linear no estilo PromQL sobre dados de séries temporais na grade especificada.                                                                                                                                                                                                                             |
| [timeSeriesRateToGrid](/pt-BR/reference/functions/aggregate-functions/timeSeriesRateToGrid)                                   | Função de agregação que calcula o rate no estilo PromQL sobre dados de séries temporais na grade especificada.                                                                                                                                                                                                                                        |
| [timeSeriesResampleToGridWithStaleness](/pt-BR/reference/functions/aggregate-functions/timeSeriesResampleToGridWithStaleness) | Função de agregação que reamostra dados de séries temporais para a grade especificada.                                                                                                                                                                                                                                                                |
| [timeSeriesResetsToGrid](/pt-BR/reference/functions/aggregate-functions/timeSeriesResetsToGrid)                               | Função de agregação que calcula resets no estilo PromQL sobre dados de séries temporais na grade especificada.                                                                                                                                                                                                                                        |
| [topK](/pt-BR/reference/functions/aggregate-functions/topK)                                                                   | Retorna um array com os valores aproximadamente mais frequentes na coluna especificada. O array resultante é ordenado em ordem decrescente da frequência aproximada dos valores (não pelos próprios valores).                                                                                                                                         |
| [topKWeighted](/pt-BR/reference/functions/aggregate-functions/topKWeighted)                                                   | Retorna um array com os valores aproximadamente mais frequentes na coluna especificada. O array resultante é ordenado em ordem decrescente da frequência aproximada dos valores (não pelos próprios valores). Além disso, o peso do valor é levado em conta.                                                                                          |
| [uniq](/pt-BR/reference/functions/aggregate-functions/uniq)                                                                   | Calcula o número aproximado de valores distintos do argumento.                                                                                                                                                                                                                                                                                        |
| [uniqCombined](/pt-BR/reference/functions/aggregate-functions/uniqCombined)                                                   | Calcula o número aproximado de valores distintos do argumento.                                                                                                                                                                                                                                                                                        |
| [uniqCombined64](/pt-BR/reference/functions/aggregate-functions/uniqCombined64)                                               | Calcula o número aproximado de valores distintos do argumento. É igual a uniqCombined, mas usa um hash de 64 bits para todos os tipos de dados, em vez de apenas para o tipo de dado String.                                                                                                                                                          |
| [uniqExact](/pt-BR/reference/functions/aggregate-functions/uniqExact)                                                         | Calcula o número exato de valores distintos do argumento.                                                                                                                                                                                                                                                                                             |
| [uniqHLL12](/pt-BR/reference/functions/aggregate-functions/uniqHLL12)                                                         | Calcula o número aproximado de valores distintos do argumento usando o algoritmo HyperLogLog.                                                                                                                                                                                                                                                         |
| [uniqTheta](/pt-BR/reference/functions/aggregate-functions/uniqthetasketch)                                                   | Calcula o número aproximado de valores distintos do argumento usando o Theta Sketch Framework.                                                                                                                                                                                                                                                        |
| [varPop](/pt-BR/reference/functions/aggregate-functions/varPop)                                                               | Calcula a variância populacional.                                                                                                                                                                                                                                                                                                                     |
| [varPopStable](/pt-BR/reference/functions/aggregate-functions/varPopStable)                                                   | Retorna a variância populacional. Ao contrário de varPop, esta função usa um algoritmo numericamente estável. Ela funciona mais lentamente, mas fornece um erro computacional menor.                                                                                                                                                                  |
| [varSamp](/pt-BR/reference/functions/aggregate-functions/varSamp)                                                             | Calcula a variância amostral de um conjunto de dados.                                                                                                                                                                                                                                                                                                 |
| [varSampStable](/pt-BR/reference/functions/aggregate-functions/varSampStable)                                                 | Calcula a variância amostral de um conjunto de dados. Ao contrário de `varSamp`, esta função usa um algoritmo numericamente estável. Ela funciona mais lentamente, mas fornece um erro computacional menor.                                                                                                                                           |
| [welchTTest](/pt-BR/reference/functions/aggregate-functions/welchTTest)                                                       | Aplica o teste t de Welch a amostras de duas populações.                                                                                                                                                                                                                                                                                              |
