数组函数

empty

检查输入数组是否为空。

语法

empty([x])

如果数组不包含任何元素，则视为空数组。

注意

通过启用 optimize_functions_to_subcolumns 设置可以优化此函数。当 optimize_functions_to_subcolumns = 1 时，此函数仅读取 size0 子列，而不是读取和处理整个数组列。查询 SELECT empty(arr) FROM TABLE; 会转换为 SELECT arr.size0 = 0 FROM TABLE;。

此函数也适用于字符串或 UUID。

参数

[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。

此函数也适用于字符串或 UUID。

参数

[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 必须是任何整数类型。数组中的索引从 1 开始。

支持负索引。在这种情况下，它会选择从末尾编号的相应元素。例如，arr[-1] 是数组中的最后一个项目。

如果索引超出数组的范围，则返回一些默认值（数字为 0，字符串为空字符串等），除非是非恒定数组和恒定索引 0 的情况（在这种情况下，会出现错误 Array indices are 1-based）。

has(arr, elem)

检查 ‘arr’ 数组是否包含 ‘elem’ 元素。如果元素不在数组中，则返回 0，如果元素在数组中，则返回 1。

NULL 被视为一个值进行处理。

SELECT has([1, 2, NULL], NULL)

┌─has([1, 2, NULL], NULL)─┐
│                       1 │
└─────────────────────────┘

arrayElementOrNull(arr, n)

从数组 arr 中获取索引为 n 的元素。n 必须是任何整数类型。数组中的索引从 1 开始。

支持负索引。在这种情况下，它会选择从末尾编号的相应元素。例如，arr[-1] 是数组中的最后一个项目。

如果索引超出数组的范围，则返回 NULL 而不是默认值。

示例

SELECT arrayElementOrNull([1, 2, 3], 2), arrayElementOrNull([1, 2, 3], 4)

 ┌─arrayElementOrNull([1, 2, 3], 2)─┬─arrayElementOrNull([1, 2, 3], 4)─┐
 │                                2 │                             ᴺᵁᴸᴸ │
 └──────────────────────────────────┴──────────────────────────────────┘

hasAll

检查一个数组是否是另一个数组的子集。

hasAll(set, subset)

参数

set – 包含元素集合的任何类型的数组。
subset – 任何类型的数组，与 set 共享公共超类型，包含应测试是否为 set 子集的元素。

返回值

1，如果 set 包含 subset 中的所有元素。
0，否则。

如果 set 和 subset 元素不共享公共超类型，则引发 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 共享公共超类型。

返回值

1，如果 array1 和 array2 至少有一个相似的元素。
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 – 包含元素集合的任何类型的数组。

返回值

1，如果 array1 包含 array2。
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 的元素被视为普通值。

indexOfAssumeSorted(arr, x)

如果数组中存在值为 ‘x’ 的第一个元素，则返回其索引（从 1 开始）。如果数组不包含搜索到的值，则该函数返回 0。假设数组按升序排序（即，该函数使用二分搜索）。如果数组未排序，则结果未定义。如果内部数组的类型为 Nullable，则将调用函数 ‘indexOf‘。

示例

SELECT indexOfAssumeSorted([1, 3, 3, 3, 4, 4, 5], 4)

┌─indexOfAssumeSorted([1, 3, 3, 3, 4, 4, 5], 4)─┐
│                                             5 │
└───────────────────────────────────────────────┘

arrayCount([func,] arr1, ...)

返回 func(arr1[i], ..., arrN[i]) 返回非 0 值的元素数量。如果未指定 func，则返回数组中非零元素的数量。

请注意，arrayCount 是一个高阶函数。您可以将 lambda 函数作为第一个参数传递给它。

arrayDotProduct

返回两个数组的点积。

语法

arrayDotProduct(vector1, vector2)

别名：scalarProduct, dotProduct

参数

vector1: 第一个向量。数组或元组的数值。
vector2: 第二个向量。数组或元组的数值。

注意

两个向量的大小必须相等。数组和元组也可能包含混合元素类型。

返回值

两个向量的点积。数值。

注意

返回类型由参数的类型确定。如果数组或元组包含混合元素类型，则结果类型为超类型。

示例

查询

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

返回与源数组大小相同的数组，指示对于每个元素，其在具有相同值的元素中的位置。例如：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] │
└─────────┘

注意

为了提高排序效率，使用了 Schwartzian 变换。

arrayPartialSort([func,] limit, arr, ...)

与 arraySort 相同，但添加了 limit 参数以允许部分排序。返回与原始数组大小相同的数组，其中范围 [1..limit] 中的元素按升序排序。剩余元素 (limit..N] 应包含未指定顺序的元素。

arrayReverseSort

以降序对 arr 数组的元素进行排序。如果指定了 func 函数，则根据应用于数组元素的 func 函数的结果对 arr 进行排序，然后反转排序后的数组。如果 func 接受多个参数，则将多个数组传递给 arrayReverseSort 函数，这些数组将对应于 func 的参数。详细示例显示在 arrayReverseSort 描述的末尾。

语法

arrayReverseSort([func,] arr, ...)

整数值排序示例

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']）进行排序。在第二个数组 ([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

返回值

包含部分打乱元素的数组。

实现细节

注意

此函数不会物化常量。

limit 的值应在 [1..N] 范围内。超出该范围的值等同于执行完整的 arrayShuffle。

示例

注意：当使用 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 – 数组。

返回值

返回相邻数组元素之间差异的数组。 UInt*, Int*, Float*。

示例

查询

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]]

arrayUnion(arr)

接受多个数组，返回一个包含任何源数组中存在的所有元素的数组。

示例

SELECT
    arrayUnion([-2, 1], [10, 1], [-2], []) as num_example,
    arrayUnion(['hi'], [], ['hello', 'hi']) as str_example,
    arrayUnion([1, 3, NULL], [2, 3, NULL]) as null_example

┌─num_example─┬─str_example────┬─null_example─┐
│ [10,-2,1]   │ ['hello','hi'] │ [3,2,1,NULL] │
└─────────────┴────────────────┴──────────────┘

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)

参数

agg_func — 聚合函数的名称，应为常量字符串。
arr — 任何数量的数组类型列，作为聚合函数的参数。

返回值

示例

查询

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 │
└─────────────────────────────────────────────────────────────┘

另请参阅

arrayFold

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 │
└───────────┘

另请参阅

arrayReduce

arrayReverse

返回与原始数组大小相同的数组，其中包含反向顺序的元素。

语法

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 — 要检查的数组。

返回值

不包含重复项的数组。数组。

示例

查询

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)]            │
└──────────────────────────────────────┘

arrayZipUnaligned

将多个数组合并为一个数组，允许未对齐的数组。结果数组包含源数组的对应元素，并按参数的列出顺序分组为元组。

语法

arrayZipUnaligned(arr1, arr2, ..., arrN)

参数

arrN — 数组。

该函数可以接受任意数量的不同类型的数组。

返回值

包含源数组元素的数组，这些元素分组为元组。元组中的数据类型与输入数组的类型相同，并且顺序与数组传递的顺序相同。数组。如果数组大小不同，则较短的数组将用 null 值填充。

示例

查询

SELECT arrayZipUnaligned(['a'], [1, 2, 3]);

结果

┌─arrayZipUnaligned(['a'], [1, 2, 3])─┐
│ [('a',1),(NULL,2),(NULL,3)]         │
└─────────────────────────────────────┘

arrayROCAUC

计算受试者工作特征 (ROC) 曲线下的面积。 ROC 曲线是通过在所有阈值上绘制 y 轴上的真阳性率 (TPR) 和 x 轴上的假阳性率 (FPR) 来创建的。结果值范围从 0 到 1，值越高表示模型性能越好。 ROC AUC（也简称为 AUC）是机器学习中的一个概念。有关更多详细信息，请参阅此处、此处和此处。

语法

arrayROCAUC(arr_scores, arr_labels[, scale[, arr_partial_offsets]])

别名: arrayAUC

参数

arr_scores — 评分预测模型给出。数组的整数或浮点数。
arr_labels — 样本标签，通常正样本为 1，负样本为 0。数组的整数或枚举。
scale — 决定是否返回归一化面积。如果为 false，则返回 TP（真阳性）x FP（假阳性）曲线下的面积。默认值：true。布尔值。可选。
arr_partial_offsets — 用于计算 ROC 曲线下部分面积（相当于 ROC 空间的垂直带）而不是整个 AUC 的四个非负整数的数组。此选项对于 ROC AUC 的分布式计算很有用。该数组必须包含以下元素 [higher_partitions_tp, higher_partitions_fp, total_positives, total_negatives]。非负整数的数组。可选。
- 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。

示例

查询

select arrayROCAUC([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1]);

结果

┌─arrayROCAUC([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1])─┐
│                                             0.75 │
└──────────────────────────────────────────────────┘

arrayAUCPR

计算精确率-召回率 (PR) 曲线下的面积。精确率-召回率曲线是通过在所有阈值上绘制 y 轴上的精确率和 x 轴上的召回率来创建的。结果值范围从 0 到 1，值越高表示模型性能越好。 PR AUC 对于不平衡数据集尤其有用，与这些情况下的 ROC AUC 相比，它可以更清晰地比较性能。有关更多详细信息，请参阅此处、此处和此处。

语法

arrayAUCPR(arr_scores, arr_labels[, arr_partial_offsets])

别名: 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: 整个数据集中的正样本总数。

注意

一个分区可以包含范围 [0, 0.5) 内的所有评分。
另一个分区可以包含范围 [0.5, 1.0] 内的评分。

返回值

返回精确率-召回率 (PR) 曲线下的面积。 Float64。

示例

查询

select arrayAUCPR([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1]);

结果

┌─arrayAUCPR([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1])─┐
│                              0.8333333333333333 │
└─────────────────────────────────────────────────┘

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, ...)

参数

func: Lambda 函数。 Lambda 函数。
arr1: 要操作的数组。数组。

返回值

传递数组中的第一个元素。
否则，返回 NULL

实现细节

请注意，arrayFirstOrNull 是一个高阶函数。您必须将 lambda 函数作为第一个参数传递给它，并且它不能省略。

示例

查询

SELECT arrayFirstOrNull(x -> x >= 2, [1, 2, 3]);

结果

查询

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, ...)

参数

func: Lambda 函数。 Lambda 函数。
arr1: 要操作的数组。数组。

返回值

传递数组中的最后一个元素。
否则，返回 NULL

实现细节

请注意，arrayLastOrNull 是一个高阶函数。您必须将 lambda 函数作为第一个参数传递给它，并且它不能省略。

示例

查询

SELECT arrayLastOrNull(x -> x >= 2, [1, 2, 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 — 函数。表达式。
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 — 函数。表达式。
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 — 函数。表达式。
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)

参数

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 — 数值的 Array 数组。

返回值

返回源数组中元素的部分总和的数组。UInt*, Int*, Float*。

示例

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 — 数值的 Array 数组。

返回值

返回源数组中元素的非负部分总和的数组。UInt*, Int*, Float*。

SELECT arrayCumSumNonNegative([1, 1, -4, 1]) AS res

┌─res───────┐
│ [1,2,0,1] │
└───────────┘

请注意，arraySumNonNegative 是一个高阶函数。您可以将 lambda 函数作为第一个参数传递给它。

arrayProduct

将 array 的元素相乘。

语法

arrayProduct(arr)

参数

arr — 数值的 Array 数组。

返回值

数组元素的乘积。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

将 array 向左旋转指定的元素数量。如果元素数量为负数，则数组向右旋转。

语法

arrayRotateLeft(arr, n)

参数

arr — Array。
n — 要旋转的元素数量。

返回值

向左旋转指定元素数量的数组。Array。

示例

查询

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

将 array 向右旋转指定的元素数量。如果元素数量为负数，则数组向左旋转。

语法

arrayRotateRight(arr, n)

参数

arr — Array。
n — 要旋转的元素数量。

返回值

向右旋转指定元素数量的数组。Array。

示例

查询

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

将 array 向左移动指定的元素数量。新元素会用提供的参数或数组元素类型的默认值填充。如果元素数量为负数，则数组向右移动。

语法

arrayShiftLeft(arr, n[, default])

参数

arr — Array。
n — 要移动的元素数量。
default — 可选。新元素的默认值。

返回值

向左移动指定元素数量的数组。Array。

示例

查询

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

将 array 向右移动指定的元素数量。新元素会用提供的参数或数组元素类型的默认值填充。如果元素数量为负数，则数组向左移动。

语法

arrayShiftRight(arr, n[, default])

参数

arr — Array。
n — 要移动的元素数量。
default — 可选。新元素的默认值。

返回值

向右移动指定元素数量的数组。Array。

示例

查询

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)

参数

arr — 要从中采样元素的输入数组。(Array(T))
samples — 要包含在随机样本中的元素数量 (UInt*)

返回值

包含来自输入数组的随机样本元素的数组。Array。

示例

查询

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] │
└─────────┘

arrayNormalizedGini

计算归一化 Gini 系数。

语法

arrayNormalizedGini(predicted, label)

参数

predicted — 预测值 (Array(T))
label — 实际值 (Array(T))

返回值

一个元组，包含预测值的 Gini 系数、归一化值的 Gini 系数以及归一化 Gini 系数（= 前两个 Gini 系数的比率）。

示例

查询

SELECT arrayNormalizedGini([0.9, 0.3, 0.8, 0.7], [6, 1, 0, 2]);

结果

┌─arrayNormalizedGini([0.9, 0.3, 0.8, 0.7], [6, 1, 0, 2])──────────┐
│ (0.18055555555555558,0.2638888888888889,0.6842105263157896) │
└─────────────────────────────────────────────────────────────┘

距离函数

所有支持的函数都在距离函数文档中描述。

empty​

notEmpty​

length​

emptyArrayUInt8​

emptyArrayUInt16​

emptyArrayUInt32​

emptyArrayUInt64​

emptyArrayInt8​

emptyArrayInt16​

emptyArrayInt32​

emptyArrayInt64​

emptyArrayFloat32​

emptyArrayFloat64​

emptyArrayDate​

emptyArrayDateTime​

emptyArrayString​

emptyArrayToSingle​

range(end), range([start, ] end [, step])​

array(x1, ...), 运算符 [x1, ...]​

arrayWithConstant(length, elem)​

arrayConcat​

arrayElement(arr, n), 运算符 arr[n]​

has(arr, elem)​

arrayElementOrNull(arr, n)​

示例​

hasAll​

hasAny​

hasSubstr​

indexOf(arr, x)​

indexOfAssumeSorted(arr, x)​

arrayCount([func,] arr1, ...)​

arrayDotProduct​

countEqual(arr, x)​

arrayEnumerate(arr)​

arrayEnumerateUniq​

arrayEnumerateUniqRanked​

arrayPopBack​

arrayPopFront​

arrayPushBack​

arrayPushFront​

arrayResize​

arraySlice​

arrayShingles​

arraySort([func,] arr, ...)​

arrayPartialSort([func,] limit, arr, ...)​

arrayReverseSort​

arrayPartialReverseSort([func,] limit, arr, ...)​

arrayShuffle​

arrayPartialShuffle​

arrayUniq(arr, ...)​

arrayJoin(arr)​

arrayDifference​

arrayDistinct​

arrayEnumerateDense​

arrayEnumerateDenseRanked​

arrayUnion(arr)​

arrayIntersect(arr)​

arrayJaccardIndex​

arrayReduce​

arrayReduceInRanges​

arrayFold​

arrayReverse​

reverse(arr)​

arrayFlatten​

arrayCompact​

arrayZip​

arrayZipUnaligned​

arrayROCAUC​

arrayAUCPR​

arrayMap(func, arr1, ...)​

arrayFilter(func, arr1, ...)​

arrayFill(func, arr1, ...)​

arrayReverseFill(func, arr1, ...)​

arraySplit(func, arr1, ...)​

arrayReverseSplit(func, arr1, ...)​

arrayExists([func,] arr1, ...)​

arrayAll([func,] arr1, ...)​

arrayFirst(func, arr1, ...)​

arrayFirstOrNull​

arrayLast(func, arr1, ...)​

empty

notEmpty

length

emptyArrayUInt8

emptyArrayUInt16

emptyArrayUInt32

emptyArrayUInt64

emptyArrayInt8

emptyArrayInt16

emptyArrayInt32

emptyArrayInt64

emptyArrayFloat32

emptyArrayFloat64

emptyArrayDate

emptyArrayDateTime

emptyArrayString

emptyArrayToSingle

range(end), range([start, ] end [, step])

array(x1, ...), 运算符 [x1, ...]

arrayWithConstant(length, elem)

arrayConcat

arrayElement(arr, n), 运算符 arr[n]

has(arr, elem)

arrayElementOrNull(arr, n)

示例

hasAll

hasAny

hasSubstr

indexOf(arr, x)

indexOfAssumeSorted(arr, x)

arrayCount([func,] arr1, ...)

arrayDotProduct

countEqual(arr, x)

arrayEnumerate(arr)

arrayEnumerateUniq

arrayEnumerateUniqRanked

arrayPopBack

arrayPopFront

arrayPushBack

arrayPushFront

arrayResize

arraySlice

arrayShingles

arraySort([func,] arr, ...)

arrayPartialSort([func,] limit, arr, ...)

arrayReverseSort

arrayPartialReverseSort([func,] limit, arr, ...)

arrayShuffle

arrayPartialShuffle

arrayUniq(arr, ...)

arrayJoin(arr)

arrayDifference

arrayDistinct

arrayEnumerateDense

arrayEnumerateDenseRanked

arrayUnion(arr)

arrayIntersect(arr)

arrayJaccardIndex

arrayReduce

arrayReduceInRanges

arrayFold

arrayReverse

reverse(arr)

arrayFlatten

arrayCompact

arrayZip

arrayZipUnaligned

arrayROCAUC

arrayAUCPR

arrayMap(func, arr1, ...)

arrayFilter(func, arr1, ...)

arrayFill(func, arr1, ...)

arrayReverseFill(func, arr1, ...)

arraySplit(func, arr1, ...)

arrayReverseSplit(func, arr1, ...)

arrayExists([func,] arr1, ...)

arrayAll([func,] arr1, ...)

arrayFirst(func, arr1, ...)

arrayFirstOrNull

arrayLast(func, arr1, ...)