数组函数
empty
检查输入数组是否为空。
语法
empty([x])
如果数组不包含任何元素，则认为该数组为空。
可以通过启用 optimize_functions_to_subcolumns 设置 来优化。当 optimize_functions_to_subcolumns = 1 时，该函数仅读取 size0 子列，而不是读取和处理整个数组列。查询 SELECT empty(arr) FROM TABLE; 将转换为 SELECT arr.size0 = 0 FROM TABLE;。
参数
[x]— 输入数组。 数组。
返回值
- 对于空数组返回
1，对于非空数组返回0。
类型：UInt8。
示例
查询
SELECT empty([]);
结果
┌─empty(array())─┐
│ 1 │
└────────────────┘
notEmpty
检查输入数组是否为非空。
语法
notEmpty([x])
如果数组包含至少一个元素，则认为该数组为非空。
可以通过启用 optimize_functions_to_subcolumns 设置来优化。当 optimize_functions_to_subcolumns = 1 时，该函数仅读取 size0 子列，而不是读取和处理整个数组列。查询 SELECT notEmpty(arr) FROM table 将转换为 SELECT arr.size0 != 0 FROM TABLE。
参数
[x]— 输入数组。 数组。
返回值
- 对于非空数组返回
1，对于空数组返回0。
类型：UInt8。
示例
查询
SELECT notEmpty([1,2]);
结果
┌─notEmpty([1, 2])─┐
│ 1 │
└──────────────────┘
length
返回数组中的元素个数。结果类型为 UInt64。该函数也适用于字符串。
可以通过启用 optimize_functions_to_subcolumns 设置来优化。当 optimize_functions_to_subcolumns = 1 时，该函数仅读取 size0 子列，而不是读取和处理整个数组列。查询 SELECT length(arr) FROM table 将转换为 SELECT arr.size0 FROM TABLE。
别名：OCTET_LENGTH
emptyArrayUInt8
返回一个空的 UInt8 数组。
语法
emptyArrayUInt8()
参数
无。
返回值
一个空数组。
示例
查询
SELECT emptyArrayUInt8();
结果
[]
emptyArrayUInt16
返回一个空的 UInt16 数组。
语法
emptyArrayUInt16()
参数
无。
返回值
一个空数组。
示例
查询
SELECT emptyArrayUInt16();
结果
[]
emptyArrayUInt32
返回一个空的 UInt32 数组。
语法
emptyArrayUInt32()
参数
无。
返回值
一个空数组。
示例
查询
SELECT emptyArrayUInt32();
结果
[]
emptyArrayUInt64
返回一个空的 UInt64 数组。
语法
emptyArrayUInt64()
参数
无。
返回值
一个空数组。
示例
查询
SELECT emptyArrayUInt64();
结果
[]
emptyArrayInt8
返回一个空的 Int8 数组。
语法
emptyArrayInt8()
参数
无。
返回值
一个空数组。
示例
查询
SELECT emptyArrayInt8();
结果
[]
emptyArrayInt16
返回一个空的 Int16 数组。
语法
emptyArrayInt16()
参数
无。
返回值
一个空数组。
示例
查询
SELECT emptyArrayInt16();
结果
[]
emptyArrayInt32
返回一个空的 Int32 数组。
语法
emptyArrayInt32()
参数
无。
返回值
一个空数组。
示例
查询
SELECT emptyArrayInt32();
结果
[]
emptyArrayInt64
返回一个空的 Int64 数组。
语法
emptyArrayInt64()
参数
无。
返回值
一个空数组。
示例
查询
SELECT emptyArrayInt64();
结果
[]
emptyArrayFloat32
返回一个空的 Float32 数组。
语法
emptyArrayFloat32()
参数
无。
返回值
一个空数组。
示例
查询
SELECT emptyArrayFloat32();
结果
[]
emptyArrayFloat64
返回一个空的 Float64 数组。
语法
emptyArrayFloat64()
参数
无。
返回值
一个空数组。
示例
查询
SELECT emptyArrayFloat64();
结果
[]
emptyArrayDate
返回一个空的 Date 数组。
语法
emptyArrayDate()
参数
无。
返回值
一个空数组。
示例
查询
SELECT emptyArrayDate();
emptyArrayDateTime
返回一个空的 DateTime 数组。
语法
[]
参数
无。
返回值
一个空数组。
示例
查询
SELECT emptyArrayDateTime();
结果
[]
emptyArrayString
返回一个空的 String 数组。
语法
emptyArrayString()
参数
无。
返回值
一个空数组。
示例
查询
SELECT emptyArrayString();
结果
[]
emptyArrayToSingle
接受一个空数组，并返回一个包含默认值的单元素数组。
range(end), range([start,]end[, step])
返回一个从 start 到 end - 1，步长为 step 的数字数组。支持的类型有 UInt8、UInt16、UInt32、UInt64、Int8、Int16、Int32、Int64。
语法
range([start, ] end [, step])
参数
start— 数组的第一个元素。可选，如果使用step则为必填。默认值：0。end— 构造数组之前的数字。必填。step— 确定数组中每个元素之间的增量步长。可选。默认值：1。
返回值
- 从
start到end - 1，步长为step的数字数组。
实现细节
- 所有参数
start、end、step必须低于以下数据类型：UInt8、UInt16、UInt32、UInt64、Int8、Int16、Int32、Int64，以及返回数组的元素类型，该类型是所有参数的超类型。 - 如果查询结果数组的总长度超过 function_range_max_elements_in_block 设置指定的元素数量，则会抛出异常。
- 如果任何参数具有 Nullable(Nothing) 类型，则返回 Null。如果任何参数具有 Null 值（Nullable(T) 类型），则会抛出异常。
示例
查询
SELECT range(5), range(1, 5), range(1, 5, 2), range(-1, 5, 2);
结果
┌─range(5)────┬─range(1, 5)─┬─range(1, 5, 2)─┬─range(-1, 5, 2)─┐
│ [0,1,2,3,4] │ [1,2,3,4] │ [1,3] │ [-1,1,3] │
└─────────────┴─────────────┴────────────────┴─────────────────┘
array(x1, …), 运算符[x1, …]
从函数参数创建一个数组。参数必须是常量，并且具有最小公共类型的类型。必须至少传递一个参数，否则不清楚要创建哪种类型的数组。也就是说，不能使用此函数创建空数组（为此，请使用上面描述的“emptyArray*”函数）。返回“Array(T)”类型的结果，其中“T”是传递参数的最小公共类型。
arrayWithConstant(length, elem)
创建一个长度为 length 的数组，并用常量 elem 填充。
arrayConcat
合并作为参数传递的数组。
arrayConcat(arrays)
参数
arrays– 任意数量的 数组 类型参数。
示例
SELECT arrayConcat([1, 2], [3, 4], [5, 6]) AS res
┌─res───────────┐
│ [1,2,3,4,5,6] │
└───────────────┘
arrayElement(arr, n), 运算符 arr[n]
从数组 arr 中获取索引为 n 的元素。n 必须是任何整数类型。数组中的索引从一开始。支持负索引。在这种情况下，它选择从末尾开始编号的相应元素。例如，arr[-1] 是数组中的最后一个元素。
如果索引超出数组的边界，则返回一些默认值（数字为 0，字符串为空字符串等），但非恒定数组和恒定索引 0 的情况除外（在这种情况下，会出现错误 数组索引从 1 开始）。
has(arr, elem)
检查“arr”数组是否包含“elem”元素。如果元素不在数组中，则返回 0，否则返回 1。
NULL 被视为一个值。
SELECT has([1, 2, NULL], NULL)
┌─has([1, 2, NULL], NULL)─┐
│ 1 │
└─────────────────────────┘
hasAll
检查一个数组是否是另一个数组的子集。
hasAll(set, subset)
参数
set– 任何类型的数组，其中包含一组元素。subset– 任何类型的数组，与set共用一个公共超类型，其中包含应测试为set子集的元素。
返回值
- 如果
set包含subset中的所有元素，则返回1。 - 否则返回
0。
如果集合和子集元素不共享公共超类型，则引发异常 NO_COMMON_TYPE。
特殊属性
- 空数组是任何数组的子集。
Null被视为一个值。- 两个数组中值的顺序无关紧要。
示例
SELECT hasAll([], []) 返回 1。
SELECT hasAll([1, Null], [Null]) 返回 1。
SELECT hasAll([1.0, 2, 3, 4], [1, 3]) 返回 1。
SELECT hasAll(['a', 'b'], ['a']) 返回 1。
SELECT hasAll([1], ['a']) 引发 NO_COMMON_TYPE 异常。
SELECT hasAll([[1, 2], [3, 4]], [[1, 2], [3, 5]]) 返回 0。
hasAny
检查两个数组是否通过某些元素相交。
hasAny(array1, array2)
参数
array1- 具有元素集的任何类型的数组。array2- 与array1共享公共超类型的任何类型的数组。
返回值
- 如果
array1和array2至少有一个相似元素，则返回1。 - 否则返回
0。
如果 array1 和 array2 元素不共享公共超类型，则引发异常 NO_COMMON_TYPE。
特殊属性
Null被视为一个值。- 两个数组中值的顺序无关紧要。
示例
SELECT hasAny([1], []) 返回 0。
SELECT hasAny([Null], [Null, 1]) 返回 1。
SELECT hasAny([-128, 1., 512], [1]) 返回 1。
SELECT hasAny([[1, 2], [3, 4]], ['a', 'c']) 引发 NO_COMMON_TYPE 异常。
SELECT hasAll([[1, 2], [3, 4]], [[1, 2], [1, 2]]) 返回 1。
hasSubstr
检查 array2 的所有元素是否按完全相同的顺序出现在 array1 中。因此，当且仅当 array1 = prefix + array2 + suffix 时，该函数才会返回 1。
hasSubstr(array1, array2)
换句话说，该函数将检查 array2 的所有元素是否像 hasAll 函数一样包含在 array1 中。此外，它还会检查在 array1 和 array2 中是否以相同的顺序观察到这些元素。
例如
hasSubstr([1,2,3,4], [2,3])返回 1。但是，hasSubstr([1,2,3,4], [3,2])将返回0。hasSubstr([1,2,3,4], [1,2,3])返回 1。但是，hasSubstr([1,2,3,4], [1,2,4])将返回0。
参数
array1- 具有元素集的任何类型的数组。array2- 具有元素集的任何类型的数组。
返回值
- 如果
array1包含array2，则返回1。 - 否则返回
0。
如果 array1 和 array2 元素不共享公共超类型，则引发异常 NO_COMMON_TYPE。
特殊属性
- 如果
array2为空，则该函数将返回1。 Null被视为一个值。换句话说，hasSubstr([1, 2, NULL, 3, 4], [2,3])将返回0。但是，hasSubstr([1, 2, NULL, 3, 4], [2,NULL,3])将返回1- 两个数组中值的顺序很重要。
示例
SELECT hasSubstr([], []) 返回 1。
SELECT hasSubstr([1, Null], [Null]) 返回 1。
SELECT hasSubstr([1.0, 2, 3, 4], [1, 3]) 返回 0。
SELECT hasSubstr(['a', 'b'], ['a']) 返回 1。
SELECT hasSubstr(['a', 'b' , 'c'], ['a', 'b']) 返回 1。
SELECT hasSubstr(['a', 'b' , 'c'], ['a', 'c']) 返回 0。
SELECT hasSubstr([[1, 2], [3, 4], [5, 6]], [[1, 2], [3, 4]]) 返回 1. i SELECT hasSubstr([1, 2, NULL, 3, 4], ['a']) 引发 NO_COMMON_TYPE 异常。
indexOf(arr, x)
如果数组中存在第一个“x”元素，则返回其索引（从 1 开始），如果不存在，则返回 0。
示例
SELECT indexOf([1, 3, NULL, NULL], NULL)
┌─indexOf([1, 3, NULL, NULL], NULL)─┐
│ 3 │
└───────────────────────────────────┘
设置为 NULL 的元素将作为正常值处理。
arrayCount([func,]arr1, …)
返回 func(arr1[i], …, arrN[i]) 返回非 0 值的元素数量。如果未指定 func，则返回数组中非零元素的数量。
请注意，arrayCount 是一个高阶函数。您可以将 lambda 函数作为第一个参数传递给它。
arrayDotProduct
返回两个数组的点积。
语法
arrayDotProduct(vector1, vector2)
别名：scalarProduct、dotProduct
参数
两个向量的大小必须相等。数组和元组也可以包含混合元素类型。
返回值
- 两个向量的点积。
类型：数值 - 由参数的类型决定。如果数组或元组包含混合元素类型，则结果类型为超类型。
示例
查询
SELECT arrayDotProduct([1, 2, 3], [4, 5, 6]) AS res, toTypeName(res);
结果
32 UInt16
查询
SELECT dotProduct((1::UInt16, 2::UInt8, 3::Float32),(4::Int16, 5::Float32, 6::UInt8)) AS res, toTypeName(res);
结果
32 Float64
countEqual(arr, x)
返回数组中等于 x 的元素数量。等效于 arrayCount (elem ->elem = x, arr)。
NULL 元素被视为单独的值。
示例
SELECT countEqual([1, 2, NULL, NULL], NULL)
┌─countEqual([1, 2, NULL, NULL], NULL)─┐
│ 2 │
└──────────────────────────────────────┘
arrayEnumerate(arr)
返回数组[1, 2, 3, …, length (arr)]
此函数通常与 ARRAY JOIN 一起使用。它允许在应用 ARRAY JOIN 后对每个数组只计算一次。示例
SELECT
count() AS Reaches,
countIf(num = 1) AS Hits
FROM test.hits
ARRAY JOIN
GoalsReached,
arrayEnumerate(GoalsReached) AS num
WHERE CounterID = 160656
LIMIT 10
┌─Reaches─┬──Hits─┐
│ 95606 │ 31406 │
└─────────┴───────┘
在此示例中，Reaches 是转化次数（应用 ARRAY JOIN 后接收到的字符串），Hits 是页面浏览量（ARRAY JOIN 之前的字符串）。在这种特殊情况下，您可以通过更简单的方式获得相同的结果
SELECT
sum(length(GoalsReached)) AS Reaches,
count() AS Hits
FROM test.hits
WHERE (CounterID = 160656) AND notEmpty(GoalsReached)
┌─Reaches─┬──Hits─┐
│ 95606 │ 31406 │
└─────────┴───────┘
此函数也可以在高阶函数中使用。例如，您可以使用它来获取与条件匹配的元素的数组索引。
arrayEnumerateUniq(arr, …)
返回一个与源数组大小相同的数组，指示每个元素在具有相同值的元素中的位置。例如：arrayEnumerateUniq([10, 20, 10, 30]) = [1, 1, 2, 1].
此函数在使用 ARRAY JOIN 和聚合数组元素时非常有用。示例
SELECT
Goals.ID AS GoalID,
sum(Sign) AS Reaches,
sumIf(Sign, num = 1) AS Visits
FROM test.visits
ARRAY JOIN
Goals,
arrayEnumerateUniq(Goals.ID) AS num
WHERE CounterID = 160656
GROUP BY GoalID
ORDER BY Reaches DESC
LIMIT 10
┌──GoalID─┬─Reaches─┬─Visits─┐
│ 53225 │ 3214 │ 1097 │
│ 2825062 │ 3188 │ 1097 │
│ 56600 │ 2803 │ 488 │
│ 1989037 │ 2401 │ 365 │
│ 2830064 │ 2396 │ 910 │
│ 1113562 │ 2372 │ 373 │
│ 3270895 │ 2262 │ 812 │
│ 1084657 │ 2262 │ 345 │
│ 56599 │ 2260 │ 799 │
│ 3271094 │ 2256 │ 812 │
└─────────┴─────────┴────────┘
在此示例中，每个目标 ID 都计算了转化次数（Goals 嵌套数据结构中的每个元素都是已达成的目标，我们将其称为转化）和会话次数。如果没有 ARRAY JOIN，我们将使用 sum(Sign) 计算会话次数。但在这种特殊情况下，行会乘以嵌套的 Goals 结构，因此为了在此之后对每个会话进行一次计数，我们对 arrayEnumerateUniq(Goals.ID) 函数的值应用了一个条件。
arrayEnumerateUniq 函数可以采用多个大小相同的数组作为参数。在这种情况下，将考虑所有数组中相同位置的元素元组的唯一性。
SELECT arrayEnumerateUniq([1, 1, 1, 2, 2, 2], [1, 1, 2, 1, 1, 2]) AS res
┌─res───────────┐
│ [1,2,1,1,2,1] │
└───────────────┘
当将 ARRAY JOIN 与嵌套数据结构一起使用并在该结构中的多个元素之间进行进一步聚合时，这是必要的。
arrayEnumerateUniqRanked
返回一个与源数组大小相同的数组，指示每个元素在具有相同值的元素中的位置。它允许枚举多维数组，并能够指定深入数组的深度。
语法
arrayEnumerateUniqRanked(clear_depth, arr, max_array_depth)
参数
clear_depth：分别枚举指定级别的元素。小于或等于max_arr_depth的正整数。arr：要枚举的 N 维数组。数组。max_array_depth：最大有效深度。小于或等于arr深度的正整数。
示例
当 clear_depth=1 且 max_array_depth=1 时，arrayEnumerateUniqRanked 的结果与arrayEnumerateUniq对同一数组的结果相同。
查询
SELECT arrayEnumerateUniqRanked(1, [1,2,1], 1);
结果
[1,1,2]
在此示例中，arrayEnumerateUniqRanked 用于获取一个数组，该数组指示多维数组的每个元素在具有相同值的元素中的位置。对于传递数组的第一行 [1,2,3]，对应的结果是 [1,1,1]，表示这是第一次遇到 1、2 和 3。对于提供的数组的第二行 [2,2,1]，对应的结果是 [2,3,3]，表示第二次和第三次遇到 2，第二次遇到 1。同样，对于提供的数组的第三行 [3]，对应的结果是 [2]，表示第二次遇到 3。
查询
SELECT arrayEnumerateUniqRanked(1, [[1,2,3],[2,2,1],[3]], 2);
结果
[[1,1,1],[2,3,2],[2]]
将 clear_depth 更改为 2，会导致分别枚举每一行的元素。
查询
SELECT arrayEnumerateUniqRanked(2, [[1,2,3],[2,2,1],[3]], 2);
结果
[[1,1,1],[1,2,1],[1]]
arrayPopBack
删除数组中的最后一项。
arrayPopBack(array)
参数
array- 数组。
示例
SELECT arrayPopBack([1, 2, 3]) AS res;
┌─res───┐
│ [1,2] │
└───────┘
arrayPopFront
删除数组中的第一项。
arrayPopFront(array)
参数
array- 数组。
示例
SELECT arrayPopFront([1, 2, 3]) AS res;
┌─res───┐
│ [2,3] │
└───────┘
arrayPushBack
在数组的末尾添加一项。
arrayPushBack(array, single_value)
参数
array- 数组。single_value- 单个值。只能将数字添加到数字数组中，只能将字符串添加到字符串数组中。添加数字时，ClickHouse 会自动将single_value类型设置为数组的数据类型。有关 ClickHouse 中数据类型的更多信息，请参阅“数据类型”。可以是NULL。该函数将NULL元素添加到数组中，并将数组元素的类型转换为Nullable。
示例
SELECT arrayPushBack(['a'], 'b') AS res;
┌─res───────┐
│ ['a','b'] │
└───────────┘
arrayPushFront
在数组的开头添加一个元素。
arrayPushFront(array, single_value)
参数
array- 数组。single_value- 单个值。只能将数字添加到数字数组中，只能将字符串添加到字符串数组中。添加数字时，ClickHouse 会自动将single_value类型设置为数组的数据类型。有关 ClickHouse 中数据类型的更多信息，请参阅“数据类型”。可以是NULL。该函数将NULL元素添加到数组中，并将数组元素的类型转换为Nullable。
示例
SELECT arrayPushFront(['b'], 'a') AS res;
┌─res───────┐
│ ['a','b'] │
└───────────┘
arrayResize
更改数组的长度。
arrayResize(array, size[, extender])
参数
array- 数组。size- 数组的所需长度。- 如果
size小于数组的原始大小，则从右侧截断数组。
- 如果
- 如果
size大于数组的初始大小，则使用extender值或数组项数据类型的默认值将数组扩展到右侧。 extender- 用于扩展数组的值。可以是NULL。
返回值
长度为 size 的数组。
调用示例
SELECT arrayResize([1], 3);
┌─arrayResize([1], 3)─┐
│ [1,0,0] │
└─────────────────────┘
SELECT arrayResize([1], 3, NULL);
┌─arrayResize([1], 3, NULL)─┐
│ [1,NULL,NULL] │
└───────────────────────────┘
arraySlice
返回数组的切片。
arraySlice(array, offset[, length])
参数
array- 数据数组。offset- 从数组边缘开始的缩进。正值表示左侧的偏移量，负值表示右侧的偏移量。数组项的编号从 1 开始。length- 所需切片的长度。如果指定负值，则该函数返回一个开放切片[offset, array_length - length]。如果省略该值，则该函数返回切片[offset, the_end_of_array]。
示例
SELECT arraySlice([1, 2, NULL, 4, 5], 2, 3) AS res;
┌─res────────┐
│ [2,NULL,4] │
└────────────┘
设置为 NULL 的数组元素将作为正常值处理。
arrayShingles
生成一个“shingles”数组，即输入数组中具有指定长度的连续子数组。
语法
arrayShingles(array, length)
参数
array- 输入数组 数组。length- 每个 shingle 的长度。
返回值
- 生成的 shingles 数组。
类型：数组。
示例
查询
SELECT arrayShingles([1,2,3,4], 3) as res;
结果
┌─res───────────────┐
│ [[1,2,3],[2,3,4]] │
└───────────────────┘
arraySort([func,]arr, …)
按升序对 arr 数组的元素进行排序。如果指定了 func 函数，则排序顺序由应用于数组元素的 func 函数的结果确定。如果 func 接受多个参数，则会向 arraySort 函数传递多个数组，这些数组将与 func 的参数相对应。arraySort 描述的末尾显示了详细示例。
对整数值进行排序的示例
SELECT arraySort([1, 3, 3, 0]);
┌─arraySort([1, 3, 3, 0])─┐
│ [0,1,3,3] │
└─────────────────────────┘
对字符串值进行排序的示例
SELECT arraySort(['hello', 'world', '!']);
┌─arraySort(['hello', 'world', '!'])─┐
│ ['!','hello','world'] │
└────────────────────────────────────┘
请考虑以下针对 NULL、NaN 和 Inf 值的排序顺序
SELECT arraySort([1, nan, 2, NULL, 3, nan, -4, NULL, inf, -inf]);
┌─arraySort([1, nan, 2, NULL, 3, nan, -4, NULL, inf, -inf])─┐
│ [-inf,-4,1,2,3,inf,nan,nan,NULL,NULL] │
└───────────────────────────────────────────────────────────┘
-Inf值位于数组中的最前面。NULL值位于数组中的最后面。NaN值位于NULL之前。Inf值位于NaN之前。
请注意，arraySort 是一个高阶函数。您可以将 lambda 函数作为第一个参数传递给它。在这种情况下，排序顺序由应用于数组元素的 lambda 函数的结果确定。
让我们考虑以下示例
SELECT arraySort((x) -> -x, [1, 2, 3]) as res;
┌─res─────┐
│ [3,2,1] │
└─────────┘
对于源数组的每个元素，lambda 函数都会返回排序键，即[1 –>-1, 2 –>-2, 3 –> -3]。由于 arraySort 函数按升序对键进行排序，因此结果为[3, 2, 1]。因此，(x) –> -x lambda 函数在排序中设置降序。
lambda 函数可以接受多个参数。在这种情况下，您需要向 arraySort 函数传递多个长度相同的数组，这些数组将与 lambda 函数的参数相对应。结果数组将由第一个输入数组中的元素组成；来自下一个输入数组的元素指定排序键。例如
SELECT arraySort((x, y) -> y, ['hello', 'world'], [2, 1]) as res;
┌─res────────────────┐
│ ['world', 'hello'] │
└────────────────────┘
在这里，在第二个数组中传递的元素 ([2, 1]) 为来自源数组 ([‘hello’, ‘world’]) 中的相应元素定义排序键，即[‘hello’ –>2, ‘world’ –> 1]。由于 lambda 函数不使用 x，因此源数组的实际值不会影响结果中的顺序。因此，'hello' 将是结果中的第二个元素，而 'world' 将是第一个元素。
其他示例如下所示。
SELECT arraySort((x, y) -> y, [0, 1, 2], ['c', 'b', 'a']) as res;
┌─res─────┐
│ [2,1,0] │
└─────────┘
SELECT arraySort((x, y) -> -y, [0, 1, 2], [1, 2, 3]) as res;
┌─res─────┐
│ [2,1,0] │
└─────────┘
为了提高排序效率，使用了施瓦茨变换。
arrayPartialSort([func,]limit, arr, …)
与 arraySort 相同，但带有额外的 limit 参数，允许部分排序。返回一个与原始数组大小相同的数组，其中范围 [1..limit] 中的元素按升序排序。其余元素 (limit..N] 应包含未指定顺序的元素。
arrayReverseSort([func,]arr, …)
按降序对 arr 数组的元素进行排序。如果指定了 func 函数，则根据应用于数组元素的 func 函数的结果对 arr 进行排序，然后反转排序后的数组。如果 func 接受多个参数，则会向 arrayReverseSort 函数传递多个数组，这些数组将与 func 的参数相对应。arrayReverseSort 描述的末尾显示了详细示例。
对整数值进行排序的示例
SELECT arrayReverseSort([1, 3, 3, 0]);
┌─arrayReverseSort([1, 3, 3, 0])─┐
│ [3,3,1,0] │
└────────────────────────────────┘
对字符串值进行排序的示例
SELECT arrayReverseSort(['hello', 'world', '!']);
┌─arrayReverseSort(['hello', 'world', '!'])─┐
│ ['world','hello','!'] │
└───────────────────────────────────────────┘
请考虑以下针对 NULL、NaN 和 Inf 值的排序顺序
SELECT arrayReverseSort([1, nan, 2, NULL, 3, nan, -4, NULL, inf, -inf]) as res;
┌─res───────────────────────────────────┐
│ [inf,3,2,1,-4,-inf,nan,nan,NULL,NULL] │
└───────────────────────────────────────┘
Inf值位于数组中的最前面。NULL值位于数组中的最后面。NaN值位于NULL之前。-Inf值位于NaN之前。
请注意，arrayReverseSort 是一个高阶函数。您可以将 lambda 函数作为第一个参数传递给它。示例如下所示。
SELECT arrayReverseSort((x) -> -x, [1, 2, 3]) as res;
┌─res─────┐
│ [1,2,3] │
└─────────┘
数组按以下方式排序
- 首先，根据应用于数组元素的 lambda 函数的结果对源数组 ([1, 2, 3]) 进行排序。结果是一个数组[3, 2, 1].
- 反转上一步获得的数组。因此，最终结果为[1, 2, 3].
lambda 函数可以接受多个参数。在这种情况下，您需要向 arrayReverseSort 函数传递多个长度相同的数组，这些数组将与 lambda 函数的参数相对应。结果数组将由第一个输入数组中的元素组成；来自下一个输入数组的元素指定排序键。例如
SELECT arrayReverseSort((x, y) -> y, ['hello', 'world'], [2, 1]) as res;
┌─res───────────────┐
│ ['hello','world'] │
└───────────────────┘
在此示例中，数组按以下方式排序
- 首先，根据应用于数组元素的 lambda 函数的结果对源数组 ([‘hello’, ‘world’]) 根据应用于数组元素的 lambda 函数的结果进行排序。在第二个数组中传递的元素 ([2, 1]) 为来自源数组中的相应元素定义排序键。结果是一个数组[‘world’, ‘hello’].
- 反转上一步排序的数组。因此，最终结果为[‘hello’, ‘world’].
其他示例如下所示。
SELECT arrayReverseSort((x, y) -> y, [4, 3, 5], ['a', 'b', 'c']) AS res;
┌─res─────┐
│ [5,3,4] │
└─────────┘
SELECT arrayReverseSort((x, y) -> -y, [4, 3, 5], [1, 2, 3]) AS res;
┌─res─────┐
│ [4,3,5] │
└─────────┘
arrayPartialReverseSort([func,]limit, arr, …)
与 arrayReverseSort 相同，但带有额外的 limit 参数，允许部分排序。返回一个与原始数组大小相同的数组，其中范围 [1..limit] 中的元素按降序排序。其余元素 (limit..N] 应包含未指定顺序的元素。
arrayShuffle
返回一个与原始数组大小相同的数组，其中包含按随机顺序排列的元素。元素的重新排序方式使得这些元素的每个可能排列都具有相同的出现概率。
语法
arrayShuffle(arr[, seed])
参数
arr：要部分随机排列的数组。数组。seed（可选）：用于随机数生成的种子。如果未提供，则使用随机种子。UInt 或 Int。
返回值
- 元素已随机排列的数组。
实现细节
此函数不会具体化常量。
示例
在此示例中，使用 arrayShuffle 时未提供 seed，因此它将自行随机生成一个种子。
查询
SELECT arrayShuffle([1, 2, 3, 4]);
注意：使用ClickHouse Fiddle时，由于函数的随机性，确切的响应可能会有所不同。
结果
[1,4,2,3]
在此示例中，为 arrayShuffle 提供了一个 seed，它将产生稳定的结果。
查询
SELECT arrayShuffle([1, 2, 3, 4], 41);
结果
[3,2,1,4]
arrayPartialShuffle
给定一个基数为 N 的输入数组，返回一个大小为 N 的数组，其中范围 [1...limit] 中的元素被随机排列，而范围 (limit...n] 中的其余元素未被随机排列。
语法
arrayPartialShuffle(arr[, limit[, seed]])
参数
arr：要部分随机排列的大小为N的数组。数组。limit（可选）：将元素交换限制为范围[1..N]中的数字。UInt 或 Int。seed（可选）：用于随机数生成的种子值。如果未提供，则使用随机种子值。UInt 或 Int
返回值
- 元素已部分随机排列的数组。
实现细节
示例
注意：使用ClickHouse Fiddle时，由于函数的随机性，确切的响应可能会有所不同。
查询
SELECT arrayPartialShuffle([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 1)
结果
元素的顺序保持不变 ([2,3,4,5], [7,8,9,10])，但两个随机排列的元素 [1, 6] 除外。未提供 seed，因此函数会随机选择自己的种子。
[6,2,3,4,5,1,7,8,9,10]
在此示例中，limit 增加到 2，并提供了一个 seed 值。顺序
查询
SELECT arrayPartialShuffle([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 2);
元素的顺序保持不变 ([4, 5, 6, 7, 8], [10])，但四个随机排列的元素 [1, 2, 3, 9] 除外。
结果
[3,9,1,4,5,6,7,8,2,10]
arrayUniq(arr, …)
如果传递了一个参数，则它会计算数组中不同元素的数量。如果传递了多个参数，则它会计算多个数组中相应位置的元素的不同元组的数量。
如果要获取数组中唯一项的列表，可以使用 arrayReduce(‘groupUniqArray’, arr)。
arrayJoin(arr)
特殊函数。请参阅“ArrayJoin 函数”部分。
arrayDifference
计算相邻数组元素之间的差值数组。结果数组的第一个元素将为 0，第二个元素为 a[1] - a[0]，第三个元素为 a[2] - a[1]，依此类推。结果数组中元素的类型由减法的类型推断规则确定（例如，UInt8 - UInt8 = Int16）。
语法
arrayDifference(array)
参数
array– 数组。
返回值
返回相邻数组元素之间的差值数组。
示例
查询
SELECT arrayDifference([1, 2, 3, 4]);
结果
┌─arrayDifference([1, 2, 3, 4])─┐
│ [0,1,1,1] │
└───────────────────────────────┘
由于结果类型 Int64 导致溢出的示例
查询
SELECT arrayDifference([0, 10000000000000000000]);
结果
┌─arrayDifference([0, 10000000000000000000])─┐
│ [0,-8446744073709551616] │
└────────────────────────────────────────────┘
arrayDistinct
接受一个数组，返回一个仅包含不同元素的数组。
语法
arrayDistinct(array)
参数
array– 数组。
返回值
返回一个包含不同元素的数组。
示例
查询
SELECT arrayDistinct([1, 2, 2, 3, 1]);
结果
┌─arrayDistinct([1, 2, 2, 3, 1])─┐
│ [1,2,3] │
└────────────────────────────────┘
arrayEnumerateDense
返回一个与源数组大小相同的数组，指示每个元素在源数组中首次出现的位置。
语法
arrayEnumerateDense(arr)
示例
查询
SELECT arrayEnumerateDense([10, 20, 10, 30])
结果
┌─arrayEnumerateDense([10, 20, 10, 30])─┐
│ [1,2,1,3] │
└───────────────────────────────────────┘
arrayEnumerateDenseRanked
返回一个与源数组大小相同的数组，指示每个元素在源数组中首次出现的位置。它允许枚举多维数组，并能够指定要深入数组的深度。
语法
arrayEnumerateDenseRanked(clear_depth, arr, max_array_depth)
参数
clear_depth：分别枚举指定级别的元素。小于或等于max_arr_depth的正整数。arr：要枚举的 N 维数组。数组。max_array_depth：最大有效深度。小于或等于arr深度的正整数。
示例
如果 clear_depth=1 且 max_array_depth=1，则结果与 arrayEnumerateDense 的结果相同。
查询
SELECT arrayEnumerateDenseRanked(1,[10, 20, 10, 30],1);
结果
[1,2,1,3]
在此示例中，使用 arrayEnumerateDenseRanked 获取一个数组，该数组指示多维数组的每个元素在具有相同值的元素中的位置。对于传递的数组的第一行 [10,10,30,20]，结果的对应第一行为 [1,1,2,3]，表示 10 是在位置 1 和 2 遇到的第一个数字，30 是在位置 3 遇到的第二个数字，20 是在位置 4 遇到的第三个数字。对于第二行 [40, 50, 10, 30]，结果的对应第二行为 [4,5,1,2]，表示 40 和 50 是在该行的位置 1 和 2 遇到的第四个和第五个数字，另一个 10（遇到的第一个数字）位于位置 3，30（遇到的第二个数字）位于最后一个位置。
查询
SELECT arrayEnumerateDenseRanked(1,[[10,10,30,20],[40,50,10,30]],2);
结果
[[1,1,2,3],[4,5,1,2]]
将 clear_depth=2 更改为会导致枚举分别为每一行重新进行。
查询
SELECT arrayEnumerateDenseRanked(2,[[10,10,30,20],[40,50,10,30]],2);
结果
[[1,1,2,3],[1,2,3,4]]
arrayIntersect(arr)
接受多个数组，返回一个包含所有源数组中都存在的元素的数组。
示例
SELECT
arrayIntersect([1, 2], [1, 3], [2, 3]) AS no_intersect,
arrayIntersect([1, 2], [1, 3], [1, 4]) AS intersect
┌─no_intersect─┬─intersect─┐
│ [] │ [1] │
└──────────────┴───────────┘
arrayJaccardIndex
返回两个数组的Jaccard 指数。
示例
查询
SELECT arrayJaccardIndex([1, 2], [2, 3]) AS res
结果
┌─res────────────────┐
│ 0.3333333333333333 │
└────────────────────┘
arrayReduce
对数组元素应用聚合函数并返回其结果。聚合函数的名称以字符串形式在单引号 'max'、'sum' 中传递。使用参数化聚合函数时，参数在函数名称后的括号 'uniqUpTo(6)' 中指示。
语法
arrayReduce(agg_func, arr1, arr2, ..., arrN)
参数
返回值
示例
查询
SELECT arrayReduce('max', [1, 2, 3]);
结果
┌─arrayReduce('max', [1, 2, 3])─┐
│ 3 │
└───────────────────────────────┘
如果聚合函数接受多个参数，则此函数必须应用于多个大小相同的数组。
查询
SELECT arrayReduce('maxIf', [3, 5], [1, 0]);
结果
┌─arrayReduce('maxIf', [3, 5], [1, 0])─┐
│ 3 │
└──────────────────────────────────────┘
参数化聚合函数示例
查询
SELECT arrayReduce('uniqUpTo(3)', [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
结果
┌─arrayReduce('uniqUpTo(3)', [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])─┐
│ 4 │
└─────────────────────────────────────────────────────────────┘
另请参阅
arrayReduceInRanges
将聚合函数应用于给定范围内的数组元素，并返回一个数组，其中包含与每个范围相对应的结果。该函数将返回与多个 arrayReduce(agg_func, arraySlice(arr1, index, length), ...) 相同的结果。
语法
arrayReduceInRanges(agg_func, ranges, arr1, arr2, ..., arrN)
参数
agg_func— 聚合函数的名称，它应该是一个常量 字符串。ranges- 要聚合的范围，它应该是一个包含每个范围的索引和长度的 数组 的 元组。arr- 作为聚合函数参数的任意数量的 数组 类型列。
返回值
- 包含指定范围内聚合函数结果的数组。
类型：数组。
示例
查询
SELECT arrayReduceInRanges(
'sum',
[(1, 5), (2, 3), (3, 4), (4, 4)],
[1000000, 200000, 30000, 4000, 500, 60, 7]
) AS res
结果
┌─res─────────────────────────┐
│ [1234500,234000,34560,4567] │
└─────────────────────────────┘
arrayFold
将 lambda 函数应用于一个或多个大小相等的数组，并将结果收集到一个累加器中。
语法
arrayFold(lambda_function, arr1, arr2, ..., accumulator)
示例
查询
SELECT arrayFold( acc,x -> acc + x*2, [1, 2, 3, 4], toInt64(3)) AS res;
结果
┌─res─┐
│ 23 │
└─────┘
斐波那契数列示例
SELECT arrayFold( acc,x -> (acc.2, acc.2 + acc.1), range(number), (1::Int64, 0::Int64)).1 AS fibonacci
FROM numbers(1,10);
┌─fibonacci─┐
│ 0 │
│ 1 │
│ 1 │
│ 2 │
│ 3 │
│ 5 │
│ 8 │
│ 13 │
│ 21 │
│ 34 │
└───────────┘
另请参阅
arrayReverse(arr)
返回一个与原始数组大小相同的数组，其中包含按相反顺序排列的元素。
示例
SELECT arrayReverse([1, 2, 3])
┌─arrayReverse([1, 2, 3])─┐
│ [3,2,1] │
└─────────────────────────┘
reverse(arr)
“arrayReverse” 的同义词
arrayFlatten
将数组数组转换为扁平数组。
函数
- 适用于任何深度的嵌套数组。
- 不会更改已经是扁平数组的数组。
扁平化数组包含所有源数组中的所有元素。
语法
flatten(array_of_arrays)
别名：flatten。
参数
array_of_arrays- 数组 的数组。例如，[[1,2,3], [4,5]]。
示例
SELECT flatten([[[1]], [[2], [3]]]);
┌─flatten(array(array([1]), array([2], [3])))─┐
│ [1,2,3] │
└─────────────────────────────────────────────┘
arrayCompact
从数组中删除连续的重复元素。结果值的顺序由源数组中的顺序确定。
语法
arrayCompact(arr)
参数
arr - 要检查的 数组。
返回值
没有重复元素的数组。
类型：Array。
示例
查询
SELECT arrayCompact([1, 1, nan, nan, 2, 3, 3, 3]);
结果
┌─arrayCompact([1, 1, nan, nan, 2, 3, 3, 3])─┐
│ [1,nan,nan,2,3] │
└────────────────────────────────────────────┘
arrayZip
将多个数组组合成一个数组。结果数组包含按列出的参数顺序分组为元组的源数组的对应元素。
语法
arrayZip(arr1, arr2, ..., arrN)
参数
arrN- 数组。
该函数可以接受任意数量的不同类型的数组。所有输入数组的大小必须相等。
返回值
- 包含来自源数组的元素的数组，这些元素被分组到 元组 中。元组中的数据类型与输入数组的类型相同，并且顺序与传递数组的顺序相同。
类型：数组。
示例
查询
SELECT arrayZip(['a', 'b', 'c'], [5, 2, 1]);
结果
┌─arrayZip(['a', 'b', 'c'], [5, 2, 1])─┐
│ [('a',5),('b',2),('c',1)] │
└──────────────────────────────────────┘
arrayAUC
计算 AUC（曲线下面积，这是机器学习中的一个概念，请参阅更多详细信息：https://en.wikipedia.org/wiki/Receiver_operating_characteristic#Area_under_the_curve）。
语法
arrayAUC(arr_scores, arr_labels)
参数
arr_scores- 预测模型给出的分数。arr_labels- 样本的标签，通常 1 表示正样本，0 表示负样本。
返回值
返回类型为 Float64 的 AUC 值。
示例
查询
select arrayAUC([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1]);
结果
┌─arrayAUC([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1])─┐
│ 0.75 │
└───────────────────────────────────────────────┘
arrayMap(func, arr1, …)
返回一个数组，该数组是通过对每个元素应用 func(arr1[i], …, arrN[i]) 从原始数组获得的。数组 arr1 … arrN 必须具有相同数量的元素。
示例
SELECT arrayMap(x -> (x + 2), [1, 2, 3]) as res;
┌─res─────┐
│ [3,4,5] │
└─────────┘
以下示例显示如何创建来自不同数组的元素元组
SELECT arrayMap((x, y) -> (x, y), [1, 2, 3], [4, 5, 6]) AS res
┌─res─────────────────┐
│ [(1,4),(2,5),(3,6)] │
└─────────────────────┘
请注意，arrayMap 是一个 高阶函数。您必须将 lambda 函数作为第一个参数传递给它，并且不能省略它。
arrayFilter(func, arr1, …)
返回一个数组，该数组仅包含 arr1 中的元素，其中 func(arr1[i], …, arrN[i]) 返回除 0 以外的内容。
示例
SELECT arrayFilter(x -> x LIKE '%World%', ['Hello', 'abc World']) AS res
┌─res───────────┐
│ ['abc World'] │
└───────────────┘
SELECT
arrayFilter(
(i, x) -> x LIKE '%World%',
arrayEnumerate(arr),
['Hello', 'abc World'] AS arr)
AS res
┌─res─┐
│ [2] │
└─────┘
请注意，arrayFilter 是一个 高阶函数。您必须将 lambda 函数作为第一个参数传递给它，并且不能省略它。
arrayFill(func, arr1, …)
从第一个元素到最后一个元素扫描 arr1，如果 func(arr1[i], …, arrN[i]) 返回 0，则将 arr1[i] 替换为 arr1[i - 1]。arr1 的第一个元素不会被替换。
示例
SELECT arrayFill(x -> not isNull(x), [1, null, 3, 11, 12, null, null, 5, 6, 14, null, null]) AS res
┌─res──────────────────────────────┐
│ [1,1,3,11,12,12,12,5,6,14,14,14] │
└──────────────────────────────────┘
请注意，arrayFill 是一个 高阶函数。您必须将 lambda 函数作为第一个参数传递给它，并且不能省略它。
arrayReverseFill(func, arr1, …)
从最后一个元素到第一个元素扫描 arr1，如果 func(arr1[i], …, arrN[i]) 返回 0，则将 arr1[i] 替换为 arr1[i + 1]。arr1 的最后一个元素不会被替换。
示例
SELECT arrayReverseFill(x -> not isNull(x), [1, null, 3, 11, 12, null, null, 5, 6, 14, null, null]) AS res
┌─res────────────────────────────────┐
│ [1,3,3,11,12,5,5,5,6,14,NULL,NULL] │
└────────────────────────────────────┘
请注意，arrayReverseFill 是一个 高阶函数。您必须将 lambda 函数作为第一个参数传递给它，并且不能省略它。
arraySplit(func, arr1, …)
将 arr1 拆分为多个数组。当 func(arr1[i], …, arrN[i]) 返回除 0 以外的内容时，数组将在元素的左侧拆分。数组不会在第一个元素之前拆分。
示例
SELECT arraySplit((x, y) -> y, [1, 2, 3, 4, 5], [1, 0, 0, 1, 0]) AS res
┌─res─────────────┐
│ [[1,2,3],[4,5]] │
└─────────────────┘
请注意，arraySplit 是一个 高阶函数。您必须将 lambda 函数作为第一个参数传递给它，并且不能省略它。
arrayReverseSplit(func, arr1, …)
将 arr1 拆分为多个数组。当 func(arr1[i], …, arrN[i]) 返回除 0 以外的内容时，数组将在元素的右侧拆分。数组不会在最后一个元素之后拆分。
示例
SELECT arrayReverseSplit((x, y) -> y, [1, 2, 3, 4, 5], [1, 0, 0, 1, 0]) AS res
┌─res───────────────┐
│ [[1],[2,3,4],[5]] │
└───────────────────┘
请注意，arrayReverseSplit 是一个 高阶函数。您必须将 lambda 函数作为第一个参数传递给它，并且不能省略它。
arrayExists([func,]arr1, …)
如果 arr 中至少有一个元素，其中 func(arr1[i], …, arrN[i]) 返回除 0 以外的内容，则返回 1。否则，返回 0。
请注意，arrayExists 是一个 高阶函数。您可以将 lambda 函数作为第一个参数传递给它。
arrayAll([func,]arr1, …)
如果 func(arr1[i], …, arrN[i]) 对数组中的所有元素都返回除 0 以外的内容，则返回 1。否则，返回 0。
请注意，arrayAll 是一个 高阶函数。您可以将 lambda 函数作为第一个参数传递给它。
arrayFirst(func, arr1, …)
返回 arr1 数组中第一个元素，其中 func(arr1[i], …, arrN[i]) 返回除 0 以外的内容。
arrayFirstOrNull
返回 arr1 数组中第一个元素，其中 func(arr1[i], …, arrN[i]) 返回除 0 以外的内容，否则返回 NULL。
语法
arrayFirstOrNull(func, arr1, …)
参数
返回值
- 传递数组中的第一个元素。
- 否则，返回
NULL
实现细节
请注意，arrayFirstOrNull 是一个 高阶函数。您必须将 lambda 函数作为第一个参数传递给它，并且不能省略它。
示例
查询
SELECT arrayFirstOrNull(x -> x >= 2, [1, 2, 3]);
结果
2
查询
SELECT arrayFirstOrNull(x -> x >= 2, emptyArrayUInt8());
结果
\N
查询
SELECT arrayLastOrNull((x,f) -> f, [1,2,3,NULL], [0,1,0,1]);
结果
\N
arrayLast(func, arr1, …)
返回 arr1 数组中最后一个元素，其中 func(arr1[i], …, arrN[i]) 返回除 0 以外的内容。
请注意，arrayLast 是一个 高阶函数。您必须将 lambda 函数作为第一个参数传递给它，并且不能省略它。
arrayLastOrNull
返回 arr1 数组中最后一个元素，其中 func(arr1[i], …, arrN[i]) 返回除 0 以外的内容，否则返回 NULL。
语法
arrayLastOrNull(func, arr1, …)
参数
返回值
- 传递数组中的最后一个元素。
- 否则，返回
NULL
实现细节
请注意，arrayLastOrNull 是一个 高阶函数。您必须将 lambda 函数作为第一个参数传递给它，并且不能省略它。
示例
查询
SELECT arrayLastOrNull(x -> x >= 2, [1, 2, 3]);
结果
3
查询
SELECT arrayLastOrNull(x -> x >= 2, emptyArrayUInt8());
结果
\N
arrayFirstIndex(func, arr1, …)
返回 arr1 数组中第一个元素的索引，其中 func(arr1[i], …, arrN[i]) 返回除 0 以外的内容。
请注意，arrayFirstIndex 是一个 高阶函数。您必须将 lambda 函数作为第一个参数传递给它，并且不能省略它。
arrayLastIndex(func, arr1, …)
返回 arr1 数组中最后一个元素的索引，其中 func(arr1[i], …, arrN[i]) 返回除 0 以外的内容。
请注意，arrayLastIndex 是一个 高阶函数。您必须将 lambda 函数作为第一个参数传递给它，并且不能省略它。
arrayMin
返回源数组中元素的最小值。
如果指定了 func 函数，则返回由此函数转换的元素的最小值。
请注意，arrayMin 是一个 高阶函数。您可以将 lambda 函数作为第一个参数传递给它。
语法
arrayMin([func,] arr)
参数
返回值
- 函数值的最小值（或数组最小值）。
类型：如果指定了 func，则匹配 func 返回值类型，否则匹配数组元素类型。
示例
查询
SELECT arrayMin([1, 2, 4]) AS res;
结果
┌─res─┐
│ 1 │
└─────┘
查询
SELECT arrayMin(x -> (-x), [1, 2, 4]) AS res;
结果
┌─res─┐
│ -4 │
└─────┘
arrayMax
返回源数组中元素的最大值。
如果指定了 func 函数，则返回由此函数转换的元素的最大值。
请注意，arrayMax 是一个 高阶函数。您可以将 lambda 函数作为第一个参数传递给它。
语法
arrayMax([func,] arr)
参数
返回值
- 函数值的最大值（或数组最大值）。
类型：如果指定了 func，则匹配 func 返回值类型，否则匹配数组元素类型。
示例
查询
SELECT arrayMax([1, 2, 4]) AS res;
结果
┌─res─┐
│ 4 │
└─────┘
查询
SELECT arrayMax(x -> (-x), [1, 2, 4]) AS res;
结果
┌─res─┐
│ -1 │
└─────┘
arraySum
返回源数组中元素的总和。
如果指定了 func 函数，则返回此函数转换后的元素的总和。
请注意，arraySum 是一个高阶函数。您可以将 lambda 函数作为第一个参数传递给它。
语法
arraySum([func,] arr)
参数
返回值
- 函数值的总和（或数组总和）。
类型：对于源数组中的十进制数（或转换后的值，如果指定了 func） - Decimal128，对于浮点数 - Float64，对于无符号整数 - UInt64，对于有符号整数 - Int64。
示例
查询
SELECT arraySum([2, 3]) AS res;
结果
┌─res─┐
│ 5 │
└─────┘
查询
SELECT arraySum(x -> x*x, [2, 3]) AS res;
结果
┌─res─┐
│ 13 │
└─────┘
arrayAvg
返回源数组中元素的平均值。
如果指定了 func 函数，则返回此函数转换后的元素的平均值。
请注意，arrayAvg 是一个高阶函数。您可以将 lambda 函数作为第一个参数传递给它。
语法
arrayAvg([func,] arr)
参数
返回值
- 函数值的平均值（或数组平均值）。
类型：Float64。
示例
查询
SELECT arrayAvg([1, 2, 4]) AS res;
结果
┌────────────────res─┐
│ 2.3333333333333335 │
└────────────────────┘
查询
SELECT arrayAvg(x -> (x * x), [2, 4]) AS res;
结果
┌─res─┐
│ 10 │
└─────┘
arrayCumSum([func,]arr1, …)
返回源数组 arr1 中元素的部分（运行）总和的数组。如果指定了 func，则总和是通过将 func 应用于 arr1、arr2、...、arrN 来计算的，即 func(arr1[i], …, arrN[i])。
语法
arrayCumSum(arr)
参数
arr- 数组，包含数值。
返回值
- 返回源数组中元素的部分总和的数组。
示例
SELECT arrayCumSum([1, 1, 1, 1]) AS res
┌─res──────────┐
│ [1, 2, 3, 4] │
└──────────────┘
请注意，arrayCumSum 是一个高阶函数。您可以将 lambda 函数作为第一个参数传递给它。
arrayCumSumNonNegative([func,]arr1, …)
与 arrayCumSum 相同，返回源数组中元素的部分（运行）总和的数组。如果指定了 func，则总和是通过将 func 应用于 arr1、arr2、...、arrN 来计算的，即 func(arr1[i], …, arrN[i])。与 arrayCumSum 不同，如果当前运行总和小于 0，则将其替换为 0。
语法
arrayCumSumNonNegative(arr)
参数
arr- 数组，包含数值。
返回值
- 返回源数组中元素的非负部分总和的数组。
SELECT arrayCumSumNonNegative([1, 1, -4, 1]) AS res
┌─res───────┐
│ [1,2,0,1] │
└───────────┘
请注意，arraySumNonNegative 是一个高阶函数。您可以将 lambda 函数作为第一个参数传递给它。
arrayProduct
将 数组 的元素相乘。
语法
arrayProduct(arr)
参数
arr- 数组，包含数值。
返回值
- 数组元素的乘积。
类型：Float64。
示例
查询
SELECT arrayProduct([1,2,3,4,5,6]) as res;
结果
┌─res───┐
│ 720 │
└───────┘
查询
SELECT arrayProduct([toDecimal64(1,8), toDecimal64(2,8), toDecimal64(3,8)]) as res, toTypeName(res);
返回值类型始终为 Float64。结果
┌─res─┬─toTypeName(arrayProduct(array(toDecimal64(1, 8), toDecimal64(2, 8), toDecimal64(3, 8))))─┐
│ 6 │ Float64 │
└─────┴──────────────────────────────────────────────────────────────────────────────────────────┘
arrayRotateLeft
将 数组 向左旋转指定的元素数量。如果元素数量为负数，则数组向右旋转。
语法
arrayRotateLeft(arr, n)
参数
arr- 数组。n- 要旋转的元素数量。
返回值
- 向左旋转指定元素数量的数组。
类型：数组。
示例
查询
SELECT arrayRotateLeft([1,2,3,4,5,6], 2) as res;
结果
┌─res───────────┐
│ [3,4,5,6,1,2] │
└───────────────┘
查询
SELECT arrayRotateLeft([1,2,3,4,5,6], -2) as res;
结果
┌─res───────────┐
│ [5,6,1,2,3,4] │
└───────────────┘
查询
SELECT arrayRotateLeft(['a','b','c','d','e'], 3) as res;
结果
┌─res───────────────────┐
│ ['d','e','a','b','c'] │
└───────────────────────┘
arrayRotateRight
将 数组 向右旋转指定的元素数量。如果元素数量为负数，则数组向左旋转。
语法
arrayRotateRight(arr, n)
参数
arr- 数组。n- 要旋转的元素数量。
返回值
- 向右旋转指定元素数量的数组。
类型：数组。
示例
查询
SELECT arrayRotateRight([1,2,3,4,5,6], 2) as res;
结果
┌─res───────────┐
│ [5,6,1,2,3,4] │
└───────────────┘
查询
SELECT arrayRotateRight([1,2,3,4,5,6], -2) as res;
结果
┌─res───────────┐
│ [3,4,5,6,1,2] │
└───────────────┘
查询
SELECT arrayRotateRight(['a','b','c','d','e'], 3) as res;
结果
┌─res───────────────────┐
│ ['c','d','e','a','b'] │
└───────────────────────┘
arrayShiftLeft
将 数组 向左移动指定的元素数量。新元素将填充提供的参数或数组元素类型的默认值。如果元素数量为负数，则数组向右移动。
语法
arrayShiftLeft(arr, n[, default])
参数
arr- 数组。n- 要移动的元素数量。default- 可选。新元素的默认值。
返回值
- 向左移动指定元素数量的数组。
类型：数组。
示例
查询
SELECT arrayShiftLeft([1,2,3,4,5,6], 2) as res;
结果
┌─res───────────┐
│ [3,4,5,6,0,0] │
└───────────────┘
查询
SELECT arrayShiftLeft([1,2,3,4,5,6], -2) as res;
结果
┌─res───────────┐
│ [0,0,1,2,3,4] │
└───────────────┘
查询
SELECT arrayShiftLeft([1,2,3,4,5,6], 2, 42) as res;
结果
┌─res─────────────┐
│ [3,4,5,6,42,42] │
└─────────────────┘
查询
SELECT arrayShiftLeft(['a','b','c','d','e','f'], 3, 'foo') as res;
结果
┌─res─────────────────────────────┐
│ ['d','e','f','foo','foo','foo'] │
└─────────────────────────────────┘
查询
SELECT arrayShiftLeft([1,2,3,4,5,6] :: Array(UInt16), 2, 4242) as res;
结果
┌─res─────────────────┐
│ [3,4,5,6,4242,4242] │
└─────────────────────┘
arrayShiftRight
将 数组 向右移动指定的元素数量。新元素将填充提供的参数或数组元素类型的默认值。如果元素数量为负数，则数组向左移动。
语法
arrayShiftRight(arr, n[, default])
参数
arr- 数组。n- 要移动的元素数量。default- 可选。新元素的默认值。
返回值
- 向右移动指定元素数量的数组。
类型：数组。
示例
查询
SELECT arrayShiftRight([1,2,3,4,5,6], 2) as res;
结果
┌─res───────────┐
│ [0,0,1,2,3,4] │
└───────────────┘
查询
SELECT arrayShiftRight([1,2,3,4,5,6], -2) as res;
结果
┌─res───────────┐
│ [3,4,5,6,0,0] │
└───────────────┘
查询
SELECT arrayShiftRight([1,2,3,4,5,6], 2, 42) as res;
结果
┌─res─────────────┐
│ [42,42,1,2,3,4] │
└─────────────────┘
查询
SELECT arrayShiftRight(['a','b','c','d','e','f'], 3, 'foo') as res;
结果
┌─res─────────────────────────────┐
│ ['foo','foo','foo','a','b','c'] │
└─────────────────────────────────┘
查询
SELECT arrayShiftRight([1,2,3,4,5,6] :: Array(UInt16), 2, 4242) as res;
结果
┌─res─────────────────┐
│ [4242,4242,1,2,3,4] │
└─────────────────────┘
arrayRandomSample
函数 arrayRandomSample 返回输入数组中包含 samples 个随机元素的子集。如果 samples 超过输入数组的大小，则样本大小将限制为数组的大小，即返回所有数组元素，但不保证其顺序。该函数可以处理平面数组和嵌套数组。
语法
arrayRandomSample(arr, samples)
参数
返回值
- 包含输入数组中随机样本元素的数组。
类型：数组。
示例
查询
SELECT arrayRandomSample(['apple', 'banana', 'cherry', 'date'], 2) as res;
结果
┌─res────────────────┐
│ ['cherry','apple'] │
└────────────────────┘
查询
SELECT arrayRandomSample([[1, 2], [3, 4], [5, 6]], 2) as res;
结果
┌─res───────────┐
│ [[3,4],[5,6]] │
└───────────────┘
查询
SELECT arrayRandomSample([1, 2, 3], 5) as res;
结果
┌─res─────┐
│ [3,1,2] │
└─────────┘
距离函数
所有支持的函数都在距离函数文档中进行了描述。