Агрегатные функции

Агрегатные функции — это функции, которые объединяют значения из нескольких строк в одно.

Агрегатные функции отличаются от скалярных функций и оконных функций тем, что они изменяют кардинальность результата. Поэтому в запросах их можно использовать только в выражениях SELECT и HAVING.

Выражение `DISTINCT` в агрегатных функциях

Когда используется выражение DISTINCT, при вычислении значения агрегатной функции учитываются только уникальные значения. Часто это выражение используется в сочетании с агрегатной функцией count() для получения количества уникальных элементов, но может использоваться и с другими агрегатными функциями.

Пример

CREATE TABLE cities(city_name VARCHAR);

INSERT INTO cities VALUES
    ('Moscow'),
    ('Moscow'),
    ('Paris'),
    ('Madrid');

SELECT
    count(DISTINCT city_name) AS distinct_cities_num,
    count(city_name) AS cities_num
FROM cities;

+---------------------+------------+
| distinct_cities_num | cities_num |
+---------------------+------------+
| 3                   | 4          |
+---------------------+------------+

Некоторые агрегатные функции нечувствительны к повторяющимся значениям (например, min() и max()), и для них выражение DISTINCT игнорируется.

`any_value()`

Описание	Возвращает первое значение из `argument`, отличное от `NULL`.
Использование	`any_value(argument)`

На результат работы этой функции влияет порядок сортировки в таблице.

Посмотреть пример

CREATE TABLE numbers(number_asc BIGINT, number_desc BIGINT);

INSERT INTO numbers VALUES
    (NULL,  3),
    (1,     2),
    (2,     1),
    (3,     NULL);

SELECT
    any_value(number_asc) AS "any value from number asc",
    any_value(number_desc) AS "any value from number desc"
FROM numbers;

+---------------------------+----------------------------+
| any value from number asc | any value from number desc |
+---------------------------+----------------------------+
| 1                         | 3                          |
+---------------------------+----------------------------+

`approx_count_distinct()`

Описание	Вычисляет приблизительное количество уникальных значений.
Использование	`approx_count_distinct(argument)`

Вычисляет приблизительное количество уникальных значений в колонке с помощью вероятностного алгоритма HyperLogLog.

Удобно использовать для быстрого подсчета количества уникальных значений. На больших таблицах работает быстрее, чем COUNT(DISTINCT).

Посмотреть пример

WITH test AS (
    SELECT
        (generate_series % 1000000) AS col1
    FROM generate_series(1, 100000000)
)
SELECT
    approx_count_distinct(col1) AS result
FROM test;

+--------+
| result |
+--------+
| 962761 |
+--------+

`approx_quantile()`

Описание	Вычисляет приблизительный квантиль.
Использование	`approx_quantile(argument)`

Вычисляет приблизительный квантиль числовых значений с помощью алгоритма T-Digest.

Посмотреть пример

WITH test AS (
    SELECT
        (generate_series % 500) + (generate_series % 10) AS col1
    FROM generate_series(1, 10000000)
)
SELECT
    approx_quantile(col1, 0.95) AS result
FROM test;

+--------+
| result |
+--------+
| 479    |
+--------+

`approx_top_k()`

Описание	Вычисляет приблизительный список из `k` наиболее часто встречающихся значений.
Использование	`approx_top_k(argument)`

Вычисляет приблизительный список из k наиболее часто встречающихся значений, используя метод Filtered Space-Saving.

Посмотреть пример

WITH test AS (
    SELECT
        CASE
            WHEN generate_series % 10 = 0 THEN 'A'
            WHEN generate_series % 5 = 0  THEN 'B'
            WHEN generate_series % 3 = 0  THEN 'C'
            ELSE 'D'
        END AS col1
    FROM generate_series(1, 10000000)
)
SELECT
    approx_top_k(col1, 3) AS result
FROM test;

+---------+
| result  |
+---------+
| {D,C,B} |
+---------+

`arg_max()`

Описание	Находит строку с максимальным значением одной колонки и возвращает значение другой колонки в этой строке.
Использование	`arg_max(argument1, argument2[, n])`
Псевдонимы	`argmax()`, `max_by()`

Находит строку с максимальным значением колонки argument2 и возвращает значение колонки argument1 в этой строке. Строки со значением NULL игнорируются.

Если задан третий аргумент, то возвращается список длины n значений колонки argument1, соответствующих найденному топ-n значений колонки argument2.

На результат работы этой функции влияет порядок сортировки в таблице.

Посмотреть примеры

CREATE TABLE demo (num BIGINT, letter VARCHAR);

INSERT INTO demo VALUES
    (1, 'A'),
    (2, 'B'),
    (3, 'C'),
    (3, NULL),
    (4, NULL);

SELECT
    arg_max(letter, num) AS result
FROM demo;

+--------+
| result |
+--------+
| C      |
+--------+

CREATE TABLE demo (num BIGINT, letter VARCHAR);

INSERT INTO demo VALUES
    (1, 'A'),
    (2, 'B'),
    (3, 'C'),
    (3, NULL),
    (4, NULL);

SELECT
    arg_max(letter, num, 2) AS result
FROM demo;

+--------+
| result |
+--------+
| {C,B}  |
+--------+

`arg_max_null()`

Описание	Находит строку с максимальным значением одной колонки и возвращает значение другой колонки в этой строке (даже если оно пустое).
Использование	`arg_max_null(argument1, argument2)`

Находит строку с максимальным значением колонки argument2 и возвращает значение колонки argument1 в этой строке. Если в колонке argument1 значение NULL, то возвращается оно.

На результат работы этой функции влияет порядок сортировки в таблице.

Посмотреть пример

CREATE TABLE demo (num BIGINT, letter VARCHAR);

INSERT INTO demo VALUES
    (1, 'A'),
    (2, 'B'),
    (3, 'C'),
    (3, NULL),
    (4, NULL);

SELECT
    arg_max_null(letter, num) AS result
FROM demo;

+--------+
| result |
+--------+
| null   |
+--------+

`arg_min()`

Описание	Находит строку с минимальным значением одной колонки и возвращает значение другой колонки в этой строке.
Использование	`arg_min(argument1, argument2[, n])`
Псевдонимы	`argmin()`, `min_by()`

Находит строку с минимальным значением колонки argument2 и возвращает значение колонки argument1 в этой строке. Строки со значением NULL игнорируются.

Если задан третий аргумент, то возвращается список длины n значений колонки argument1, соответствующих найденному топ-n значений колонки argument2, упорядоченных по возрастанию.

На результат работы этой функции влияет порядок сортировки в таблице.

Посмотреть примеры

CREATE TABLE demo (num BIGINT, letter VARCHAR);

INSERT INTO demo VALUES
    (0, NULL),
    (1, NULL),
    (1, 'A'),
    (2, 'B'),
    (3, 'C');

SELECT
    arg_min(letter, num) AS result
FROM demo;

+--------+
| result |
+--------+
| A      |
+--------+

CREATE TABLE demo (num BIGINT, letter VARCHAR);

INSERT INTO demo VALUES
    (0, NULL),
    (1, NULL),
    (1, 'A'),
    (2, 'B'),
    (3, 'C');

SELECT
    arg_min(letter, num, 2) AS result
FROM demo;

+--------+
| result |
+--------+
| {A,B}  |
+--------+

`arg_min_null()`

Описание	Находит строку с минимальным значением одной колонки и возвращает значение другой колонки в этой строке (даже если оно пустое).
Использование	`arg_min_null(argument1, argument2)`

Находит строку с минимальным значением колонки argument2 и возвращает значение колонки argument1 в этой строке. Если в колонке argument1 значение NULL, то возвращается оно.

На результат работы этой функции влияет порядок сортировки в таблице.

Посмотреть пример

CREATE TABLE demo (num BIGINT, letter VARCHAR);

INSERT INTO demo VALUES
    (0, NULL),
    (1, NULL),
    (1, 'A'),
    (2, 'B'),
    (3, 'C');

SELECT
    arg_min_null(letter, num) AS result
FROM demo;

+--------+
| result |
+--------+
| null   |
+--------+

`array_agg()`

Описание	Возвращает список, содержащий все значения колонки.
Использование	`array_agg(argument)`
Псевдонимы	`list()`

На результат работы этой функции влияет порядок сортировки в таблице.

Посмотреть пример

CREATE TABLE numbers(number BIGINT);

INSERT INTO numbers VALUES
    (1),
    (2),
    (3),
    (NULL);

SELECT
    array_agg(number) AS array_agg,
    list(number) AS list
FROM numbers;

+--------------+--------------+
|   array_agg  |     list     |
+--------------+--------------+
| {1,2,3,None} | {1,2,3,None} |
+--------------+--------------+

`avg()`

Описание	Вычисляет среднее значение всех непустых значений в группе.
Использование	`avg(argument)`
Псевдонимы	`mean()`

Посмотреть пример

CREATE TABLE numbers(number BIGINT);

INSERT INTO numbers VALUES
    (1),
    (2),
    (3),
    (NULL);

SELECT
    avg(number) AS average,
    mean(number) AS mean
FROM numbers;

+---------+------+
| average | mean |
+---------+------+
| 2       | 2    |
+---------+------+

`bit_and()`

Описание	Возвращает побитовое `И` для всех битов в группе.
Использование	`bit_and(argument)`

Посмотреть пример

CREATE TABLE numbers(number BIGINT);

INSERT INTO numbers VALUES
    (3),
    (5),
    (7),
    (NULL);

SELECT
    bit_and(number) AS result
FROM numbers;

+--------+
| result |
+--------+
| 1      |
+--------+

`bit_or()`

Описание	Возвращает побитовое `ИЛИ` для всех битов в группе.
Использование	`bit_or(argument)`

Посмотреть пример

CREATE TABLE numbers(number BIGINT);

INSERT INTO numbers VALUES
    (3),
    (5),
    (7),
    (NULL);

SELECT
    bit_or(number) AS result
FROM numbers;

+--------+
| result |
+--------+
| 7      |
+--------+

`bit_xor()`

Описание	Возвращает побитовое исключающее `ИЛИ` для всех битов в группе.
Использование	`bit_xor(argument)`

Посмотреть пример

CREATE TABLE numbers(number BIGINT);

INSERT INTO numbers VALUES
    (1),
    (1),
    (2),
    (2),
    (3),
    (NULL);

SELECT
    bit_xor(number) AS result
FROM numbers;

+--------+
| result |
+--------+
| 3      |
+--------+

`bitstring_agg()`

Описание	Возвращает битовую строку, длина которой соответствует диапазону ненулевых (целочисленных) значений.
Использование	`bitstring_agg(argument)`

Возвращает битовую строку, длина которой соответствует диапазону ненулевых (целочисленных) значений. При этом биты установлены в позиции каждого (уникального) значения.

Посмотреть пример

CREATE TABLE numbers(number BIGINT);

INSERT INTO numbers VALUES
    (1),
    (1),
    (2),
    (2),
    (3),
    (NULL);

SELECT
    bit_count(bitstring_agg(number)) AS result
FROM numbers;

+--------+
| result |
+--------+
| 3      |
+--------+

`bool_and()`

Описание	Возвращает `TRUE`, если все непустые значения группы истинны, иначе — `FALSE`.
Использование	`bool_and(argument)`

Посмотреть пример

CREATE TABLE demo(col1 BOOL, col2 BOOL, col3 BOOL);

INSERT INTO demo VALUES
    (true, true, true),
    (true, true, true),
    (false, true, true),
    (true, true, true),
    (NULL, true, NULL);

SELECT
    bool_and(col1) AS result_1,
    bool_and(col2) AS result_2,
    bool_and(col3) AS result_3,
FROM demo;

+----------+----------+----------+
| result_1 | result_2 | result_3 |
+----------+----------+----------+
| false    | true     | true     |
+----------+----------+----------+

`bool_or()`

Описание	Возвращает `TRUE`, если хотя бы одно значение в группе истинно, иначе — `FALSE`.
Использование	`bool_or(argument)`

Посмотреть пример

CREATE TABLE demo(col1 BOOL, col2 BOOL, col3 BOOL);

INSERT INTO demo VALUES
    (true, false, false),
    (true, false, false),
    (false, false, false),
    (true, false, false),
    (NULL, false, NULL);

SELECT
    bool_or(col1) AS result_1,
    bool_or(col2) AS result_2,
    bool_or(col3) AS result_3,
FROM demo;

+----------+----------+----------+
| result_1 | result_2 | result_3 |
+----------+----------+----------+
| true     | false    | false    |
+----------+----------+----------+

`count()`

Описание	Вычисляет количество строк в группе.
Использование	`count()`
Псевдонимы	`count(*)`

Посмотреть пример

CREATE TABLE numbers(number BIGINT);

INSERT INTO numbers VALUES
    (1),
    (2),
    (3),
    (NULL);

SELECT
    count() AS rows_count,
    count(*) AS rows_count_star
FROM numbers;

+------------+-----------------+
| rows_count | rows_count_star |
+------------+-----------------+
| 4          | 4               |
+------------+-----------------+

`count(argument)`

Описание	Вычисляет количество непустых значений в группе.
Использование	`count(argument)`

Посмотреть пример

CREATE TABLE numbers(number BIGINT);

INSERT INTO numbers VALUES
    (1),
    (2),
    (3),
    (NULL);

SELECT
    count() AS rows_count,
    count(number) AS values_count
FROM numbers;

+------------+--------------+
| rows_count | values_count |
+------------+--------------+
| 4          | 3            |
+------------+--------------+

`corr()`

Описание	Вычисляет коэффициент корреляции.
Использование	`corr(argument1, argument2)`
Формула	`covar_pop(y, x) / (stddev_pop(x) * stddev_pop(y))`

Посмотреть пример

CREATE TABLE numbers(number_1 BIGINT, number_2 BIGINT);

INSERT INTO numbers VALUES
    (1, 1),
    (2, 2),
    (3, 30),
    (NULL, NULL);

SELECT
    corr(number_1, number_2) AS result
FROM numbers;

+--------------------+
| result             |
+--------------------+
| 0.8808122718846411 |
+--------------------+

`covar_pop()`

Описание	Вычисляет ковариацию генеральной совокупности (не включает коррекцию смещения).
Использование	`covar_pop(argument1, argument2)`
Формула	`(sum(xy) - sum(x) sum(y) / regr_count(y, x)) / regr_count(y, x), covar_samp(y, x) * (1 - 1 / regr_count(y, x))`

Посмотреть пример

CREATE TABLE numbers(number_1 BIGINT, number_2 BIGINT);

INSERT INTO numbers VALUES
    (1, 1),
    (2, 2),
    (3, 30),
    (NULL, NULL);

SELECT
    covar_pop(number_1, number_2) AS result
FROM numbers;

+-------------------+
| result            |
+-------------------+
| 9.666666666666666 |
+-------------------+

`covar_samp()`

Описание	Вычисляет выборочную ковариацию, включающую поправку Бесселя на смещение.
Использование	`covar_samp(argument1, argument2)`
Формула	`(sum(xy) - sum(x) sum(y) / regr_count(y, x)) / (regr_count(y, x) - 1), covar_pop(y, x) / (1 - 1 / regr_count(y, x))`
Псевдонимы	`regr_sxy()`

Посмотреть пример

CREATE TABLE numbers(number_1 BIGINT, number_2 BIGINT);

INSERT INTO numbers VALUES
    (1, 1),
    (2, 2),
    (3, 30),
    (NULL, NULL);

SELECT
    covar_samp(number_1, number_2) AS result
FROM numbers;

+--------+
| result |
+--------+
| 14.5   |
+--------+

`count_if()`

Описание	Возвращает количество записей, удовлетворяющих условию, или `NULL`, если ни одна запись не удовлетворяет условию.
Использование	`count_if(<condition>)`
Псевдоним	`countif()`

Посмотреть пример

CREATE TABLE text_table(text_data VARCHAR);

INSERT INTO text_table VALUES
('Tengri'),
('Tengri'),
('TNGRi'),
(NULL);

SELECT
    COUNT_IF(TRUE) AS row_number,
    COUNT_IF(text_data = 'Tengri') AS tengri_number
FROM text_table;

+------------+---------------+
| row_number | tengri_number |
+------------+---------------+
| 4          | 2             |
+------------+---------------+

`entropy()`

Описание	Вычисляет логарифмическую энтропию по основанию 2.
Использование	`entropy(argument)`

Посмотреть пример

CREATE TABLE numbers(number_1 BIGINT, number_2 BIGINT);

INSERT INTO numbers VALUES
    (1, 1),
    (2, 2),
    (3, 2),
    (NULL, NULL);

SELECT
    entropy(number_1) AS result_1,
    entropy(number_2) AS result_2
FROM numbers;

+--------------------+--------------------+
| result_1           | result_2           |
+--------------------+--------------------+
| 1.5849625007211559 | 0.9182958340544893 |
+--------------------+--------------------+

`favg()`

Описание	Вычисляет среднее значение с помощью алгоритма Kahan Sum.
Использование	`favg(argument)`

Вычисляет среднее значение с помощью алгоритма Kahan Sum.

На результат работы этой функции влияет порядок сортировки в таблице.

Посмотреть пример

CREATE TABLE numbers(number BIGINT);

INSERT INTO numbers VALUES
    (1),
    (2),
    (3),
    (NULL);

SELECT
    favg(number) AS result
FROM numbers;

+--------+
| result |
+--------+
| 2      |
+--------+

`first()`

Описание	Возвращает первое значение из группы.
Использование	`first(argument)`
Псевдонимы	`arbitrary()`

Возвращает первое значение из группы.

На результат работы этой функции влияет порядок сортировки в таблице.

Посмотреть пример

CREATE TABLE weekdays (name VARCHAR, weekend BOOL);

INSERT INTO weekdays VALUES
('Monday', False),
('Tuesday', False),
('Wednesday', False),
('Thursday', False),
('Friday', False),
('Saturday', True),
('Sunday', True);

SELECT
    first(name) AS first_day,
    weekend
FROM weekdays
GROUP BY weekend;

+-----------+---------+
| first_day | weekend |
+-----------+---------+
| Monday    | false   |
+-----------+---------+
| Saturday  | true    |
+-----------+---------+

`fsum()`

Описание	Вычисляет сумму непустых значений в группе с помощью алгоритма Kahan Sum.
Использование	`fsum(argument)`
Псевдонимы	`sumkahan()`, `kahan_sum()`

Вычисляет сумму непустых значений в группе с помощью алгоритма Kahan Sum.

На результат работы этой функции влияет порядок сортировки в таблице.

Посмотреть пример

CREATE TABLE numbers(number BIGINT);

INSERT INTO numbers VALUES
    (1),
    (2),
    (3),
    (NULL);

SELECT
    fsum(number) AS result
FROM numbers;

+--------+
| result |
+--------+
| 6      |
+--------+

`geometric_mean()`

Описание	Вычисляет геометрическое среднее непустых значений в группе.
Использование	`geometric_mean(argument)`
Псевдонимы	`geomean()`

Вычисляет геометрическое среднее непустых значений в группе.

На результат работы этой функции влияет порядок сортировки в таблице.

Посмотреть пример

CREATE TABLE numbers(number BIGINT);

INSERT INTO numbers VALUES
    (1),
    (2),
    (3),
    (NULL);

SELECT
    geometric_mean(number) AS result
FROM numbers;

+--------------------+
| result             |
+--------------------+
| 1.8171205928321397 |
+--------------------+

`histogram()`

Описание	Возвращает словарь уникальных непустых значений в группе с количеством их вхождений.
Использование	`histogram(argument[, boundaries_list])`

Возвращает словарь уникальных непустых значений в группе с количеством их вхождений.

Если задан аргумент boundaries_list, то диапазон всех значений разбивается по границам, заданным в этом списке, и возвращается количество значений в каждом интервале.

Посмотреть примеры

CREATE TABLE numbers(number BIGINT);

INSERT INTO numbers VALUES
    (1),
    (1),
    (1),
    (2),
    (2),
    (3),
    (NULL);

SELECT
    histogram(number) AS result
FROM numbers;

+--------------------------------------------------------------------------+
| result                                                                   |
+--------------------------------------------------------------------------+
| [{"key": 1, "value": 3}, {"key": 2, "value": 2}, {"key": 3, "value": 1}] |
+--------------------------------------------------------------------------+

WITH numbers AS (
    SELECT unnest(generate_series(1, 10)) as number
    )
SELECT
    histogram(number, [1,5,10]) AS result
FROM numbers;

+---------------------------------------------------------------------------+
| result                                                                    |
+---------------------------------------------------------------------------+
| [{"key": 1, "value": 1}, {"key": 5, "value": 4}, {"key": 10, "value": 5}] |
+---------------------------------------------------------------------------+

`histogram_exact()`

Описание	Возвращает словарь указанных значений в группе с количеством их вхождений.
Использование	`histogram_exact(argument, elements_list)`

Возвращает словарь указанных в elements_list значений в группе с количеством их вхождений.

Все значения, которых нет в списке elements_list, попадают в отдельную группу значений.

Пустые значения игнорируются.

Посмотреть пример

CREATE TABLE numbers(number BIGINT);

INSERT INTO numbers VALUES
    (1),
    (1),
    (1),
    (2),
    (2),
    (3),
    (NULL);

SELECT
    histogram_exact(number, [2, 3]) AS result
FROM numbers;

+--------------------------------------------------------------------------------------------+
| result                                                                                     |
+--------------------------------------------------------------------------------------------+
| [{"key": 2, "value": 2}, {"key": 3, "value": 1}, {"key": 9223372036854775807, "value": 3}] |
+--------------------------------------------------------------------------------------------+

`kurtosis()`

Описание	Вычисляет эксцесс (по определению Фишера) с поправкой на смещение в зависимости от размера выборки.
Использование	`kurtosis(argument)`

Посмотреть пример

CREATE TABLE numbers(number_1 BIGINT, number_2 BIGINT);

INSERT INTO numbers VALUES
    (1, 1),
    (2, 2),
    (3, 3),
    (4, 400),
    (NULL, NULL);

SELECT
    kurtosis(number_1) AS result_1,
    kurtosis(number_2) AS result_2
FROM numbers;

+--------------------+--------------------+
| result_1           | result_2           |
+--------------------+--------------------+
| -1.200000000000001 | 3.9996633187929866 |
+--------------------+--------------------+

`kurtosis_pop()`

Описание	Вычисляет эксцесс (по определению Фишера) без поправки на смещение выборки.
Использование	`kurtosis_pop(argument)`

Посмотреть пример

CREATE TABLE numbers(number_1 BIGINT, number_2 BIGINT);

INSERT INTO numbers VALUES
    (1, 1),
    (2, 2),
    (3, 3),
    (4, 400),
    (NULL, NULL);

SELECT
    kurtosis_pop(number_1) AS result_1,
    kurtosis_pop(number_2) AS result_2
FROM numbers;

+----------+---------------------+
| result_1 | result_2            |
+----------+---------------------+
| -1.36    | -0.6667115574942684 |
+----------+---------------------+

`last()`

Описание	Возвращает последнее значение из группы.
Использование	`last(argument)`

Возвращает последнее значение из группы.

На результат работы этой функции влияет порядок сортировки в таблице.

Посмотреть пример

CREATE TABLE weekdays (name VARCHAR, weekend BOOL);

INSERT INTO weekdays VALUES
('Monday', False),
('Tuesday', False),
('Wednesday', False),
('Thursday', False),
('Friday', False),
('Saturday', True),
('Sunday', True);

SELECT
    last(name) AS last_day,
    weekend
FROM weekdays
GROUP BY weekend;

+----------+---------+
| last_day | weekend |
+----------+---------+
| Friday   | false   |
+----------+---------+
| Sunday   | true    |
+----------+---------+

`mad()`

Описание	Вычисляет медианное абсолютное отклонение.
Использование	`mad(argument)`
Формула	`median(abs(x - median(x)))`

Вычисляет медианное абсолютное отклонение. Типы даты и времени возвращают положительный интервал.

Посмотреть пример

CREATE TABLE numbers(number BIGINT);

INSERT INTO numbers VALUES
    (1),
    (2),
    (3),
    (4),
    (400),
    (NULL);

SELECT
    stddev_samp(number),
    mad(number)
FROM numbers;

+--------------------+-----+
| stddev_samp        | mad |
+--------------------+-----+
| 177.77092000661975 | 1   |
+--------------------+-----+

`max()`

Описание	Возвращает максимальное значение, имеющееся в группе.
Использование	`max(argument)`

Посмотреть пример

CREATE TABLE numbers(number BIGINT);

INSERT INTO numbers VALUES
    (1),
    (2),
    (3),
    (NULL);

SELECT
    max(number),
    min(number)
FROM numbers;

+-----+-----+
| max | min |
+-----+-----+
| 3   | 1   |
+-----+-----+

`min()`

Описание	Возвращает минимальное значение, имеющееся в группе.
Использование	`min(argument)`

Посмотреть пример

CREATE TABLE numbers(number BIGINT);

INSERT INTO numbers VALUES
    (1),
    (2),
    (3),
    (NULL);

SELECT
    max(number),
    min(number)
FROM numbers;

+-----+-----+
| max | min |
+-----+-----+
| 3   | 1   |
+-----+-----+

`median()`

Описание	Возвращает медианное значение всех непустых значений в группе.
Использование	`median(argument)`

В случае четного количества значений берется среднее между двумя центральными значениями.

Посмотреть пример

Покажем разницу между медианным значением и средним значением (avg()) на примерах наборов из четного (_even) и нечетного (_odd) количества чисел, содержащих в том числе пустые значения.

CREATE TABLE numbers(
    number_even BIGINT,
    number_odd BIGINT);

INSERT INTO numbers VALUES
    (1,    1),
    (2,    2),
    (3,    10),
    (10,   NULL),
    (NULL, NULL);

SELECT
    median(number_even) AS median_even,
    avg(number_even) AS avg_even,
    median(number_odd) AS median_odd,
    avg(number_odd) AS avg_odd
FROM numbers;

+-------------+----------+------------+-------------------+
| median_even | avg_even | median_odd |      avg_odd      |
+-------------+----------+------------+-------------------+
| 2.5         | 4        | 2          | 4.333333333333333 |
+-------------+----------+------------+-------------------+

`mode()`

Описание	Возвращает самое частотное значение в группе.
Использование	`mode(argument)`

На результат работы этой функции влияет порядок сортировки в таблице.

Посмотреть пример

CREATE TABLE numbers(number BIGINT);

INSERT INTO numbers VALUES
    (1),
    (2),
    (2),
    (3),
    (NULL);

SELECT
    mode(number) AS result,
FROM numbers;

+--------+
| result |
+--------+
| 2      |
+--------+

`product()`

Описание	Перемножает непустые значения в группе.
Использование	`product(argument)`

Посмотреть пример

CREATE TABLE numbers(number BIGINT);

INSERT INTO numbers VALUES
    (1),
    (2),
    (3),
    (NULL);

SELECT
    product(number) AS result,
FROM numbers;

+--------+
| result |
+--------+
| 6      |
+--------+

`quantile_cont()`

Описание	Вычисляет интерполированный положительный квантиль.
Использование	`quantile_cont(argument, pos)`

Посмотреть пример

CREATE TABLE numbers(number BIGINT);

INSERT INTO numbers VALUES
    (1),
    (2),
    (3),
    (4),
    (NULL);

SELECT
    quantile_cont(number, 0.5)               AS result_1,
    quantile_cont(number, [0.25, 0.5, 0.75]) AS result_2
FROM numbers;

+----------+-----------------+
| result_1 | result_2        |
+----------+-----------------+
| 2.5      | {1.75,2.5,3.25} |
+----------+-----------------+

`quantile_disc()`

Описание	Вычисляет дискретный положительный квантиль.
Использование	`quantile_disc(argument, pos)`

Посмотреть пример

CREATE TABLE numbers(number BIGINT);

INSERT INTO numbers VALUES
    (1),
    (2),
    (3),
    (4),
    (NULL);

SELECT
    quantile_disc(number, 0.5)               AS result_1,
    quantile_disc(number, [0.25, 0.5, 0.75]) AS result_2
FROM numbers;

+----------+----------+
| result_1 | result_2 |
+----------+----------+
| 2        | {1,2,3}  |
+----------+----------+

`reservoir_quantile()`

Описание	Вычисляет приблизительный квантиль с использованием резервуарного сплинтинга.
Использование	`reservoir_quantile(argument, quantile[, sample_size])`

Вычисляет приблизительный квантиль с использованием резервуарного сплинтинга.

В параметре sample_size можно задать размер выборки. По умолчанию используется значение 8192.

Посмотреть пример

WITH numbers AS (
    SELECT unnest(generate_series(1000000)) as number
    ORDER BY random()
)
SELECT
    reservoir_quantile(number, 0.5),
    quantile_cont(number, 0.5)
FROM numbers;

+--------------------+---------------+
| reservoir_quantile | quantile_cont |
+--------------------+---------------+
| 500201             | 500000        |
+--------------------+---------------+

`sem()`

Описание	Вычисляет стандартную ошибку среднего значения.
Использование	`sem(argument)`

Посмотреть пример

CREATE TABLE numbers(number BIGINT);

INSERT INTO numbers VALUES
    (1),
    (2),
    (3),
    (4),
    (NULL);

SELECT
    mean(number) AS sample_mean,
    sem(number) AS standard_error
FROM numbers;

+-------------+--------------------+
| sample_mean | standard_error     |
+-------------+--------------------+
| 2.5         | 0.5590169943749475 |
+-------------+--------------------+

`skewness()`

Описание	Вычисляет коэффициент асимметрии.
Использование	`skewness(argument)`

Посмотреть пример

CREATE TABLE numbers(number BIGINT);

INSERT INTO numbers VALUES
    (1),
    (2),
    (3),
    (40),
    (NULL);

SELECT
    skewness(number)
FROM numbers;

+-------------------+
| skewness          |
+-------------------+
| 1.988947740397821 |
+-------------------+

`stddev_pop()`

Описание	Вычисляет стандартное отклонение генеральной совокупности.
Использование	`stddev_pop(argument)`
Формула	`sqrt(var_pop(x))`

Посмотреть пример

CREATE TABLE numbers(number BIGINT);

INSERT INTO numbers VALUES
    (1),
    (2),
    (3),
    (4),
    (NULL);

SELECT
    stddev_pop(number),
    stddev_samp(number)
FROM numbers;

+-------------------+--------------------+
| stddev_pop        | stddev_samp        |
+-------------------+--------------------+
| 1.118033988749895 | 1.2909944487358056 |
+-------------------+--------------------+

`stddev_samp()`

Описание	Вычисляет выборочное стандартное отклонение.
Использование	`stddev_samp(argument)`
Формула	`sqrt(var_samp(x))`
Псевдонимы	`stddev()`

Посмотреть пример

CREATE TABLE numbers(number BIGINT);

INSERT INTO numbers VALUES
    (1),
    (2),
    (3),
    (4),
    (NULL);

SELECT
    stddev_pop(number),
    stddev_samp(number)
FROM numbers;

+-------------------+--------------------+
| stddev_pop        | stddev_samp        |
+-------------------+--------------------+
| 1.118033988749895 | 1.2909944487358056 |
+-------------------+--------------------+

`string_agg()`

Описание	Объединяет значения в одну текстовую строку через заданный разделитель.
Использование	`string_agg(argument, separator)`
Псевдонимы	`group_concat()`, `listagg()`

Если значения не являются текстовыми, то они приводятся к текстовым.

Посмотреть пример

CREATE TABLE weekdays (name VARCHAR, weekend BOOL);

INSERT INTO weekdays VALUES
('Monday', False),
('Tuesday', False),
('Wednesday', False),
('Thursday', False),
('Friday', False),
('Saturday', True),
('Sunday', True);

SELECT
    string_agg(name, ', ') AS week_days,
    weekend AS are_weekend
FROM weekdays
GROUP BY weekend;

+----------------------------------------------+-------------+
| week_days                                    | are_weekend |
+----------------------------------------------+-------------+
| Monday, Tuesday, Wednesday, Thursday, Friday | false       |
+----------------------------------------------+-------------+
| Saturday, Sunday                             | true        |
+----------------------------------------------+-------------+

`sum()`

Описание	Вычисляет сумму всех непустых значений в группе.
Использование	`sum(argument)`

В случае булевых значений вычисляет количество значений True.

Посмотреть пример

CREATE TABLE numbers(
    number BIGINT,
    boolean BOOL);

INSERT INTO numbers VALUES
    (1,    True),
    (2,    False),
    (3,    False),
    (NULL, NULL);

SELECT
    sum(number) AS sum_number,
    sum(boolean) AS sum_boolean
FROM numbers;

+------------+-------------+
| sum_number | sum_boolean |
+------------+-------------+
| 6          | 1           |
+------------+-------------+

`var_pop()`

Описание	Вычисляет дисперсию генеральной совокупности, не включающую коррекцию смещения.
Использование	`var_pop(argument)`
Формула	`(sum(x^2) - sum(x)^2 / count(x)) / count(x), var_samp(y, x) * (1 - 1 / count(x))`

Посмотреть пример

CREATE TABLE numbers(number BIGINT);

INSERT INTO numbers VALUES
    (1),
    (2),
    (3),
    (4),
    (NULL);

SELECT
    var_pop(number),
    var_samp(number)
FROM numbers;

+---------+--------------------+
| var_pop | var_samp           |
+---------+--------------------+
| 1.25    | 1.6666666666666667 |
+---------+--------------------+

`var_samp()`

Описание	Вычисляет выборочную дисперсию, включающую поправку Бесселя на смещение.
Использование	`var_samp(argument)`
Формула	`(sum(x^2) - sum(x)^2 / count(x)) / (count(x) - 1), var_pop(y, x) / (1 - 1 / count(x))`
Псевдонимы	`variance()`

Посмотреть пример

CREATE TABLE numbers(number BIGINT);

INSERT INTO numbers VALUES
    (1),
    (2),
    (3),
    (4),
    (NULL);

SELECT
    var_pop(number),
    var_samp(number)
FROM numbers;

+---------+--------------------+
| var_pop | var_samp           |
+---------+--------------------+
| 1.25    | 1.6666666666666667 |
+---------+--------------------+

`weighted_avg()`

Описание	Вычисляет среднее взвешенное всех непустых значений в группе.
Использование	`weighted_avg(argument, weight)`
Псевдонимы	`wavg()`

Посмотреть пример

CREATE TABLE numbers(number BIGINT, weight BIGINT);

INSERT INTO numbers VALUES
    (1, 1),
    (2, 2),
    (3, 3),
    (NULL, NULL);

SELECT
    avg(number),
    weighted_avg(number, weight)
FROM numbers;

+-----+--------------------+
| avg | weighted_avg       |
+-----+--------------------+
| 2   | 2.3333333333333335 |
+-----+--------------------+

Агрегатные функции

Выражение DISTINCT в агрегатных функциях

Пример

any_value()

approx_count_distinct()

approx_quantile()

approx_top_k()

arg_max()

arg_max_null()

arg_min()

arg_min_null()

array_agg()

avg()

bit_and()

bit_or()

bit_xor()

bitstring_agg()

bool_and()

bool_or()

count()

count(argument)

corr()

covar_pop()

covar_samp()

count_if()

entropy()

favg()

first()

fsum()

geometric_mean()

histogram()

histogram_exact()

kurtosis()

kurtosis_pop()

last()

mad()

max()

min()

median()

mode()

product()

quantile_cont()

quantile_disc()

reservoir_quantile()

sem()

skewness()

stddev_pop()

stddev_samp()

string_agg()

sum()

var_pop()

var_samp()

weighted_avg()

Выражение `DISTINCT` в агрегатных функциях

`any_value()`

`approx_count_distinct()`

`approx_quantile()`

`approx_top_k()`

`arg_max()`

`arg_max_null()`

`arg_min()`

`arg_min_null()`

`array_agg()`

`avg()`

`bit_and()`

`bit_or()`

`bit_xor()`

`bitstring_agg()`

`bool_and()`

`bool_or()`

`count()`

`count(argument)`

`corr()`

`covar_pop()`

`covar_samp()`

`count_if()`

`entropy()`

`favg()`

`first()`

`fsum()`

`geometric_mean()`

`histogram()`

`histogram_exact()`

`kurtosis()`

`kurtosis_pop()`

`last()`

`mad()`

`max()`

`min()`

`median()`

`mode()`

`product()`

`quantile_cont()`

`quantile_disc()`

`reservoir_quantile()`

`sem()`

`skewness()`

`stddev_pop()`

`stddev_samp()`

`string_agg()`

`sum()`

`var_pop()`

`var_samp()`

`weighted_avg()`