聚合函数--ByteHouse云数仓版-火山引擎

文档中心

ByteHouse云数仓版

函数参考

聚合函数

any

选择第一个遇到的值。
查询可以按任意顺序执行，甚至每次都按不同的顺序执行，因此此函数的结果不确定。
要获得确定的结果，您可以使用“min”或“max”函数代替“any”。
在某些情况下，您可以依赖执行顺序。这适用于 SELECT 来自使用 ORDER BY 的子查询的情况。
当SELECT查询包含GROUP BY子句或至少一个聚合函数时，ByteHouse（与 MySQL 相反）要求、和子句中的所有表达式都从SELECT键或聚合函数计算得出。换句话说，从表中选择的每个列都必须在键或聚合函数中使用。要获得与 MySQL 类似的行为，您可以将其他列放在聚合函数中。
语法

any(column)

参数

column– 列名称。

返回值

遇到的第一个值。类型与输入列相同。

示例

SELECT any(number) FROM numbers(10);

┌─any(number)─┐
│ 0           │
└─────────────┘

anyHeavy

heavy hitters算法选择一个频繁出现的值。如果查询的每个执行线程中有一个值在超过一半的情况下出现，则返回该值。通常，结果是不确定的。
语法

anyHeavy(column)

参数

column– 列名称。

返回值

最常见的值。类型与输入列相同。

示例

CREATE TABLE IF NOT EXISTS test.functionAnyHeavy(id Int) ENGINE=CnchMergeTree() ORDER BY id;
INSERT INTO test.functionAnyHeavy values (1),(1),(1),(2),(3);
SELECT anyHeavy(id) FROM test.functionAnyHeavy;

┌─anyHeavy(id)─┐
│ 1            │
└──────────────┘

anyLast

选择遇到的最后一个值。
结果同样不确定。
语法

anyLast(column)
sql

参数

column– 列名称。

返回值

遇到的最后一个值。类型与输入列相同。

示例

SELECT anyLast(number) FROM numbers(10);

┌─anyLast(number)─┐
│ 9               │
└─────────────────┘

argMax

计算arg最大值的值。如果的最大值val有多个不同的值，则返回遇到的第一个值。argval
语法

argMax(arg, val)
sql

参数

arg争论。
val价值。

返回值

与最大 val 值对应的 arg 值。类型与 arg 类型相同。

示例

CREATE TABLE IF NOT EXISTS test.functionArgMax (user String, salary Int) Engine=CnchMergeTree() ORDER BY user;
INSERT INTO test.functionArgMax VALUES ('director',5000),('manager',3000),('worker',1000);
SELECT argMax(user, salary) FROM test.functionArgMax;

┌─argMax(user, salary)─┐
│ director             │
└──────────────────────┘

argMin

计算arg最小值的值。如果的最小值val有多个不同的值，则返回遇到的第一个值。argval
语法

argMin(arg, val)

参数

arg争论。
val价值。

返回值

与最小 val 值对应的 arg 值。类型与 arg 类型相同。

示例

CREATE TABLE IF NOT EXISTS test.functionArgMin (user String, salary Int) Engine=CnchMergeTree() ORDER BY user;
INSERT INTO test.functionArgMin VALUES ('director',5000),('manager',3000),('worker',1000);
SELECT argMin(user, salary) FROM test.functionArgMin;

┌─argMin(user, salary)─┐
│ worker               │
└──────────────────────┘

avg

计算算术平均值。
语法

avg(x)

参数

x— 输入值，必须是整数、浮点数或十进制。

返回值

算术平均值，始终为 Float64。
NaN如果输入参数x为空。

示例

CREATE TABLE IF NOT EXISTS test.functionAvg (x Int8) ENGINE=CnchMergeTree() ORDER BY x;
INSERT INTO test.functionAvg SELECT * FROM numbers(6);
SELECT avg(x) FROM test.functionAvg;

┌─avg(x)──┐
│ 2.5e+00 │
└─────────┘

CREATE TABLE IF NOT EXISTS test.functionAvg (x Int8) ENGINE=CnchMergeTree() ORDER BY x;
SELECT avg(x) FROM test.functionAvg;

┌─avg(x)─┐
│ NaN    │
└────────┘

corr

计算皮尔逊相关系数：Σ((x - x̅)(y - y̅)) / sqrt(Σ((x - x̅)^2) * Σ((y - y̅)^2))。
此函数使用数值不稳定算法。如果您需要计算中的数值稳定性corrStable，请使用该函数。它运行速度较慢，但计算误差较低。
语法

corr(x, y)

参数

x— 输入值，必须是整数、浮点数。
y— 输入值，必须是整数、浮点数。

返回值

皮尔逊相关系数，始终为 Float64。

示例

CREATE TABLE IF NOT EXISTS test.functionCorr (x Int8, y Int8) ENGINE=CnchMergeTree() ORDER BY x;
INSERT INTO test.functionCorr VALUES (1,5),(2,4),(3,3),(4,2),(5,1);
SELECT corr(x,y) FROM test.functionCorr;

┌─corr(x, y)─┐
│ -1e+00     │
└────────────┘

covarPop

计算的值Σ((x - x̅)(y - y̅)) / n。
此函数使用数值不稳定算法。如果您需要计算中的数值稳定性covarPopStable，请使用该函数。它运行速度较慢，但计算误差较低。
语法

covarPop(x, y)

参数

x— 输入值，必须是整数、浮点数。
y— 输入值，必须是整数、浮点数。

返回值

Σ((x - x̅)(y - y̅)) / n，始终为 Float64。

示例

CREATE TABLE IF NOT EXISTS test.functionCovarPop (x Int8, y Int8) ENGINE=CnchMergeTree() ORDER BY x;
INSERT INTO test.functionCovarPop VALUES (1,5),(2,4),(3,3),(4,2),(5,1);
SELECT covarPop(x,y) FROM test.functionCovarPop;

┌─covarPop(x, y)─┐
│ -2e+00         │
└────────────────┘

covarSamp

计算的值Σ((x - x̅)(y - y̅)) / (n - 1)。
此函数使用数值不稳定算法。如果您需要计算中的数值稳定性covarSampStable，请使用该函数。它运行速度较慢，但计算误差较低。
语法

covarSamp(x, y)

参数

x— 输入值，必须是整数、浮点数。
y— 输入值，必须是整数、浮点数。

返回值

Σ((x - x̅)(y - y̅)) / (n - 1)，始终为 Float64。
当 n <= 1 时，返回 NaN。

示例

CREATE TABLE IF NOT EXISTS test.functionCovarSamp (x Int8, y Int8) ENGINE=CnchMergeTree() ORDER BY x;
INSERT INTO test.functionCovarSamp VALUES (1,5),(2,4),(3,3),(4,2),(5,1);
SELECT covarSamp(x,y) FROM test.functionCovarSamp;

┌─covarSamp(x, y)─┐
│ -2.5e+00        │
└─────────────────┘

CREATE TABLE IF NOT EXISTS test.functionCovarSamp (x Int8, y Int8) ENGINE=CnchMergeTree() ORDER BY x;
INSERT INTO test.functionCovarSamp VALUES (1,5);
SELECT covarSamp(x,y) FROM test.functionCovarSamp;

┌─covarSamp(x, y)─┐
│ NaN             │
└─────────────────┘

groupArray

创建参数值数组。
可以按任意（不确定）顺序将值添加到数组中。
第二个版本（带有max_size参数）将结果数组的大小限制为max_size元素。例如，groupArray(1)(x)相当于[any (x)]。
在某些情况下，您仍然可以依赖执行顺序。这适用于SELECT来自使用的子查询的情况ORDER BY。
语法

groupArray(x)
groupArray(max_size)(x)

参数

x— 输入值。

返回值

值数组。类型为数组。

示例

select groupArray(number) from numbers(10);

┌─groupArray(number)─────────────┐
│ [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] │
└────────────────────────────────┘

select groupArray(5)(number) from numbers(10);

┌─groupArray(5)(number)─┐
│ [0, 1, 2, 3, 4]       │
└───────────────────────┘

groupBitAnd

AND对一系列数字按位应用。
语法

groupBitAnd(expr)

参数

expr– 产生类型的表达式UInt*。

返回值

类型的值UInt*。

示例

CREATE TABLE IF NOT EXISTS test.groupBitAnd (num UInt8) ENGINE=CnchMergeTree() ORDER BY num;
INSERT INTO test.groupBitAnd VALUES (44),(28),(13),(85);
SELECT groupBitAnd(num) FROM test.groupBitAnd;

┌─groupBitAnd(num)─┐
│ 4                │
└──────────────────┘

44、28、13、85的位表示形式分别为00101100、00011100、00001101、01010101，四个数的位和为00000100，等于4。

groupBitOr

OR对一系列数字按位应用。
语法

groupBitOr(expr)

参数

expr– 产生类型的表达式UInt*。

返回值

类型的值UInt*。

示例

CREATE TABLE IF NOT EXISTS test.functionGroupBitOr (num UInt8) ENGINE=CnchMergeTree ORDER BY num;
INSERT INTO test.functionGroupBitOr VALUES (44),(28),(13),(85);
SELECT groupBitOr(num) FROM test.functionGroupBitOr;

┌─groupBitOr(num)─┐
│ 125             │
└─────────────────┘

44、28、13、85的位表示形式分别为00101100、00011100、00001101和01010101，这四个数的位或为01111101，等于125。

groupBitXor

XOR对一系列数字按位应用。
语法

groupBitXor(expr)

参数

expr– 产生类型的表达式UInt*。

返回值

类型的值UInt*。

示例

CREATE TABLE IF NOT EXISTS test.functionGroupBitXor (num UInt8) ENGINE=CnchMergeTree ORDER BY num;
INSERT INTO test.functionGroupBitXor VALUES (44),(28),(13),(85);
SELECT groupBitXor(num) FROM test.functionGroupBitXor;

┌─groupBitXor(num)─┐
│ 104              │
└──────────────────┘

44、28、13、85 的位表示形式分别为 00101100、00011100、00001101 和 01010101。这四个数的位异或结果为 01101000，等于 104。

groupBitmap

从无符号整数列进行位图或聚合计算，返回 UInt64 类型的基数，如果添加后缀 -State，则返回位图对象。
语法

groupBitmap(expr)

参数

expr– 产生类型的表达式UInt*。

返回值

类型的值UInt64。

示例

SELECT groupBitmap(number) FROM numbers(4);

┌─groupBitmap(number)─┐
│ 4                   │
└─────────────────────┘

groupBitmapAnd

计算位图列的AND，返回UInt64类型的基数，如果添加后缀-State，则返回位图对象。
语法

groupBitmapAnd(expr)

参数

expr– 产生类型的表达式AggregateFunction(groupBitmap, UInt*)。

返回值

类型的值UInt64。

示例

DROP TABLE IF EXISTS bitmap_column_expr_test2;

CREATE TABLE bitmap_column_expr_test2(tag_id String,z AggregateFunction(groupBitmap, UInt32)) ENGINE = CnchMergeTree ORDER BY tag_id;

INSERT INTO bitmap_column_expr_test2 VALUES ('tag1', bitmapBuild(cast([1,2,3,4,5,6,7,8,9,10] as Array(UInt32))));
INSERT INTO bitmap_column_expr_test2 VALUES ('tag2', bitmapBuild(cast([6,7,8,9,10,11,12,13,14,15] as Array(UInt32))));
INSERT INTO bitmap_column_expr_test2 VALUES ('tag3', bitmapBuild(cast([2,4,6,8,10,12] as Array(UInt32))));

SELECT groupBitmapAnd(z) FROM bitmap_column_expr_test2 WHERE like(tag_id, 'tag%');
┌─groupBitmapAnd(z)─┐
│               3   │
└───────────────────┘

SELECT arraySort(bitmapToArray(groupBitmapAndState(z))) FROM bitmap_column_expr_test2 WHERE like(tag_id, 'tag%');
┌─arraySort(bitmapToArray(groupBitmapAndState(z)))─┐
│ [6,8,10]                                         │
└──────────────────────────────────────────────────┘

groupBitmapOr

计算位图列的或，返回 UInt64 类型的基数，如果添加后缀 -State，则返回位图对象。这相当于groupBitmapMerge。
语法

groupBitmapOr(expr)

参数

expr– 产生类型的表达式AggregateFunction(groupBitmap, UInt*)。

返回值

类型的值UInt64。

示例

DROP TABLE IF EXISTS bitmap_column_expr_test2;
CREATE TABLE bitmap_column_expr_test2(tag_id String,z AggregateFunction(groupBitmap, UInt32)) ENGINE = CnchMergeTree ORDER BY tag_id;

INSERT INTO bitmap_column_expr_test2 VALUES ('tag1', bitmapBuild(cast([1,2,3,4,5,6,7,8,9,10] as Array(UInt32))));
INSERT INTO bitmap_column_expr_test2 VALUES ('tag2', bitmapBuild(cast([6,7,8,9,10,11,12,13,14,15] as Array(UInt32))));
INSERT INTO bitmap_column_expr_test2 VALUES ('tag3', bitmapBuild(cast([2,4,6,8,10,12] as Array(UInt32))));

SELECT groupBitmapOr(z) FROM bitmap_column_expr_test2 WHERE like(tag_id, 'tag%');
┌─groupBitmapOr(z)─┐
│             15   │
└──────────────────┘

SELECT arraySort(bitmapToArray(groupBitmapOrState(z))) FROM bitmap_column_expr_test2 WHERE like(tag_id, 'tag%');
┌─arraySort(bitmapToArray(groupBitmapOrState(z)))─┐
│ [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]           │
└─────────────────────────────────────────────────┘

groupBitmapXor

计算位图列的异或，返回 UInt64 类型的基数，如果添加后缀 -State，则返回位图对象。
语法

groupBitmapOr(expr)

参数

expr– 产生类型的表达式AggregateFunction(groupBitmap, UInt*)。

返回值

类型的值UInt64。

示例

DROP TABLE IF EXISTS bitmap_column_expr_test2;
CREATE TABLE bitmap_column_expr_test2(tag_id String, z AggregateFunction(groupBitmap, UInt32)) ENGINE = CnchMergeTree ORDER BY tag_id;

INSERT INTO bitmap_column_expr_test2 VALUES ('tag1', bitmapBuild(cast([1,2,3,4,5,6,7,8,9,10] as Array(UInt32))));
INSERT INTO bitmap_column_expr_test2 VALUES ('tag2', bitmapBuild(cast([6,7,8,9,10,11,12,13,14,15] as Array(UInt32))));
INSERT INTO bitmap_column_expr_test2 VALUES ('tag3', bitmapBuild(cast([2,4,6,8,10,12] as Array(UInt32))));

SELECT groupBitmapXor(z) FROM bitmap_column_expr_test2 WHERE like(tag_id, 'tag%');
┌─groupBitmapXor(z)─┐
│              10   │
└───────────────────┘

SELECT arraySort(bitmapToArray(groupBitmapXorState(z))) FROM bitmap_column_expr_test2 WHERE like(tag_id, 'tag%');
┌─arraySort(bitmapToArray(groupBitmapXorState(z)))─┐
│ [1,3,5,6,8,10,11,13,14,15]                       │
└──────────────────────────────────────────────────┘

groupConcat

从一组字符串中计算拼接后字符串，可选用分隔符分隔，并可限制包含的最大元素数量。
语法

groupConcat[(delimiter [, limit])](expression);

别名: group_concat
参数

expression — 输出要拼接字符串的表达式或列名。
delimiter — 用于分隔拼接后值的字符串。此参数是可选的，如果未指定，则默认为“,”号。

参数列表

delimiter — 用于分隔拼接后值的字符串。此参数是可选的，如果未指定，则默认为“,”号。
limit — 指定要拼接的元素最大数量的正整数。如果存在更多元素，则多余元素将被忽略。此参数是可选的。

注意

如果只指定了 delimiter 而未指定 limit，则 delimiter 必须是第一个参数。如果同时指定了 delimiter 和 limit，则 delimiter 必须在 limit 之前。
另外，如果在参数（Arguments）和参数列表（Parameters）中指定了不同的分隔符，则仅使用参数（Arguments）中的分隔符。

返回值

返回一个字符串，由该列或表达式的值拼接而成。如果分组中没有元素或只有 null 元素，并且函数未指定仅 null 值的处理方式，则结果为具有 null 值的 Nullable 字符串。

示例
输入表：

create database if not exists test;
create table if not exists test.employees (id UInt64, name String) engine=CnchMergeTree order by id;
insert into test.employees values(1, 'Joe'), (2, 'Jane'), (3, 'Doe');

基本用法：

SELECT groupConcat(name) FROM test.employees;

┌─groupConcat(name)─┐
│ Joe, Jane, Doe    │
└───────────────────┘

使用逗号作为分隔符：

SELECT groupConcat(', ')(name) FROM test.employees;

┌─groupConcat(', ')(name)─┐
│ Joe, Jane, Doe          │
└─────────────────────────┘

限制拼接元素的数量

SELECT groupConcat(', ', 2)(name) FROM test.employees;

┌─groupConcat(', ', 2)(name)─┐
│ Joe, Jane                  │
└────────────────────────────┘

groupUniqArray

根据不同的参数值创建一个数组。内存消耗与 uniqExact 函数相同。
第二个版本（带有max_size参数）将结果数组的大小限制为max_size元素。
语法

groupUniqArray(x)
groupUniqArray(max_size)(x)

参数

x— 输入值。

返回值

值数组。类型为数组。

示例

select groupUniqArray(number) from numbers(10);

┌─groupUniqArray(number)─────────┐
│ [0, 8, 3, 9, 7, 2, 1, 6, 4, 5] │
└────────────────────────────────┘

select groupUniqArray(5)(number) from numbers(10);

┌─groupArray(5)(number)─┐
│ [0, 1, 2, 3, 4]       │
└───────────────────────┘

histogram

计算自适应直方图。它不保证结果精确。
该函数使用流式并行决策树算法。当新数据进入函数时，直方图箱的边界会进行调整。通常情况下，箱的宽度不相等。
语法

histogram(number_of_bins)(values)

参数

number_of_bins— 直方图中 bin 数量的上限。该函数会自动计算 bin 数量。它会尝试达到指定的 bin 数量，但如果失败，则会使用较少的 bin。
values— 产生输入值的表达式。

返回值

以下格式的元组数组：
[(lower_1, upper_1, height_1), ... (lower_N, upper_N, height_N)]

lower
— Lower bound of the bin.
upper
— Upper bound of the bin.
height — Calculated height of the bin.
示例

SELECT histogram(5)(number + 1) FROM numbers(20);

┌─histogram(5)(plus(number, 1))───────────────────────────────────────────┐
│ [(1,4.5,4),(4.5,8.5,4),(8.5,12.75,4.125),(12.75,17,4.625),(17,20,3.25)] │
└─────────────────────────────────────────────────────────────────────────┘

您可以使用 bar 函数可视化直方图，例如：

WITH histogram(5)(rand() % 100) AS hist
SELECT
    arrayJoin(hist).3 AS height,
    bar(height, 0, 6, 5) AS bar
FROM numbers(20);

┌─height─┬─bar───┐
│  2.125 │ █▋    │
│   3.25 │ ██▌   │
│  5.625 │ ████▏ │
│  5.625 │ ████▏ │
│  3.375 │ ██▌   │
└────────┴───────┘

在这种情况下，您应该记住您不知道直方图箱边界。

max

计算一组值的最大值的聚合函数。
语法

max(values)

参数

values— 输入值。

返回值

最大值。类型与值相同

示例

SELECT max(number) FROM numbers(20);

┌─max(number)─┐
│ 19          │
└─────────────┘

如果需要非聚合函数来选择最多两个值，请参见greatest：

SELECT greatest(a, b) FROM table;

median

这些median*函数是相应函数的别名quantile*。它们计算数值数据样本的中位数。
功能：

median— 分位数的别名。
medianDeterministic— quantileDeterministic 的别名。
medianExact— quantileExact 的别名。
medianExactWeighted— quantileExactWeighted 的别名。
medianTiming— quantileTiming 的别名。
medianTimingWeighted— quantileTimingWeighted 的别名。
medianTDigest— quantileTDigest 的别名。
medianTDigestWeighted— quantileTDigestWeighted 的别名。
medianBFloat16— quantileBFloat16 的别名。

medianDeterministic

quantileDeterministic 的别名。

medianExact

quantileExact 的别名。

medianExactWeighted

quantileExactWeighted 的别名。

medianTDigest

quantileTDigest 的别名。

medianTDigestWeighted

quantileTDigestWeighted 的别名。

medianTiming

quantileTiming 的别名。

medianTimingWeighted

quantileTimingWeighted 的别名。

quantile

计算数值数据序列的近似分位数。
此函数应用水库采样，水库大小最大为 8192，并使用随机数生成器进行采样。结果不确定。要获得精确的分位数，请使用 quantileExact 函数。
在查询中使用具有不同级别的多个函数时quantile*，内部状态不会合并（即查询的效率低于应有的水平）。在这种情况下，请使用分位数函数。
语法

quantile(level)(expr)

别名：median。
参数

level— 分位数级别。可选参数。0 到 1 之间的常量浮点数。我们建议使用level范围内的值[0.01, 0.99]。默认值：0.5。level=0.5函数计算中位数。
expr— 对列值进行表达式，得出数字、日期或日期时间。

返回值

指定级别的近似分位数。

类型：

Float64 用于数字数据类型输入。
如果输入值具有该Date类型，则为日期。
如果输入值具有该DateTime类型，则为 DateTime。

示例

SELECT quantile(number) FROM numbers(10);

┌─quantile(number)─┐
│ 4.5e+00          │
└──────────────────┘

quantileDeterministic

计算数值数据序列的近似分位数。
此函数应用水库采样，水库大小最高可达 8192，采样算法具有确定性。结果是确定性的。要获得精确的分位数，请使用 quantileExact 函数。
在查询中使用具有不同级别的多个函数时quantile*，内部状态不会合并（即查询的效率低于应有的水平）。在这种情况下，请使用分位数函数。
语法

quantileDeterministic(level)(expr, determinator)
sql

别名：medianDeterministic。
参数

level— 分位数级别。可选参数。0 到 1 之间的常量浮点数。我们建议使用level范围内的值[0.01, 0.99]。默认值：0.5。level=0.5函数计算中位数。
expr— 对列值进行表达式，得出数字数据类型，即日期或日期时间。
determinator— 在水库采样算法中使用哈希值代替随机数生成器来确保采样结果具有确定性的数字。作为确定器，您可以使用任何确定性正数，例如用户 ID 或事件 ID。如果相同的确定器值出现得太频繁，则该函数无法正常工作。

返回值

指定级别的近似分位数。

类型：

Float64 用于数字数据类型输入。
如果输入值具有该Date类型，则为日期。
如果输入值具有该DateTime类型，则为 DateTime。

示例

SELECT quantileDeterministic(number, 1) FROM numbers(10);
sql

┌─quantileDeterministic(number, 1)─┐
│ 4.5e+00                          │
└──────────────────────────────────┘
纯文本

quantileExact

精确计算数值数据序列的分位数。
为了获得精确值，所有传递的值都会组合成一个数组，然后对其进行部分排序。因此，该函数会消耗O(n)内存，其中n是传递的值的数量。但是，对于少量值，该函数非常有效。
在查询中使用具有不同级别的多个函数时quantile*，内部状态不会合并（即查询的效率低于应有的水平）。在这种情况下，请使用分位数函数。
语法

quantileExact(level)(expr)

别名：medianExact。
参数

level— 分位数级别。可选参数。0 到 1 之间的常量浮点数。我们建议使用level范围内的值[0.01, 0.99]。默认值：0.5。level=0.5函数计算中位数。
expr— 对列值进行表达式，得出数字数据类型，即日期或日期时间。

返回值

指定级别的分位数。

类型：

Float64 用于数字数据类型输入。
如果输入值具有该Date类型，则为日期。
如果输入值具有该DateTime类型，则为 DateTime。

示例

SELECT quantileExact(number) FROM numbers(10);

┌─quantileExact(number)─┐
│                     5 │
└───────────────────────┘

quantileExactWeighted

精确计算数值数据序列的分位数，同时考虑每个元素的权重。
为了获得精确值，所有传递的值都会组合成一个数组，然后对其进行部分排序。每个值都用其权重进行计数，就像它是当前值一样weight。算法中使用了哈希表。因此，如果传递的值经常重复，则该函数比 quantileExact 消耗的 RAM 更少。您可以使用此函数代替quantileExact并指定权重 1。
在查询中使用具有不同级别的多个函数时quantile*，内部状态不会合并（即查询的效率低于应有的水平）。在这种情况下，请使用分位数函数。
语法

quantileExactWeighted(level)(expr, weight)

别名：medianExactWeighted。
参数

level— 分位数级别。可选参数。0 到 1 之间的常量浮点数。我们建议使用level范围内的值[0.01, 0.99]。默认值：0.5。level=0.5函数计算中位数。
expr— 对列值进行表达式，得出数字、日期或日期时间。
weight— 序列成员权重列。权重是值出现的次数。

返回值

指定级别的分位数。

类型：

Float64 用于数字数据类型输入。
如果输入值具有该Date类型，则为日期。
如果输入值具有该DateTime类型，则为 DateTime。

示例

CREATE TABLE IF NOT EXISTS test.functionQuantileExactWeighted (n UInt8, val UInt8) ENGINE=CnchMergeTree ORDER BY n;
INSERT INTO test.functionQuantileExactWeighted VALUES (0,3),(1,2),(2,1),(5,4);
SELECT quantileExactWeighted(n, val) FROM test.functionQuantileExactWeighted;

┌─quantileExactWeighted(n, val)─┐
│                             1 │
└───────────────────────────────┘

quantileTDigest

使用t-digest算法计算数值数据序列的近似分位数。
内存消耗为log(n)，其中n是数值。结果取决于运行查询的顺序，并且是不确定的。
函数的性能低于 quantile 或 quantileTiming 的性能。从状态大小与精度的比率来看，该函数比好得多quantile。
在查询中使用具有不同级别的多个函数时quantile*，内部状态不会合并（即查询的效率低于应有的水平）。在这种情况下，请使用分位数函数。
语法

quantileTDigest(level)(expr)

别名：medianTDigest。
参数

level— 分位数级别。可选参数。0 到 1 之间的常量浮点数。我们建议使用level范围内的值[0.01, 0.99]。默认值：0.5。level=0.5函数计算中位数。
expr— 对列值进行表达式，得出数字数据类型，即日期或日期时间。

返回值

指定级别的近似分位数。

类型：

Float64 用于数字数据类型输入。
如果输入值具有该Date类型，则为日期。
如果输入值具有该DateTime类型，则为 DateTime。

示例

SELECT quantileTDigest(number) FROM numbers(10)

┌─quantileTDigest(number)─┐
│ 4.5e+00                 │
└─────────────────────────┘

quantileTDigestWeighted

使用t-digest算法计算数值数据序列的近似分位数。该函数考虑了每个序列成员的权重。最大误差为 1%。内存消耗为，其中是值的数量。log(n)n
函数的性能低于 quantile 或 quantileTiming 的性能。从状态大小与精度的比率来看，该函数比好得多quantile。
结果取决于运行查询的顺序并且是不确定的。
在查询中使用具有不同级别的多个函数时quantile*，内部状态不会合并（即查询的效率低于应有的水平）。在这种情况下，请使用分位数函数。

sum

计算总和。仅适用于数字。
语法

sum(num)

参数

num: 数值列。(U)Int*, Float*, Decimal*。

返回值

值的总和。(U)Int*, Float*, Decimal*。

示例

创建一个表 employees 并向其中插入一些虚构的员工数据。

CREATE TABLE employees
(
    `id` UInt32,
    `name` String,
    `salary` UInt32
)
ENGINE = Log

INSERT INTO employees VALUES
    (87432, 'John Smith', 45680),
    (59018, 'Jane Smith', 72350),
    (20376, 'Ivan Ivanovich', 58900),
    (71245, 'Anastasia Ivanovna', 89210);

使用 sum 函数查询员工薪资的总额。

SELECT sum(salary) FROM employees;

结果：

┌─sum(salary)─┐
1. │      266140 │
   └─────────────┘

最近更新时间：2026.01.08 16:19:36

这个页面对您有帮助吗？

有用

无用

ByteHouse云数仓版

any #

anyHeavy #

anyLast #

argMax #

argMin #

avg #

corr #

covarPop #

covarSamp #

groupArray #

groupBitAnd #

groupBitOr #

groupBitXor #

groupBitmap #

groupBitmapAnd #

groupBitmapOr #

groupBitmapXor #

groupConcat #

groupUniqArray #

histogram #

max #

median #

medianDeterministic #

medianExact #

medianExactWeighted #

medianTDigest #

medianTDigestWeighted #

medianTiming #

medianTimingWeighted #

quantile #

quantileDeterministic #

quantileExact #

quantileExactWeighted #

quantileTDigest #

quantileTDigestWeighted #

sum #

any

anyHeavy

anyLast

argMax

argMin

avg

corr

covarPop

covarSamp

groupArray

groupBitAnd

groupBitOr

groupBitXor

groupBitmap

groupBitmapAnd

groupBitmapOr

groupBitmapXor

groupConcat

groupUniqArray

histogram

max

median

medianDeterministic

medianExact

medianExactWeighted

medianTDigest

medianTDigestWeighted

medianTiming

medianTimingWeighted

quantile

quantileDeterministic

quantileExact

quantileExactWeighted

quantileTDigest

quantileTDigestWeighted

sum