选择第一个遇到的值。
查询可以按任意顺序执行，甚至每次都按不同的顺序执行，因此此函数的结果不确定。
要获得确定的结果，您可以使用“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 │ └─────────────┘
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(column) sql
参数
column– 列名称。返回值
示例
SELECT anyLast(number) FROM numbers(10);
┌─anyLast(number)─┐ │ 9 │ └─────────────────┘
计算arg最大值的值。如果的最大值val有多个不同的值，则返回遇到的第一个值。argval
语法
argMax(arg, val) sql
参数
arg争论。val价值。返回值
示例
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 │ └──────────────────────┘
计算arg最小值的值。如果的最小值val有多个不同的值，则返回遇到的第一个值。argval
语法
argMin(arg, val)
参数
arg争论。val价值。返回值
示例
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(x)
参数
x— 输入值，必须是整数、浮点数或十进制。返回值
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 │ └────────┘
计算皮尔逊相关系数：Σ((x - x̅)(y - y̅)) / sqrt(Σ((x - x̅)^2) * Σ((y - y̅)^2))。
此函数使用数值不稳定算法。如果您需要计算中的数值稳定性corrStable，请使用该函数。它运行速度较慢，但计算误差较低。
语法
corr(x, y)
参数
x— 输入值，必须是整数、浮点数。y— 输入值，必须是整数、浮点数。返回值
示例
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 │ └────────────┘
计算 的值Σ((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 │ └────────────────┘
计算 的值Σ((x - x̅)(y - y̅)) / (n - 1)。
此函数使用数值不稳定算法。如果您需要计算中的数值稳定性covarSampStable，请使用该函数。它运行速度较慢，但计算误差较低。
语法
covarSamp(x, y)
参数
x— 输入值，必须是整数、浮点数。y— 输入值，必须是整数、浮点数。返回值
Σ((x - x̅)(y - y̅)) / (n - 1)，始终为 Float64。示例
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 │ └─────────────────┘
创建参数值数组。
可以按任意（不确定）顺序将值添加到数组中。
第二个版本（带有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] │ └───────────────────────┘
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。
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。
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。
从无符号整数列进行位图或聚合计算，返回 UInt64 类型的基数，如果添加后缀 -State，则返回位图对象。
语法
groupBitmap(expr)
参数
expr– 产生类型的表达式UInt*。返回值
UInt64。示例
SELECT groupBitmapState(number) FROM numbers(4);
┌─groupBitmap(number)─┐ │ 4 │ └─────────────────────┘
计算位图列的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] │ └──────────────────────────────────────────────────┘
计算位图列的或，返回 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] │ └─────────────────────────────────────────────────┘
计算位图列的异或，返回 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] │ └──────────────────────────────────────────────────┘
根据不同的参数值创建一个数组。内存消耗与 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(number_of_bins)(values)
参数
number_of_bins— 直方图中 bin 数量的上限。该函数会自动计算 bin 数量。它会尝试达到指定的 bin 数量，但如果失败，则会使用较少的 bin。values— 产生输入值的表达式。返回值
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(values)
参数
values— 输入值。返回值
示例
SELECT max(number) FROM numbers(20);
┌─max(number)─┐ │ 19 │ └─────────────┘
如果需要非聚合函数来选择最多两个值，请参见greatest：
SELECT greatest(a, b) FROM table;
这些median*函数是相应函数的别名quantile*。它们计算数值数据样本的中位数。
功能：
median— 分位数的别名。medianDeterministic— quantileDeterministic 的别名。medianExact— quantileExact 的别名。medianExactWeighted— quantileExactWeighted 的别名。medianTiming— quantileTiming 的别名。medianTimingWeighted— quantileTimingWeighted 的别名。medianTDigest— quantileTDigest 的别名。medianTDigestWeighted— quantileTDigestWeighted 的别名。medianBFloat16— quantileBFloat16 的别名。quantileDeterministic 的别名。
quantileExact 的别名。
quantileExactWeighted 的别名。
quantileTDigest 的别名。
quantileTDigestWeighted 的别名。
quantileTiming 的别名。
quantileTimingWeighted 的别名。
计算数值数据序列的近似分位数。
此函数应用水库采样，水库大小最大为 8192，并使用随机数生成器进行采样。结果不确定。要获得精确的分位数，请使用 quantileExact 函数。
在查询中使用具有不同级别的多个函数时quantile*，内部状态不会合并（即查询的效率低于应有的水平）。在这种情况下，请使用分位数函数。
语法
quantile(level)(expr)
别名：median。
参数
level— 分位数级别。可选参数。0 到 1 之间的常量浮点数。我们建议使用level范围内的值[0.01, 0.99]。默认值：0.5。level=0.5函数计算中位数。expr— 对列值进行表达式，得出数字、日期或日期时间。返回值
类型：
Date类型，则为日期。DateTime类型，则为 DateTime。示例
SELECT quantile(number) FROM numbers(10);
┌─quantile(number)─┐ │ 4.5e+00 │ └──────────────────┘
计算数值数据序列的近似分位数。
此函数应用水库采样，水库大小最高可达 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。如果相同的确定器值出现得太频繁，则该函数无法正常工作。返回值
类型：
Date类型，则为日期。DateTime类型，则为 DateTime。示例
SELECT quantileDeterministic(number, 1) FROM numbers(10); sql
┌─quantileDeterministic(number, 1)─┐ │ 4.5e+00 │ └──────────────────────────────────┘ 纯文本
精确计算数值数据序列的分位数。
为了获得精确值，所有传递的值都会组合成一个数组，然后对其进行部分排序。因此，该函数会消耗O(n)内存，其中n是传递的值的数量。但是，对于少量值，该函数非常有效。
在查询中使用具有不同级别的多个函数时quantile*，内部状态不会合并（即查询的效率低于应有的水平）。在这种情况下，请使用分位数函数。
语法
quantileExact(level)(expr)
别名：medianExact。
参数
level— 分位数级别。可选参数。0 到 1 之间的常量浮点数。我们建议使用level范围内的值[0.01, 0.99]。默认值：0.5。level=0.5函数计算中位数。expr— 对列值进行表达式，得出数字数据类型，即日期或日期时间。返回值
类型：
Date类型，则为日期。DateTime类型，则为 DateTime。示例
SELECT quantileExact(number) FROM numbers(10);
┌─quantileExact(number)─┐ │ 5 │ └───────────────────────┘
精确计算数值数据序列的分位数，同时考虑每个元素的权重。
为了获得精确值，所有传递的值都会组合成一个数组，然后对其进行部分排序。每个值都用其权重进行计数，就像它是当前值一样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— 序列成员权重列。权重是值出现的次数。返回值
类型：
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 │ └───────────────────────────────┘
使用t-digest算法计算数值数据序列的近似分位数。
内存消耗为log(n)，其中n是数值。结果取决于运行查询的顺序，并且是不确定的。
函数的性能低于 quantile 或 quantileTiming 的性能。从状态大小与精度的比率来看，该函数比 好得多quantile。
在查询中使用具有不同级别的多个函数时quantile*，内部状态不会合并（即查询的效率低于应有的水平）。在这种情况下，请使用分位数函数。
语法
quantileTDigest(level)(expr) sql
别名：medianTDigest。
参数
level— 分位数级别。可选参数。0 到 1 之间的常量浮点数。我们建议使用level范围内的值[0.01, 0.99]。默认值：0.5。level=0.5函数计算中位数。expr— 对列值进行表达式，得出数字数据类型，即日期或日期时间。返回值
类型：
Date类型，则为日期。DateTime类型，则为 DateTime。示例
SELECT quantileTDigest(number) FROM numbers(10)
┌─quantileTDigest(number)─┐ │ 4.5e+00 │ └─────────────────────────┘
使用t-digest算法计算数值数据序列的近似分位数。该函数考虑了每个序列成员的权重。最大误差为 1%。内存消耗为，其中是值的数量。log(n)n
函数的性能低于 quantile 或 quantileTiming 的性能。从状态大小与精度的比率来看，该函数比 好得多quantile。
结果取决于运行查询的顺序并且是不确定的。
在查询中使用具有不同级别的多个函数时quantile*，内部状态不会合并（即查询的效率低于应有的水平）。在这种情况下，请使用分位数函数。