# Aggregate function

In database management, an aggregate function or aggregation function is a function where the values of multiple rows are grouped together to form a single summary value.
Common aggregate functions include:
Others include:
Formally, an aggregate function takes as input a set, a multiset, or a list from some input domain and outputs an element of an output domain. The input and output domains may be the same, such as for `SUM`, or may be different, such as for `COUNT`.
Aggregate functions occur commonly in numerous programming languages, in spreadsheets, and in relational algebra.
The `listagg` function, as defined in the standard
aggregates data from multiple rows into a single concatenated string.

## Decomposable aggregate functions

Aggregate functions present a bottleneck, because they potentially require having all input values at once. In distributed computing, it is desirable to divide such computations into smaller pieces, and distribute the work, usually computing in parallel, via a divide and conquer algorithm.
Some aggregate functions can be computed by computing the aggregate for subsets, and then aggregating these aggregates; examples include `COUNT, MAX, MIN,` and `SUM`. In other cases the aggregate can be computed by computing auxiliary numbers for subsets, aggregating these auxiliary numbers, and finally computing the overall number at the end; examples include `AVERAGE` and `RANGE`. In other cases the aggregate cannot be computed without analyzing the entire set at once, though in some cases approximations can be distributed; examples include `DISTINCT COUNT, MEDIAN,` and `MODE`.
Such functions are called decomposable aggregation functions or decomposable aggregate functions. The simplest may be referred to as self-decomposable aggregation functions, which are defined as those functions such that there is a merge operator such that
where is the union of multisets.
For example, `SUM`:
`COUNT`:
`MAX`:
`MIN`:
Note that self-decomposable aggregation functions can be combined by applying them separately, so for instance one can compute both the `SUM` and `COUNT` at the same time, by tracking two numbers.
More generally, one can define a decomposable aggregation function as one that can be expressed as the composition of a final function and a self-decomposable aggregation function,. For example, `AVERAGE`=`SUM`/`COUNT` and `RANGE`=`MAX``MIN`.
In the MapReduce framework, these steps are known as InitialReduce, Combine, and FinalReduce, and moving decomposable aggregation before the Shuffle phase is known as an InitialReduce step,
Decomposable aggregation functions are important in online analytical processing, as they allow aggregation queries to be computed on the pre-computed results in the OLAP cube, rather than on the base data. For example, it is easy to support `COUNT, MAX, MIN,` and `SUM` in OLAP, since these can be computed for each cell of the OLAP cube and then summarized, but it is difficult to support `MEDIAN`, as that must be computed for every view separately.

## Other Decomposable aggregate functions

In order to calculate the Average and Standard Deviation from aggregate data, it is necessary to have available for each group: the total of values, the number of values and the total of squares of the values of each groups.
`AVG`:
or
or, only if COUNT=COUNT
`SUM`:
The sum of squares of the values is important in order to calculate the Standard Deviation of groups
`STDDEV`:
For a finite population with equal probabilities at all points, we have
This means that the standard deviation is equal to the square root of the difference between the average of the squares of the values and the square of the average value.