数组函数
empty
检查输入数组是否为空。
语法
如果数组不包含任何元素，则认为该数组为空。
可以通过启用 optimize_functions_to_subcolumns 设置来优化。若 optimize_functions_to_subcolumns = 1，函数只读取 size0 子列，而不是读取和处理整个数组列。查询 SELECT empty(arr) FROM TABLE; 转换为 SELECT arr.size0 = 0 FROM TABLE;。
参数
[x]— 输入数组。 Array。
返回值
- 对于空数组返回
1，对于非空数组返回0。 UInt8。
示例
查询：
结果：
notEmpty
检查输入数组是否非空。
语法
如果数组至少包含一个元素，则认为该数组为非空。
可以通过启用 optimize_functions_to_subcolumns 设置来优化。若 optimize_functions_to_subcolumns = 1，该函数只读取 size0 子列，而不是读取和处理整个数组列。查询 SELECT notEmpty(arr) FROM table 转换为 SELECT arr.size0 != 0 FROM TABLE。
参数
[x]— 输入数组。 Array。
返回值
- 对于非空数组返回
1，对于空数组返回0。 UInt8。
示例
查询：
结果：
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 数组。
语法
参数
无。
返回值
一个空数组。
示例
查询：
结果：
emptyArrayUInt16
返回一个空的 UInt16 数组。
语法
参数
无。
返回值
一个空数组。
示例
查询：
结果：
emptyArrayUInt32
返回一个空的 UInt32 数组。
语法
参数
无。
返回值
一个空数组。
示例
查询：
结果：
emptyArrayUInt64
返回一个空的 UInt64 数组。
语法
参数
无。
返回值
一个空数组。
示例
查询：
结果：
emptyArrayInt8
返回一个空的 Int8 数组。
语法
参数
无。
返回值
一个空数组。
示例
查询：
结果：
emptyArrayInt16
返回一个空的 Int16 数组。
语法
参数
无。
返回值
一个空数组。
示例
查询：
结果：
emptyArrayInt32
返回一个空的 Int32 数组。
语法
参数
无。
返回值
一个空数组。
示例
查询：
结果：
emptyArrayInt64
返回一个空的 Int64 数组。
语法
参数
无。
返回值
一个空数组。
示例
查询：
结果：
emptyArrayFloat32
返回一个空的 Float32 数组。
语法
参数
无。
返回值
一个空数组。
示例
查询：
结果：
emptyArrayFloat64
返回一个空的 Float64 数组。
语法
参数
无。
返回值
一个空数组。
示例
查询：
结果：
emptyArrayDate
返回一个空的 Date 数组。
语法
参数
无。
返回值
一个空数组。
示例
查询：
emptyArrayDateTime
返回一个空的 DateTime 数组。
语法
参数
无。
返回值
一个空数组。
示例
查询：
结果：
emptyArrayString
返回一个空的 String 数组。
语法
参数
无。
返回值
一个空数组。
示例
查询：
结果：
emptyArrayToSingle
接受一个空数组并返回一个等于默认值的单元素数组。
range(end), range([start, ] end [, step])
返回从 start 到 end - 1 的数字数组，步长为 step。支持的类型有 UInt8, UInt16, UInt32, UInt64, Int8, Int16, Int32, Int64。
语法
参数
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) 类型)，将抛出异常。
示例
查询：
结果：
array(x1, ...), operator [x1, ...]
从函数参数创建一个数组。 参数必须是常量且具有最小的公共类型。必须至少传递一个参数，因为否则不清楚要创建哪种类型的数组。也就是说，您不能使用此函数创建一个空数组（要做到这一点，请使用上面描述的 'emptyArray*' 函数）。 返回 'Array(T)' 类型的结果，其中 'T' 是所传参数的最小公共类型。
arrayWithConstant(length, elem)
创建一个长度为 length 的数组，填充常量 elem。
arrayConcat
将作为参数传递的数组组合在一起。
参数
arrays– 任意数量的 Array 类型的参数。
示例
arrayElement(arr, n), operator arr[n]
从数组 arr 中获取索引为 n 的元素。 n 必须是任何整数类型。
数组中的索引从一开始。
支持负索引。在这种情况下，它选择从末尾开始编号的相应元素。例如，arr[-1] 是数组中的最后一项。
如果索引超出了数组的边界，则返回一些默认值（数字为 0，字符串为空字符串等），但是对于非常量数组和常量索引为 0 的情况（在这种情况下将出现错误 Array indices are 1-based）除外。
has(arr, elem)
检查数组 'arr' 是否包含元素 'elem'。 如果元素不在数组中返回 0，若在则返回 1。
NULL 被处理为一个值。
arrayElementOrNull(arr, n)
从数组 arr 中获取索引为 n 的元素。 n 必须是任何整数类型。
数组中的索引从一开始。
支持负索引。在这种情况下，它选择从末尾开始编号的相应元素。例如，arr[-1] 是数组中的最后一项。
如果索引超出了数组的边界，则返回 NULL，而不是默认值。
示例
hasAll
检查一个数组是否是另一个数组的子集。
参数
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
检查两个数组是否有某些元素的交集。
参数
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
检查数组2的所有元素是否以相同的确切顺序出现在数组1中。因此，该函数将返回 1，仅当且仅当 array1 = prefix + array2 + suffix。
换句话说，这个函数将检查 array2 的所有元素是否包含在 array1 中，就像 hasAll 函数一样。此外，它还将检查这些元素在 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。
示例：
设置为 NULL 的元素被视为正常值处理。
indexOfAssumeSorted(arr, x)
返回值为 'x' 的第一个元素的索引（从 1 开始），如果它在数组中。 如果数组不包含所搜索的值，则该函数返回 0。 假定数组按升序排列（即，该函数使用二分查找）。 如果数组未排序，则结果是未定义的。 如果内部数组的类型为 Nullable，则将调用函数 'indexOf'。
示例：
arrayCount([func,] arr1, ...)
返回 func(arr1[i], ..., arrN[i]) 返回非零的元素数量。如果未指定 func，则返回数组中非零元素的数量。
请注意，arrayCount 是一个 高阶函数。您可以将一个 lambda 函数作为第一个参数传递给它。
arrayDotProduct
返回两个数组的点积。
语法
别名: scalarProduct, dotProduct
参数
两个向量的大小必须相等。数组和元组也可以包含混合元素类型。
返回值
- 两个向量的点积。 Numeric。
返回类型由参数类型决定。如果数组或元组包含混合元素类型，则结果类型为超类型。
示例
查询：
结果：
查询：
结果：
countEqual(arr, x)
返回数组中等于 x 的元素数量。等同于 arrayCount (elem -> elem = x, arr)。
NULL 元素被视为单独的值。
示例：
arrayEnumerate(arr)
返回数组 [1, 2, 3, ..., length (arr) ]
此函数通常与 ARRAY JOIN 一起使用。它允许对每个数组进行计数，仅在应用 ARRAY JOIN 后计数一次。例如：
在这个例子中，Reaches 是转换后的数量（在应用 ARRAY JOIN 后收到的字符串），而 Hits 是页面浏览量（在应用 ARRAY JOIN 之前的字符串）。在此特定情况下，您也可以以更简单的方式获得相同的结果：
该函数也可以在高阶函数中使用。例如，您可以使用它来获取与特定条件匹配的元素的数组索引。
arrayEnumerateUniq
返回一个与源数组相同大小的数组，指示每个元素在具有相同值的元素中的位置。 例如： arrayEnumerateUniq([10, 20, 10, 30]) = [1, 1, 2, 1]。
该函数在使用 ARRAY JOIN 和数组元素聚合时很有用。 示例：
在这个例子中，每个目标 ID 都计算了转换的数量（在 Goals 嵌套数据结构中的每个元素是达到的目标，我们称之为转换）和会话的数量。在没有使用 ARRAY JOIN 的情况下，我们会将会话的数量计算为 sum(Sign)。但在这种情况下，行被嵌套 Goals 结构乘以，因此为了在此之后计算每个会话，我们应用了 arrayEnumerateUniq(Goals.ID) 函数的值的条件。
arrayEnumerateUniq 函数可以将多个相同大小的数组作为参数传递。在这种情况下，唯一性将被认为是所有数组中相同位置的元素的元组。
在使用包含嵌套数据结构的 ARRAY JOIN 和进一步聚合多个元素时，这是必要的。
arrayEnumerateUniqRanked
返回一个与源数组相同大小的数组，指示每个元素在具有相同值的元素中的位置。它允许对多维数组进行枚举，并能够指定深入查找数组的程度。
语法
参数
clear_depth: 在指定级别单独枚举元素。正整数（Integer），小于或等于max_arr_depth。arr: 要枚举的 N 维数组。 Array。max_array_depth: 最大有效深度。正整数（Integer），小于或等于arr的深度。
示例
设置 clear_depth=1 和 max_array_depth=1，arrayEnumerateUniqRanked 的结果与 arrayEnumerateUniq 对同一数组的结果相同。
查询：
结果：
在这个例子中，arrayEnumerateUniqRanked 用于获取一个数组，指示每个多维数组的元素在相同值的元素中的位置。对于传入的数组的第一行[1,2,3]，对应结果为[1,1,1]，表示这是 1、2 和 3 第一次被遇到。对于提供的数组第二行[2,2,1]，对应结果为[2,3,3]，表示 2 被遇到第二次和第三次，而 1 被遇到第二次。同样，对于提供的数组第三行[3]，对应的结果为[2]，表明 3 被遇到第二次。
查询：
结果：
更改 clear_depth=2，结果为每行分别枚举元素。
查询：
结果：
arrayPopBack
从数组中移除最后一个项。
参数
array– 数组。
示例
arrayPopFront
从数组中移除第一个项。
参数
array– 数组。
示例
arrayPushBack
向数组末尾添加一个项。
参数
array– 数组。single_value– 单个值。只有数字可以添加到数字数组中，只有字符串可以添加到字符串数组中。在添加数字时，ClickHouse 会自动为single_value设置数组的数据类型。有关 ClickHouse 中数据类型的信息，请参见 "数据类型"。可以是NULL。该函数向数组中添加NULL元素，并且数组元素类型转换为Nullable。
示例
arrayPushFront
向数组开头添加一个元素。
参数
array– 数组。single_value– 单个值。只有数字可以添加到数字数组中，只有字符串可以添加到字符串数组中。在添加数字时，ClickHouse 会自动为single_value设置数组的数据类型。有关 ClickHouse 中数据类型的信息，请参见 "数据类型"。可以是NULL。该函数向数组中添加NULL元素，并且数组元素类型转换为Nullable。
示例
arrayResize
更改数组的长度。
参数:
array— 数组。size— 数组所需的长度。- 如果
size小于数组的原始大小，则数组将从右侧截断。
- 如果
- 如果
size大于数组的初始大小，则数组将用extender值或该数组项数据类型的默认值向右扩展。 extender— 扩展数组的值。可以是NULL。
返回值:
长度为 size 的数组。
调用示例
arraySlice
返回数组的切片。
参数
array– 数据数组。offset– 从数组边缘的缩进值。正值表示从左侧偏移，负值表示从右侧偏移。数组项目的编号从 1 开始。length– 所需切片的长度。如果指定负值，则该函数返回开放切片[offset, array_length - length]。如果省略该值，则函数返回切片[offset, the_end_of_array]。
示例
设置为 NULL 的数组元素被视为正常值处理。
arrayShingles
生成一组 "shingles" 数组，即具有指定长度的输入数组的连续子数组。
语法
参数
array— 输入数组 Array。length— 每个 shingle 的长度。
返回值
- 生成的 shingle 数组。 Array。
示例
查询：
结果：
arraySort([func,] arr, ...)
对 arr 数组的元素按升序排序。如果指定了 func 函数，则排序顺序由应用于数组元素的 func 函数的结果决定。如果 func 接受多个参数，则 arraySort 函数将传入多个数组，这些数组将对应于 func 的参数。详细示例在 arraySort 描述的末尾列出。
整数值排序的示例：
字符串值排序的示例：
考虑以下 NULL、NaN 和 Inf 值的排序顺序：
-Inf值在数组的最前面。NULL值在数组的最后面。NaN值在NULL之前。Inf值在NaN之前。
注意 arraySort 是一个 高阶函数。您可以将 lambda 函数作为第一个参数传递给它。在这种情况下，排序顺序由应用于数组元素的 lambda 函数的结果决定。
让我们考虑以下示例：
对于源数组的每个元素，lambda 函数返回排序键，即 [1 –> -1, 2 –> -2, 3 –> -3]。由于 arraySort 函数以升序对键进行排序，因此结果为 [3, 2, 1]。因此，(x) –> -x lambda 函数在排序中设置了 降序。
lambda 函数可以接受多个参数。在这种情况下，您需要将 arraySort 函数传递多个相同长度的数组，这些数组将对应于 lambda 函数的参数。结果数组将由第一个输入数组的元素组成；下一个输入数组的元素指定排序键。例如：
在这里，传递到第二个数组中的元素（[2, 1]）定义了来自源数组（['hello', 'world']）的相应元素的排序键，即 ['hello' –> 2, 'world' –> 1]。由于 lambda 函数未使用 x，源数组的实际值不会影响结果的顺序。因此，'hello' 将是结果中的第二个元素，而 'world' 将是第一个。
其他示例在下面显示。
为了提高排序效率，使用 Schwartzian 变换。
arrayPartialSort([func,] limit, arr, ...)
与 arraySort 相同，额外的 limit 参数允许部分排序。返回一个与原始数组大小相同的数组，其中范围为 [1..limit] 的元素按升序排序。其余元素 (limit..N] 应包含未指定顺序的元素。
arrayReverseSort
将 arr 数组的元素按降序排序。如果指定了 func 函数，则 arr 根据应用于数组元素的 func 函数的结果进行排序，然后对排序后的数组进行反转。如果 func 接受多个参数，则 arrayReverseSort 函数将传入多个数组，这些数组将对应于 func 的参数。详细示例在 arrayReverseSort 描述的末尾列出。
语法
整数值排序的示例：
字符串值排序的示例：
考虑以下 NULL、NaN 和 Inf 值的排序顺序：
Inf值在数组的最前面。NULL值在数组的最后面。NaN值在NULL之前。-Inf值在NaN之前。
注意 arrayReverseSort 是一个 高阶函数。您可以将 lambda 函数作为第一个参数传递给它。示例如下所示。
数组的排序方式如下：
- 首先，源数组（[1, 2, 3]）根据应用于数组元素的 lambda 函数的结果进行排序。结果是数组 [3, 2, 1]。
- 在上一步中获得的数组被反转。因此，最终结果为 [1, 2, 3]。
lambda 函数可以接受多个参数。在这种情况下，您需要将 arrayReverseSort 函数传递多个相同长度的数组，这些数组将对应于 lambda 函数的参数。结果数组将由第一个输入数组的元素组成；下一个输入数组的元素指定排序键。例如：
在这个例子中，数组的排序方式如下：
- 首先，源数组（['hello', 'world']）根据应用于数组元素的 lambda 函数的结果进行排序。传递到第二个数组中的元素（[2, 1]）定义了来自源数组的相应元素的排序键。结果是数组 ['world', 'hello']。
- 在上一步中排序的数组被反转。因此，最终结果是 ['hello', 'world']。
其他示例在下面显示。
arrayPartialReverseSort([func,] limit, arr, ...)
与 arrayReverseSort 相同，额外的 limit 参数允许部分排序。返回一个与原始数组大小相同的数组，其中范围 [1..limit] 的元素按降序排序。其余元素 (limit..N] 应包含未指定顺序的元素。
arrayShuffle
返回一个与原始数组大小相同的数组，其中包含 shuffled 顺序的元素。元素的重新排序方式使得这些元素的每种可能排列具有相等的出现概率。
语法
参数
arr：要部分洗牌的数组。 Array。seed（可选）：随机数生成时使用的种子。如果未提供，则使用随机生成。 UInt 或 Int。
返回值
- 带有洗牌元素的数组。
实现细节
此函数不会对常量进行物化。
示例
在这个例子中，arrayShuffle 在未提供 seed 的情况下使用，因此将随机生成一个 seed。
查询：
注意：在使用 ClickHouse Fiddle 时，由于该函数的随机性，确切的响应可能会有所不同。
结果：
在这个例子中，arrayShuffle 提供了一个 seed，从而产生稳定的结果。
查询：
结果：
arrayPartialShuffle
给定一个基数为 N 的输入数组，返回一个大小为 N 的数组，其中范围 [1...limit] 的元素被洗牌，范围 (limit...n] 的其余元素未被洗牌。
语法
参数
arr：要部分洗牌的大小为N的数组。 Array。limit（可选）：在范围[1..N]中限制元素交换的数量。UInt 或 Int。seed（可选）：用于随机数生成的种子值。如果未提供，则使用随机生成。UInt 或 Int
返回值
- 带有部分洗牌元素的数组。
实现细节
示例
注意：在使用 ClickHouse Fiddle 时，由于该函数的随机性，确切的响应可能会有所不同。
查询：
结果：
元素的顺序保持不变（[2,3,4,5], [7,8,9,10]），除了两个被洗牌的元素 [1, 6]。未提供 seed，所以函数随机选择了。
在这个例子中，limit 增加到 2 并提供了一个 seed 值。顺序
查询：
元素的顺序保持不变（[4, 5, 6, 7, 8], [10]），除了四个被洗牌的元素 [1, 2, 3, 9]。
结果：
arrayUniq(arr, ...)
如果传入一个参数，则计算数组中不同元素的数量。如果传入多个参数，则计算多个数组中对应位置元素的不同元组的数量。
如果你想获得数组中的唯一项目列表，可以使用 arrayReduce('groupUniqArray', arr)。
arrayJoin(arr)
一个特殊函数。请参见 "ArrayJoin function" 部分。
arrayDifference
计算相邻数组元素之间的差异数组。结果数组的第一个元素将为 0，第二个 a[1] - a[0]，第三个 a[2] - a[1]，依此类推。结果数组中元素的类型由减法的类型推断规则决定（例如 UInt8 - UInt8 = Int16）。
语法
参数
array– Array。
返回值
返回相邻数组元素之间的差异数组。 UInt*， Int*， Float*。
示例
查询：
结果：
由于结果类型为 Int64 的溢出示例：
查询：
结果：
arrayDistinct
获取数组，返回仅包含不同元素的数组。
语法
参数
array– Array。
返回值
返回仅包含不同元素的数组。
示例
查询：
结果：
arrayEnumerateDense
返回一个与源数组大小相同的数组，指示每个元素在源数组中首次出现的位置。
语法
示例
查询：
结果：
arrayEnumerateDenseRanked
返回一个与源数组大小相同的数组，指示每个元素在源数组中首次出现的位置。它允许对多维数组进行枚举，并能够指定查找内部数组的深度。
语法
参数
clear_depth：分别在指定层次的清晰枚举。正整数 Integer，小于或等于max_arr_depth。arr：要枚举的 N 维数组。Array。max_array_depth：最大有效深度。正整数 Integer，小于或等于arr的深度。
示例
在 clear_depth=1 和 max_array_depth=1 的情况下，结果与 arrayEnumerateDense 的结果相同。
查询：
结果：
在这个示例中，arrayEnumerateDenseRanked 用于获取一个数组，指示对于多维数组的每个元素，同样值的元素的位置。对于传递数组的第一行 [10,10,30,20]，结果的对应第一行是 [1,1,2,3]，指示 10 在位置 1 和 2 中是遇到的第一个数字，30 是第三个数字，20 是第四个数字。对于第二行 [40, 50, 10, 30]，结果的对应第二行是 [4,5,1,2]，指出 40 和 50 分别是该行中遇到的第四和第五个数字，而另一个 10（遇到的第一个数字）在位置 3 中，30（遇到的第二个数字）在最后的位置。
查询：
结果：
将 clear_depth=2 更改将导致每一行新的单独枚举。
查询：
结果：
arrayUnion
接受多个数组并返回一个数组，该数组包含所有在一个或多个源数组中存在的元素。结果仅包含唯一值。
语法
参数
arrN— Array。
该函数可以接受任意数量的不同类型数组。
返回值
- 由源数组中的不同元素组成的 Array。
示例
查询：
结果：
arrayIntersect
接受多个数组并返回一个包含所有源数组中存在的元素的数组。结果仅包含唯一值。
语法
参数
arrN— Array。
该函数可以接受任意数量的不同类型数组。
返回值
- 包含所有源数组中存在的不同元素的 Array。
示例
查询：
结果：
arraySymmetricDifference
接受多个数组并返回一个包含在所有源数组中不存在的元素的数组。结果仅包含唯一值。
两个以上集合的对称差异在数学上定义为出现奇数次的所有输入元素的集合。相反，函数 arraySymmetricDifference 仅返回所有输入集合中不存在的输入元素的集合。
语法
参数
arrN— Array。
该函数可以接受任意数量的不同类型数组。
返回值
- 包含所有源数组中不存在的不同元素的 Array。
示例
查询：
结果：
arrayJaccardIndex
返回两个数组的 Jaccard 指数。
示例
查询：
结果：
arrayReduce
对数组元素应用聚合函数并返回其结果。聚合函数的名称作为字符串传递，使用单引号 'max'、'sum'。当使用参数聚合函数时，参数放在函数名称后面，用括号标示 'uniqUpTo(6)'。
语法
参数
返回值
示例
查询：
结果：
如果聚合函数接受多个参数，则必须对多个相同大小的数组应用此函数。
查询：
结果：
带有参数聚合函数的示例：
查询：
结果：
另见
arrayReduceInRanges
将聚合函数应用于给定范围的数组元素，并返回一个包含每个范围对应结果的数组。该函数将返回与多个 arrayReduce(agg_func, arraySlice(arr1, index, length), ...) 相同的结果。
语法
参数
agg_func— 应该是常量字符串 string 的聚合函数的名称。ranges— 所需聚合的范围，应该是包含每个范围的索引和长度的 array 的 tuples。arr— 作为聚合函数参数的任意数量的 Array 类型列。
返回值
- 包含指定范围的聚合函数结果的数组。 Array。
示例
查询：
结果：
arrayFold
将 lambda 函数应用于一个或多个等大小的数组，并在一个累加器中收集结果。
语法
示例
查询：
结果：
带有 Fibonacci 序列的示例
另见
arrayReverse
返回一个与原始数组大小相同的数组，其中包含元素的反向顺序。
语法
示例：
reverse(arr)
"arrayReverse" 的同义词。
arrayFlatten
将数组数组转换为扁平数组。
函数：
- 适用于任何深度的嵌套数组。
- 不更改已是扁平的数组。
扁平数组包含来自所有源数组的所有元素。
语法
别名：flatten。
参数
array_of_arrays— Array 的数组。例如，[[1,2,3], [4,5]]。
示例
arrayCompact
从数组中删除连续重复的元素。结果值的顺序由源数组中的顺序决定。
语法
参数
arr — 要检查的 array。
返回值
没有重复的数组。 Array。
示例
查询：
结果：
arrayZip
将多个数组组合成一个数组。结果数组包含源数组中对应元素按照参数列出的顺序分组为元组。
语法
参数
arrN— Array。
该函数可以接受任意数量的不同类型数组。所有输入数组必须具有相同的大小。
返回值
示例
查询：
结果：
arrayZipUnaligned
将多个数组组合成一个数组，允许不对齐的数组。结果数组中的元素是源数组中对应元素按参数列出的顺序分组为元组。
语法
参数
arrN— Array。
该函数可以接受任意数量的不同类型数组。
返回值
示例
查询：
结果：
arrayROCAUC
计算接收者操作特征（ROC）曲线下面积。 ROC 曲线是通过绘制真实正率（TPR）与假正率（FPR）在所有阈值上的关系而创建的。 结果值的范围从 0 到 1，较高的值表示模型性能更好。 ROC AUC（也称为简单的 AUC）是机器学习中的一个概念。 有关更多详细信息，请参见 here、here 和 here。
语法
别名：arrayAUC
参数
arr_scores— 预测模型给出的分数。 Array 的 Integers 或 Floats。arr_labels— 样本的标签，通常正样本为 1，负样本为 0。 Array 的 Integers 或 Enums。scale— 决定是否返回归一化区域。如果为 false，则返回 TP（真正例）x FP（假正例）曲线下的区域。默认值：true。 Bool。可选。arr_partial_offsets— 用于计算 ROC 曲线下面积的部分区域（相当于 ROC 空间的垂直带）的四个非负整数数组，而不是整个 AUC。此选项有助于 ROC AUC 的分布式计算。数组必须包含以下元素 [higher_partitions_tp,higher_partitions_fp,total_positives,total_negatives]。 Array 的非负 Integers。可选。higher_partitions_tp：在分数较高的分区中正标签的数量。higher_partitions_fp：在分数较高的分区中负标签的数量。total_positives：整个数据集中正样本的总数。total_negatives：整个数据集中负样本的总数。
当使用 arr_partial_offsets 时，arr_scores 和 arr_labels 应仅为整个数据集的一个分区，包含一个分数区间的数据。
数据集应被划分为连续的分区，每个分区包含其分数落在特定范围内的数据子集。
例如：
- 一个分区可以包含所有分数在 [0, 0.5) 范围内。
- 另一个分区可以包含分数在 [0.5, 1.0] 范围内。
返回值
返回 ROC 曲线下面积。 Float64。
示例
查询：
结果：
arrayAUCPR
计算精确率-召回率 (PR) 曲线下的面积。
精确率-召回率曲线是通过在所有阈值下将精确率绘制在 y 轴上、召回率绘制在 x 轴上创建的。
结果值的范围从 0 到 1，值越高表示模型性能越好。
PR AUC 对于不平衡数据集特别有用，与 ROC AUC 相比，在这些情况下提供了更清晰的性能比较。
有关更多详细信息，请参见 这里、这里 和 这里。
语法
别名: arrayPRAUC
参数
arr_scores— 模型提供的分数。 数组 的 整数 或 浮点数。arr_labels— 样本的标签，通常对于正样本为 1，对于负样本为 0。 数组 的 整数 或 枚举。arr_partial_offsets— 可选。用于计算 PR 曲线下的部分区域的三个非负整数的 数组（相当于 PR 空间的垂直带），而不是整个 AUC。此选项对于 PR AUC 的分布式计算很有用。数组必须包含以下元素 [higher_partitions_tp,higher_partitions_fp,total_positives]。可选的非负 整数 的数组。higher_partitions_tp: 高分片中的正标签数量。higher_partitions_fp: 高分片中的负标签数量。total_positives: 整个数据集中的正样本总数。
使用 arr_partial_offsets 时，arr_scores 和 arr_labels 应仅为整个数据集的一部分，包含一个分数区间。
数据集应划分为连续分区，每个分区包含分数在特定范围内的数据子集。
例如：
- 一个分区可以包含所有分数在 [0, 0.5) 范围内。
- 另一个分区可以包含分数在 [0.5, 1.0] 范围内。
返回值
返回精确率-召回率 (PR) 曲线下的面积。 Float64。
示例
查询：
结果：
arrayMap(func, arr1, ...)
通过对每个元素应用 func(arr1[i], ..., arrN[i]) 从原始数组中返回一个数组。数组 arr1 ... arrN 必须具有相同数量的元素。
示例：
以下示例显示如何从不同数组创建元素的元组：
注意 arrayMap 是一个 高阶函数。您必须将一个 lambda 函数作为第一个参数传递给它，且该参数不可省略。
arrayFilter(func, arr1, ...)
返回一个仅包含 arr1 中 func(arr1[i], ..., arrN[i]) 返回非零元素的数组。
示例：
注意 arrayFilter 是一个 高阶函数。您必须将一个 lambda 函数作为第一个参数传递给它，且该参数不可省略。
arrayFill(func, arr1, ...)
从第一个元素到最后一个元素扫描 arr1，如果 func(arr1[i], ..., arrN[i]) 返回 0，则用 arr1[i - 1] 替换 arr1[i]。arr1 的第一个元素不会被替换。
示例：
注意 arrayFill 是一个 高阶函数。您必须将一个 lambda 函数作为第一个参数传递给它，且该参数不可省略。
arrayReverseFill(func, arr1, ...)
从最后一个元素到第一个元素扫描 arr1，如果 func(arr1[i], ..., arrN[i]) 返回 0，则用 arr1[i + 1] 替换 arr1[i]。arr1 的最后一个元素不会被替换。
示例：
注意 arrayReverseFill 是一个 高阶函数。您必须将一个 lambda 函数作为第一个参数传递给它，且该参数不可省略。
arraySplit(func, arr1, ...)
将 arr1 拆分为多个数组。当 func(arr1[i], ..., arrN[i]) 返回非零元素时，数组将在元素左侧拆分。数组在第一个元素之前不会被拆分。
示例：
注意 arraySplit 是一个 高阶函数。您必须将一个 lambda 函数作为第一个参数传递给它，且该参数不可省略。
arrayReverseSplit(func, arr1, ...)
将 arr1 拆分为多个数组。当 func(arr1[i], ..., arrN[i]) 返回非零元素时，数组将在元素右侧拆分。数组在最后一个元素之后不会被拆分。
示例：
注意 arrayReverseSplit 是一个 高阶函数。您必须将一个 lambda 函数作为第一个参数传递给它，且该参数不可省略。
arrayExists([func,] arr1, ...)
如果 arr 中至少有一个元素使得 func(arr1[i], ..., arrN[i]) 返回非零，则返回 1。否则，返回 0。
注意 arrayExists 是一个 高阶函数。您可以将一个 lambda 函数作为第一个参数传递给它。
arrayAll([func,] arr1, ...)
如果 func(arr1[i], ..., arrN[i]) 对数组中所有元素返回非零，则返回 1。否则，返回 0。
注意 arrayAll 是一个 高阶函数。您可以将一个 lambda 函数作为第一个参数传递给它。
arrayFirst(func, arr1, ...)
返回 arr1 数组中第一个使得 func(arr1[i], ..., arrN[i]) 返回非零的元素。
arrayFirstOrNull
返回 arr1 数组中第一个使得 func(arr1[i], ..., arrN[i]) 返回非零的元素，否则返回 NULL。
语法
参数
返回值
- 在传入数组中的第一个元素。
- 否则，返回
NULL。
实现细节
注意 arrayFirstOrNull 是一个 高阶函数。您必须将一个 lambda 函数作为第一个参数传递给它，且该参数不可省略。
示例
查询：
结果：
查询：
结果：
查询：
结果：
arrayLast(func, arr1, ...)
返回 arr1 数组中第一个使得 func(arr1[i], ..., arrN[i]) 返回非零的最后一个元素。
注意 arrayLast 是一个 高阶函数。您必须将一个 lambda 函数作为第一个参数传递给它，且该参数不可省略。
arrayLastOrNull
返回 arr1 数组中第一个使得 func(arr1[i], ..., arrN[i]) 返回非零的最后一个元素，否则返回 NULL。
语法
参数
返回值
- 在传入数组中的最后一个元素。
- 否则，返回
NULL。
实现细节
注意 arrayLastOrNull 是一个 高阶函数。您必须将一个 lambda 函数作为第一个参数传递给它，且该参数不可省略。
示例
查询：
结果：
查询：
结果：
arrayFirstIndex(func, arr1, ...)
返回 arr1 数组中第一个使得 func(arr1[i], ..., arrN[i]) 返回非零的元素的索引。
注意 arrayFirstIndex 是一个 高阶函数。您必须将一个 lambda 函数作为第一个参数传递给它，且该参数不可省略。
arrayLastIndex(func, arr1, ...)
返回 arr1 数组中最后一个使得 func(arr1[i], ..., arrN[i]) 返回非零的元素的索引。
注意 arrayLastIndex 是一个 高阶函数。您必须将一个 lambda 函数作为第一个参数传递给它，且该参数不可省略。
arrayMin
返回源数组中元素的最小值。
如果指定了 func 函数，则返回由此函数转换后的元素的最小值。
注意 arrayMin 是一个 高阶函数。您可以将一个 lambda 函数作为第一个参数传递给它。
语法
参数
返回值
- 函数值的最小值（或数组的最小值）。
如果指定了 func，则返回类型与 func 的返回值类型相匹配，否则与数组元素的类型相匹配。
示例
查询：
结果：
查询：
结果：
arrayMax
返回源数组中元素的最大值。
如果指定了 func 函数，则返回由此函数转换后的元素的最大值。
注意 arrayMax 是一个 高阶函数。您可以将一个 lambda 函数作为第一个参数传递给它。
语法
参数
返回值
- 函数值的最大值（或数组的最大值）。
如果指定了 func，则返回类型与 func 的返回值类型相匹配，否则与数组元素的类型相匹配。
示例
查询：
结果：
查询：
结果：
arraySum
返回源数组中元素的总和。
如果指定了 func 函数，则返回由此函数转换后的元素的总和。
注意 arraySum 是一个 高阶函数。您可以将一个 lambda 函数作为第一个参数传递给它。
语法
参数
返回值
- 函数值的总和（或数组的总和）。
返回类型：
- 对于源数组中的十进制数（或对于转换值，如果指定了
func） — Decimal128。 - 对于浮点数 — Float64。
- 对于无符号数字 — UInt64。
- 对于有符号数字 — Int64。
示例
查询：
结果：
查询：
结果：
arrayAvg
返回源数组中元素的平均值。
如果指定了 func 函数，则返回由此函数转换后的元素的平均值。
注意 arrayAvg 是一个 高阶函数。您可以将一个 lambda 函数作为第一个参数传递给它。
语法
参数
返回值
- 函数值的平均值（或数组的平均值）。 Float64。
示例
查询：
结果：
查询：
结果：
arrayCumSum([func,] arr1, ...)
返回源数组 arr1 中元素的部分（运行）和的数组。如果指定了 func，则通过将 func 应用到 arr1、arr2、...、arrN 计算和，即 func(arr1[i], ..., arrN[i])。
语法
参数
arr— 数组 的数值。
返回值
示例：
注意 arrayCumSum 是一个 高阶函数。您可以将一个 lambda 函数作为第一个参数传递给它。
arrayCumSumNonNegative([func,] arr1, ...)
与 arrayCumSum 相同，返回源数组中元素的部分（运行）和的数组。如果指定了 func，则通过将 func 应用到 arr1、arr2、...、arrN 计算和，即 func(arr1[i], ..., arrN[i])。与 arrayCumSum 不同的是，如果当前的运行总和小于 0，则用 0 替换。
语法
参数
arr— 数组 的数值。
返回值
注意 arraySumNonNegative 是一个 高阶函数。您可以将一个 lambda 函数作为第一个参数传递给它。
arrayProduct
对 数组 的元素进行乘法运算。
语法
参数
arr— 数组 的数值。
返回值
- 数组元素的乘积。 Float64。
示例
查询：
结果：
查询：
返回值类型始终为 Float64。结果：
arrayRotateLeft
将 数组 向左旋转指定数量的元素。
如果元素的数量为负，则数组向右旋转。
语法
参数
arr— 数组。n— 旋转的元素数量。
返回值
- 向左旋转指定数量元素的数组。 数组。
示例
查询：
结果：
查询：
结果：
查询：
结果：
arrayRotateRight
将 数组 向右旋转指定数量的元素。
如果元素的数量为负，则数组向左旋转。
语法
参数
arr— 数组。n— 旋转的元素数量。
返回值
- 向右旋转指定数量元素的数组。 数组。
示例
查询：
结果：
查询：
结果：
查询：
结果：
arrayShiftLeft
将 数组 向左移动指定数量的元素。
新元素使用提供的参数或数组元素类型的默认值填充。
如果元素的数量为负，则数组向右移动。
语法
参数
arr— 数组。n— 移动的元素数量。default— 可选。新元素的默认值。
返回值
- 向左移动指定数量元素的数组。 数组。
示例
查询：
结果：
查询：
结果：
查询：
结果：
查询：
结果：
查询：
结果：
arrayShiftRight
将 数组 向右移动指定数量的元素。
新元素使用提供的参数或数组元素类型的默认值填充。
如果元素的数量为负，则数组向左移动。
语法
参数
arr— 数组。n— 移动的元素数量。default— 可选。新元素的默认值。
返回值
- 向右移动指定数量元素的数组。 数组。
示例
查询：
结果：
查询：
结果：
查询：
结果：
查询：
结果：
查询：
结果：
arrayRandomSample
函数 arrayRandomSample 从输入数组返回一个包含 samples 个随机元素的子集。
如果 samples 超过输入数组的大小，则样本大小限制为数组的大小，即返回所有数组元素，但不保证其顺序。
该函数可以处理平面数组和嵌套数组。
语法
参数
返回值
- 包含来自输入数组的随机元素样本的数组。 数组。
示例
查询：
结果：
查询：
结果：
查询：
结果：
arrayNormalizedGini
计算规范化的基尼系数。
语法
参数
返回值
- 包含预测值的基尼系数、规范化值的基尼系数和规范化基尼系数（即前两个基尼系数的比率）的元组。
示例
查询：
结果：
Distance functions
所有支持的函数在 距离函数文档 中有所描述。