数组函数 - ClickHouse Documentation

array

Introduced in: v1.1.0 根据函数参数创建数组。这些参数应为常量，且其类型应具有相同的共同超类型。必须至少传入一个参数，否则无法确定要创建哪种类型的数组。这意味着你不能使用此函数创建空数组。若要创建空数组，请使用 emptyArray* 函数。 [ ] 运算符可实现相同功能。 Syntax

array(x1 [, x2, ..., xN])

参数

x1 — 任意类型 T 的常量值。如果只提供这一个参数，数组的类型将为 T。- [, x2, ..., xN] — 另外 N 个与 x1 具有相同共同超类型的常量值

返回值 返回一个数组，其中 ‘T’ 是所传参数中最小的公共类型。Array(T) 示例 有效用法

Query

SELECT array(toInt32(1), toUInt16(2), toInt8(3)) AS a, toTypeName(a)

Response

┌─a───────┬─toTypeName(a)─┐
│ [1,2,3] │ Array(Int32)  │
└─────────┴───────────────┘

错误用法

Query

SELECT array(toInt32(5), toDateTime('1998-06-16'), toInt8(5)) AS a, toTypeName(a)

Response

Received exception from server (version 25.4.3):
Code: 386. DB::Exception: Received from localhost:9000. DB::Exception:
There is no supertype for types Int32, DateTime, Int8 ...

arrayAUCPR

首次引入于：v20.4.0 计算精确率-召回率 (PR) 曲线下的面积。精确率-召回率曲线是通过在所有阈值下，以 y 轴表示精确率、x 轴表示召回率绘制而成的。结果值范围为 0 到 1，值越高表示模型性能越好。对于类别不平衡的数据集，PR AUC 尤其有用；与 ROC AUC 相比，它在这类场景下能更清晰地比较性能。更多详情，请参见此处、此处和此处。语法

arrayAUCPR(scores, labels[, partial_offsets])

别名: arrayPRAUC 参数

cores — 预测模型给出的评分。Array((U)Int*) 或 Array(Float*)
labels — 样本标签，通常正样本为 1，负样本为 0。Array((U)Int*) 或 Array(Enum)
partial_offsets —
可选。一个由三个非负整数组成的 Array(T)，用于计算 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 示例 使用示例

Query

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

Response

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

arrayAll

Introduced in：v1.1.0 如果 lambda func(x [, y1, y2, ... yN]) 对所有元素都返回 true，则返回 1；否则返回 0。语法

arrayAll(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

参数

func(x[, y1, ..., yN]) — 作用于源数组 (x) 和条件数组 (y) 元素的 lambda 函数。Lambda function
source_arr — 要处理的源数组。Array(T)
cond1_arr, ... — 可选。N 个条件数组，为 lambda 函数提供额外参数。Array(T)

返回值 如果 lambda 函数对所有元素都返回 true，则返回 1；否则返回 0。UInt8 示例 所有元素均匹配

Query

SELECT arrayAll(x, y -> x=y, [1, 2, 3], [1, 2, 3])

Response

并非所有元素都匹配

Query

SELECT arrayAll(x, y -> x=y, [1, 2, 3], [1, 1, 1])

Response

arrayAutocorrelation

首次引入于：v26.4.0 计算数组的自相关。如果提供了 max_lag，则仅计算 [0, max_lag) 范围内各个滞后值的相关性。如果未提供 max_lag，则计算所有可能滞后值的相关性。语法

arrayAutocorrelation(arr, [max_lag])

参数

arr — 数字数组。Array(T)
max_lag — 可选。要计算的最大滞后数。必须为非负整数。Integer

返回值 返回 Float64 数组。如果方差为 0，则返回 NaN。Array(Float64) 示例线性

Query

SELECT arrayAutocorrelation([1, 2, 3, 4, 5]);

Response

[1, 0.4, -0.1, -0.4, -0.4]

对称

Query

SELECT arrayAutocorrelation([10, 20, 10]);

Response

[1, -0.6666666666666669, 0.16666666666666674]

常量

Query

SELECT arrayAutocorrelation([5, 5, 5]);

Response

[nan, nan, nan]

受限

Query

SELECT arrayAutocorrelation([1, 2, 3, 4, 5], 2);

Response

[1, 0.4]

arrayAvg

引入版本：v21.1.0 返回源数组中元素的平均值。如果指定了 lambda 函数 func，则返回 lambda 结果元素的平均值。语法

arrayAvg([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])

参数

func(x[, y1, ..., yN]) — 可选。对源数组 (x) 和条件数组 (y) 中的元素执行操作的 Lambda 函数。Lambda function
source_arr — 要处理的源数组。Array(T)
[, cond1_arr, ... , condN_arr] — 可选。N 个条件数组，为 Lambda 函数提供额外参数。Array(T)

返回值 返回源数组元素的平均值；如果提供了 Lambda 函数，则返回 Lambda 计算结果元素的平均值。Float64 示例 基本示例

Query

SELECT arrayAvg([1, 2, 3, 4]);

Response

2.5

与 lambda function 配合使用

Query

SELECT arrayAvg(x, y -> x*y, [2, 3], [2, 3]) AS res;

Response

6.5

arrayCompact

引入版本：v20.1.0 从数组中移除连续重复的元素，包括 null 值。结果数组中各值的顺序取决于它们在源数组中的顺序。语法

arrayCompact(arr)

参数

arr — 用于去重的数组。Array(T)

返回值 返回一个不包含重复值的数组 Array(T) 示例 用法示例

Query

SELECT arrayCompact([1, 1, nan, nan, 2, 3, 3, 3]);

Response

[1,nan,2,3]

arrayConcat

引入版本：v1.1.0 将作为参数传入的数组合并。语法

arrayConcat(arr1 [, arr2, ... , arrN])

参数

arr1 [, arr2, ... , arrN] — 要拼接的 N 个数组。Array(T)

返回值 返回由所提供的数组参数拼接而成的单个数组。Array(T) 示例 用法示例

Query

SELECT arrayConcat([1, 2], [3, 4], [5, 6]) AS res

Response

[1, 2, 3, 4, 5, 6]

arrayCount

引入版本：v1.1.0 返回使 func(arr1[i], ..., arrN[i]) 的结果为 true 的元素个数。如果未指定 func，则返回数组中非零元素的个数。 arrayCount 是一个高阶函数。语法

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

参数

func — 可选。要应用到数组中每个元素的函数。Lambda 函数
arr1, ..., arrN — N 个数组。Array(T)

返回值 返回使 func 返回 true 的元素个数。否则，返回数组中非零元素的个数。UInt32 示例 使用示例

Query

SELECT arrayCount(x -> (x % 2), groupArray(number)) FROM numbers(10)

Response

arrayCumSum

引入版本：v1.1.0 返回一个数组，其中包含源数组中各元素的部分 (累计) 和。如果指定了 lambda 函数，则会对每个位置上的数组元素应用该 lambda 函数，并基于其结果计算累计和。语法

arrayCumSum([func,] arr1[, arr2, ... , arrN])

参数

func — 可选。应用于数组各位置元素的 Lambda 函数。Lambda function
arr1 — 由数值组成的源数组。Array(T)
[arr2, ..., arrN] — 可选。其他大小相同的数组；如果指定了 Lambda 函数，则会作为参数传递给它。Array(T)

返回值 返回一个数组，其中包含源数组各元素的前缀和。结果类型与输入数组的数值类型一致。Array(T) 示例 基本用法

Query

SELECT arrayCumSum([1, 1, 1, 1]) AS res

Response

[1, 2, 3, 4]

使用 Lambda 表达式

Query

SELECT arrayCumSum(x -> x * 2, [1, 2, 3]) AS res

Response

[2, 6, 12]

arrayCumSumNonNegative

引入版本：v18.12.0 返回一个数组，其中包含源数组各元素的部分和 (累计和) ，并将任何为负的累计和替换为零。如果指定了 Lambda 函数，则会对每个位置上的数组元素应用该 Lambda 函数，并基于其结果计算累计和。语法

arrayCumSumNonNegative([func,] arr1[, arr2, ... , arrN])

参数

func — 可选。一个 Lambda 函数，用于对每个位置上的数组元素进行处理。Lambda function
arr1 — 由数值组成的源数组。Array(T)
[arr2, ..., arrN] — 可选。其他大小相同的数组；如果指定了 Lambda 函数，这些数组会作为参数传递给该函数。Array(T)

返回值 返回一个数组，包含源数组元素的前缀和，其中任何小于零的累计和都会被替换为零。结果类型与输入数组的数值类型一致。Array(T) 示例 基本用法

Query

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

Response

[1, 2, 0, 1]

配合 lambda

Query

SELECT arrayCumSumNonNegative(x -> x * 2, [1, -2, 3]) AS res

Response

[2, 0, 6]

arrayDifference

Introduced in: v1.1.0 计算由相邻数组元素差值组成的数组。结果数组的第一个元素为 0，第二个为 arr[1] - arr[0]，第三个为 arr[2] - arr[1]，以此类推。结果数组中元素的类型由减法的类型推断规则决定 (例如 UInt8 - UInt8 = Int16) 。语法

arrayDifference(arr)

参数

arr — 用于计算相邻元素差值的数组。Array(T)

返回值 返回一个由数组中相邻元素差值组成的数组 UInt* 示例 用法示例

Query

SELECT arrayDifference([1, 2, 3, 4]);

Response

[0,1,1,1]

结果类型为 Int64 时的溢出示例

Query

SELECT arrayDifference([0, 10000000000000000000]);

Response

┌─arrayDifference([0, 10000000000000000000])─┐
│ [0,-8446744073709551616]                   │
└────────────────────────────────────────────┘

arrayDistinct

首次引入版本：v1.1.0 返回一个仅包含数组中不重复元素的数组。语法

arrayDistinct(arr)

参数

arr — 要提取其中不同元素的数组。Array(T)

返回值 返回包含不同元素的数组。Array(T) 示例 使用示例

Query

SELECT arrayDistinct([1, 2, 2, 3, 1]);

Response

[1,2,3]

arrayDotProduct

引入版本：v23.5.0 返回两个数组的点积。

两个向量的长度必须相等。数组和 Tuple 也可以包含混合的元素类型。

语法

arrayDotProduct(v1, v2)

参数

v1 — 第一个向量。Array((U)Int* | Float* | Decimal) 或 Tuple((U)Int* | Float* | Decimal)
v2 — 第二个向量。Array((U)Int* | Float* | Decimal) 或 Tuple((U)Int* | Float* | Decimal)

返回值 两个向量的点积。

返回类型由参数类型决定。如果 Array 或 Tuple 包含混合的元素类型，则结果类型为 supertype。

(U)Int* 或 Float* 或 Decimal 示例 Array 示例

Query

SELECT arrayDotProduct([1, 2, 3], [4, 5, 6]) AS res, toTypeName(res);

Response

32    UInt16

Tuple 示例

Query

SELECT dotProduct((1::UInt16, 2::UInt8, 3::Float32),(4::Int16, 5::Float32, 6::UInt8)) AS res, toTypeName(res);

Response

32    Float64

arrayElement

引入版本：v1.1.0 获取给定数组中索引为 n 的元素，其中 n 可以是任意整数类型。如果索引超出数组范围，则返回默认值 (数值类型返回 0，String 返回空字符串等) ，但非常量数组参数且索引为常量 0 的情况除外。在这种情况下，会报错 Array indices are 1-based。

ClickHouse 中的数组从 1 开始索引。

支持负索引。在这种情况下，会从末尾开始计数并选择相应的元素。例如，arr[-1] 表示数组中的最后一个元素。运算符 [n] 提供相同的功能。语法

arrayElement(arr, n)

参数

arr — 要搜索的数组。Array(T)。 - n — 要获取的元素位置。(U)Int*。

返回值 返回一个由提供的数组参数合并而成的数组 Array(T) 示例 使用示例

Query

SELECT arrayElement(arr, 2) FROM (SELECT [1, 2, 3] AS arr)

Response

负数索引

Query

SELECT arrayElement(arr, -1) FROM (SELECT [1, 2, 3] AS arr)

Response

使用 [n] 记法

Query

SELECT arr[2] FROM (SELECT [1, 2, 3] AS arr)

Response

数组索引越界

Query

SELECT arrayElement(arr, 4) FROM (SELECT [1, 2, 3] AS arr)

Response

arrayElementOrNull

引入版本：v1.1.0 获取给定数组中索引为 n 的元素，其中 n 可以是任意整数类型。如果索引超出数组范围，则返回 NULL，而不是默认值。

ClickHouse 中的数组从 1 开始索引。

支持负索引。在这种情况下，会选择从末尾开始计数的对应元素。例如，arr[-1] 表示数组中的最后一个元素。语法

arrayElementOrNull(arrays)

参数

arrays — 任意数量的数组参数。Array

返回值 返回由给定数组参数合并而成的单个数组。Array(T) 示例 用法示例

Query

SELECT arrayElementOrNull(arr, 2) FROM (SELECT [1, 2, 3] AS arr)

Response

负数索引

Query

SELECT arrayElementOrNull(arr, -1) FROM (SELECT [1, 2, 3] AS arr)

Response

数组索引越界

Query

SELECT arrayElementOrNull(arr, 4) FROM (SELECT [1, 2, 3] AS arr)

Response

NULL

arrayEnumerate

引入版本：v1.1.0 返回数组 [1, 2, 3, ..., length (arr)] 此函数通常与 ARRAY JOIN 子句配合使用。它可以在应用 ARRAY JOIN 后，对每个数组中的某项内容只统计一次。此函数也可用于高阶函数。例如，可以用它获取满足条件的元素的数组索引。语法

arrayEnumerate(arr)

参数

arr — 要进行枚举的数组。Array

返回值 返回数组 [1, 2, 3, ..., length (arr)]。Array(UInt32) 示例 使用 ARRAY JOIN 的基础示例

Query

CREATE TABLE test
(
    `id` UInt8,
    `tag` Array(String),
    `version` Array(String)
)
ENGINE = MergeTree
ORDER BY id;

INSERT INTO test VALUES (1, ['release-stable', 'dev', 'security'], ['2.4.0', '2.6.0-alpha', '2.4.0-sec1']);

SELECT
    id,
    tag,
    version,
    seq
FROM test
ARRAY JOIN
    tag,
    version,
    arrayEnumerate(tag) AS seq

Response

┌─id─┬─tag────────────┬─version─────┬─seq─┐
│  1 │ release-stable │ 2.4.0       │   1 │
│  1 │ dev            │ 2.6.0-alpha │   2 │
│  1 │ security       │ 2.4.0-sec1  │   3 │
└────┴────────────────┴─────────────┴─────┘

arrayEnumerateDense

引入版本：v18.12.0 返回一个与源数组大小相同的数组，表示源数组中每个元素首次出现的位置。语法

arrayEnumerateDense(arr)

参数

arr — 要进行枚举的数组。Array(T)

返回值 返回一个与 arr 大小相同的数组，表示每个元素在源数组中首次出现的位置。Array(T) 示例 用法示例

Query

SELECT arrayEnumerateDense([10, 20, 10, 30])

Response

[1,2,1,3]

arrayEnumerateDenseRanked

在以下版本中引入：v20.1.0 返回一个与源数组大小相同的数组，表示每个元素在源数组中首次出现的位置。它支持对多维数组进行枚举，并可指定向数组内部深入的层级。语法

arrayEnumerateDenseRanked(clear_depth, arr, max_array_depth)

参数

clear_depth — 在指定层级对元素分别进行枚举。必须小于或等于 max_arr_depth。UInt*
arr — 要枚举的 N 维数组。Array(T)
max_array_depth — 最大有效深度。必须小于或等于 arr 的深度。UInt*

返回值 返回一个数组，表示源数组中每个元素首次出现的位置。Array 示例 基本用法

Query

-- 当 clear_depth=1 且 max_array_depth=1 时，结果与 arrayEnumerateDense 的输出相同。

SELECT arrayEnumerateDenseRanked(1,[10, 20, 10, 30],1);

Response

[1,2,1,3]

与多维数组配合使用

Query

-- 在此示例中，arrayEnumerateDenseRanked 用于获取一个数组，指示多维数组中每个元素在相同值的元素中的排列位置。
-- 对于传入数组的第一行 [10, 10, 30, 20]，结果的对应第一行为 [1, 1, 2, 3]，
-- 表示 10 是在位置 1 和 2 首次出现的第 1 个数字，30 是在位置 3 首次出现的第 2 个数字，
-- 20 是在位置 4 首次出现的第 3 个数字。
-- 对于第二行 [40, 50, 10, 30]，结果的对应第二行为 [4,5,1,2]，表示 40 和 50 分别是该行位置 1 和 2 出现的第 4 和第 5 个数字，
-- 另一个 10（首次出现的数字）位于位置 3，30（第 2 个出现的数字）位于最后一个位置。

SELECT arrayEnumerateDenseRanked(1,[[10,10,30,20],[40,50,10,30]],2);

Response

[[1,1,2,3],[4,5,1,2]]

clear_depth 增大时的示例

Query

-- 将 clear_depth 改为 2 后，枚举将对每一行分别重新开始。

SELECT arrayEnumerateDenseRanked(2,[[10,10,30,20],[40,50,10,30]],2);

Response

[[1, 1, 2, 3], [1, 2, 3, 4]]

arrayEnumerateUniq

引入版本：v1.1.0 返回一个与源数组大小相同的数组，表示每个元素在相同值的元素中所处的位置。此函数在结合 ARRAY JOIN 和数组元素聚合使用时非常有用。该函数可以接受多个大小相同的数组作为参数。在这种情况下，唯一性是根据所有数组中相同位置元素组成的 Tuple 来判定的。语法

arrayEnumerateUniq(arr1[, arr2, ... , arrN])

参数

arr1 — 要处理的第一个数组。Array(T)
arr2, ... — 可选。其他大小相同的数组，用于确定 Tuple 的唯一性。Array(UInt32)

返回值 返回一个数组，其中每个元素表示它在具有相同值或 Tuple 的元素中所处的位置。Array(T) 示例 基本用法

Query

SELECT arrayEnumerateUniq([10, 20, 10, 30]);

Response

[1, 1, 2, 1]

多个数组

Query

SELECT arrayEnumerateUniq([1, 1, 1, 2, 2, 2], [1, 1, 2, 1, 1, 2]);

Response

[1,2,1,1,2,1]

ARRAY JOIN 聚合

Query

-- 每个目标 ID 都会计算转化次数（Goals 嵌套数据结构中的每个元素代表一个已达成的目标，即一次转化）
-- 以及会话数。若不使用 ARRAY JOIN，我们会通过 sum(Sign) 来统计会话数。但在这种情况下，
-- 由于行数已被嵌套的 Goals 结构扩展，为了确保每个会话只被计算一次，我们对
-- arrayEnumerateUniq(Goals.ID) 函数的返回值应用了一个条件。

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

Response

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

arrayEnumerateUniqRanked

引入版本：v20.1.0 返回一个与源数组维度相同的数组 (或多维数组) ，其中会标明每个元素在相同值元素中的位置。它支持对多维数组进行枚举，并且可以指定在数组内部查看到多深。语法

arrayEnumerateUniqRanked(clear_depth, arr, max_array_depth)

参数

clear_depth — 在指定层级分别对元素进行枚举。取值为小于或等于 max_arr_depth 的正整数。UInt*
arr — 要枚举的 N 维数组。Array(T)
max_array_depth — 最大有效深度。取值为小于或等于 arr 深度的正整数。UInt*

返回值 返回一个与 arr 大小相同的 N 维数组，其中每个元素表示该元素在其他相同值元素中的位置。Array(T) 示例 示例 1

Query

-- 当 clear_depth=1 且 max_array_depth=1 时，arrayEnumerateUniqRanked 的结果
-- 与对同一数组使用 arrayEnumerateUniq 所得结果相同。

SELECT arrayEnumerateUniqRanked(1, [1, 2, 1], 1);

Response

[1, 1, 2]

示例 2

Query

-- 当 clear_depth=1 且 max_array_depth=1 时，arrayEnumerateUniqRanked 的结果
-- 与对同一数组使用 arrayEnumerateUniq 所得结果相同。

SELECT arrayEnumerateUniqRanked(1, [[1, 2, 3], [2, 2, 1], [3]], 2);", "[[1, 1, 1], [2, 3, 2], [2]]

Response

[1, 1, 2]

示例 3

Query

-- 在此示例中，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);

Response

[[1, 1, 1], [2, 3, 2], [2]]

示例 4

Query

-- 将 clear_depth 改为 2 后，每行的元素将被单独枚举。
SELECT arrayEnumerateUniqRanked(2,[[1, 2, 3],[2, 2, 1],[3]], 2);

Response

[[1, 1, 1], [1, 2, 1], [1]]

arrayExcept

引入版本：v25.9.0 返回一个数组，包含 source 中存在但 except 中不存在的元素，并保留原有顺序。此函数对两个数组执行集合差集运算。对于 source 中的每个元素，它会检查该元素是否存在于 except 中 (使用精确比较) 。如果不存在，则将该元素包含在结果中。该运算具有以下特性：

保留 source 中元素的顺序
如果 source 中的重复元素不在 except 中，则会保留
NULL 会作为单独的值处理

语法

arrayExcept(source, except)

参数

source — 要进行过滤的源数组。 Array(T)
except — 包含要从结果中排除的元素的数组。 Array(T)

返回值 返回一个与输入数组类型相同的数组，包含 source 中未在 except 中出现的元素。 Array(T) 示例 基本用法

Query

SELECT arrayExcept([1, 2, 3, 2, 4], [3, 5])

Response

[1, 2, 2, 4]

with_nulls1

Query

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

Response

[1, NULL, NULL]

with_nulls2

Query

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

Response

[1]

String

Query

SELECT arrayExcept(['apple', 'banana', 'cherry'], ['banana', 'date'])

Response

['apple', 'cherry']

arrayExists

引入版本：v1.1.0 如果源数组中至少有一个元素使 func(x[, y1, y2, ... yN]) 返回 true，则返回 1；否则返回 0。语法

arrayExists(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

参数

func(x[, y1, ..., yN]) — 一个 Lambda 函数，对源数组 (x) 和条件数组 (y) 中的元素进行操作。Lambda function
source_arr — 要处理的源数组。Array(T)
[, cond1_arr, ... , condN_arr] — 可选。N 个条件数组，为 Lambda 函数提供附加参数。Array(T)

返回值 如果 Lambda 函数对至少一个元素返回 true，则返回 1；否则返回 0 UInt8 示例 使用示例

Query

SELECT arrayExists(x, y -> x=y, [1, 2, 3], [0, 0, 0])

Response

arrayFill

Introduced in：v20.1.0 arrayFill 函数会按顺序处理源数组，从第一个元素一直到最后一个元素，在每个位置使用源数组和条件数组中的元素计算 lambda 条件。当 Lambda 函数在位置 i 的计算结果为 false 时，该函数会将该元素替换为数组当前状态下位置 i-1 的元素。无论条件如何，第一个元素始终会被保留。语法

arrayFill(func(x [, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

参数

func(x [, y1, ..., yN]) — 一个 lambda 函数 func(x [, y1, y2, ... yN]) → F(x [, y1, y2, ... yN])，用于对源数组 (x) 和条件数组 (y) 中的元素进行处理。Lambda function
source_arr — 要处理的源数组。Lambda function
[, cond1_arr, ... , condN_arr] — 可选。N 个条件数组，为 lambda 函数提供额外参数。Array(T)

返回值 返回一个数组 Array(T) 示例 单个数组示例

Query

SELECT arrayFill(x -> not isNull(x), [1, null, 2, null]) AS res

Response

[1, 1, 2, 2]

含两个数组的示例

Query

SELECT arrayFill(x, y, z -> x > y AND x < z, [5, 3, 6, 2], [4, 7, 1, 3], [10, 2, 8, 5]) AS res

Response

[5, 5, 6, 6]

arrayFilter

引入版本：v1.1.0 返回一个数组，其中仅包含源数组中使 Lambda 函数返回 true 的元素。语法

arrayFilter(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])]

参数

func(x[, y1, ..., yN]) — 对源数组 (x) 和条件数组 (y) 中的元素执行操作的 lambda 函数。Lambda function
source_arr — 要处理的源数组。Array(T)
[, cond1_arr, ... , condN_arr] — 可选。N 个条件数组，为 lambda 函数提供额外参数。Array(T)

返回值 返回源数组的一个子集。Array(T) 示例 示例 1

Query

SELECT arrayFilter(x -> x LIKE '%World%', ['Hello', 'abc World']) AS res

Response

['abc World']

示例 2

Query

SELECT
    arrayFilter(
        (i, x) -> x LIKE '%World%',
        arrayEnumerate(arr),
        ['Hello', 'abc World'] AS arr)
    AS res

Response

[2]

arrayFirst

引入版本：v1.1.0 返回源数组中第一个使 func(x[, y1, y2, ... yN]) 返回 true 的元素；否则返回默认值。语法

arrayFirst(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

参数

func(x[, y1, ..., yN]) — 一个 Lambda 函数，用于处理源数组 (x) 和条件数组 (y) 中的元素。Lambda 函数。 - source_arr — 要处理的源数组。Array(T)。 - [, cond1_arr, ... , condN_arr] — 可选。N 个条件数组，为 Lambda 函数提供额外参数。Array(T)。

返回值 返回源数组中第一个满足 λ 为 true 的元素；否则返回 T 的默认值。示例 使用示例

Query

SELECT arrayFirst(x, y -> x=y, ['a', 'b', 'c'], ['c', 'b', 'a'])

Response

无匹配项

Query

SELECT arrayFirst(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)

Response

0 UInt8

arrayFirstIndex

引入版本：v1.1.0 返回源数组中第一个使 func(x[, y1, y2, ... yN]) 返回 true 的元素索引；否则返回 ‘0’。语法

arrayFirstIndex(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

参数

func(x[, y1, ..., yN]) — 对源数组 (x) 和条件数组 (y) 中的元素执行操作的 lambda 函数。Lambda 函数。 - source_arr — 要处理的源数组。Array(T)。 - [, cond1_arr, ... , condN_arr] — 可选。N 个条件数组，为 lambda 函数提供额外参数。Array(T)。

返回值 返回源数组中第一个使 func 为 true 的元素的索引，否则返回 0 UInt32 示例 使用示例

Query

SELECT arrayFirstIndex(x, y -> x=y, ['a', 'b', 'c'], ['c', 'b', 'a'])

Response

无匹配项

Query

SELECT arrayFirstIndex(x, y -> x=y, ['a', 'b', 'c'], ['d', 'e', 'f'])

Response

arrayFirstOrNull

引入版本：v1.1.0 返回源数组中第一个使 func(x[, y1, y2, ... yN]) 返回 true 的元素；否则返回 NULL。语法

arrayFirstOrNull(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

参数

func(x[, y1, ..., yN]) — 一个对源数组 (x) 和条件数组 (y) 中的元素进行操作的 Lambda 函数。Lambda 函数
source_arr — 要处理的源数组。Array(T)
[, cond1_arr, ... , condN_arr] — 可选。N 个条件数组，为 Lambda 函数提供额外参数。Array(T)

返回值 返回源数组中第一个使 func 结果为 true 的元素；否则返回 NULL。示例 使用示例

Query

SELECT arrayFirstOrNull(x, y -> x=y, ['a', 'b', 'c'], ['c', 'b', 'a'])

Response

无匹配项

Query

SELECT arrayFirstOrNull(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)

Response

NULL Nullable(UInt8)

arrayFlatten

引入版本：v20.1.0 将嵌套数组转换为扁平数组。函数：

适用于任意深度的嵌套数组。
不会更改已经是扁平结构的数组。

展平后的数组包含所有源数组中的全部元素。语法

arrayFlatten(arr)

别名: flatten 参数

arr — 多维数组。Array(Array(T))

返回值 返回由多维数组展平后的数组 Array(T) 示例 使用示例

Query

SELECT arrayFlatten([[[1]], [[2], [3]]]);

Response

[1, 2, 3]

arrayFold

首次引入版本：v23.10.0 将 lambda function 应用于一个或多个等长数组，并将结果累积到累加器中。语法

arrayFold(λ(acc, x1 [, x2, x3, ... xN]), arr1 [, arr2, arr3, ... arrN], acc)

参数

λ(x, x1 [, x2, x3, ... xN]) — 一个 Lambda 函数 λ(acc, x1 [, x2, x3, ... xN]) → F(acc, x1 [, x2, x3, ... xN])，其中 F 是应用于 acc 和来自 x 的数组值的操作，并会重复使用 acc 的结果。Lambda function
arr1 [, arr2, arr3, ... arrN] — 要操作的 N 个数组。Array(T)
acc — 累加器值，其类型与 Lambda 函数的返回类型相同。

返回值 返回最终的 acc 值。示例 使用示例

Query

SELECT arrayFold(acc,x -> acc + x*2, [1, 2, 3, 4], 3::Int64) AS res;

Response

斐波那契数列

Query

SELECT arrayFold(acc, x -> (acc.2, acc.2 + acc.1),range(number),(1::Int64, 0::Int64)).1 AS fibonacci FROM numbers(1,10);

Response

┌─fibonacci─┐
│         0 │
│         1 │
│         1 │
│         2 │
│         3 │
│         5 │
│         8 │
│        13 │
│        21 │
│        34 │
└───────────┘

多个数组示例

Query

SELECT arrayFold(
(acc, x, y) -> acc + (x * y),
[1, 2, 3, 4],
[10, 20, 30, 40],
0::Int64
) AS res;

Response

arrayIntersect

引入版本：v1.1.0 接受多个数组，并返回一个数组，其中包含所有源数组中都存在的元素。结果仅包含唯一值。语法

arrayIntersect(arr, arr1, ..., arrN)

参数

arrN — 用于构造新数组的 N 个数组。Array(T)。

返回值 返回一个数组，其中包含在所有 N 个数组中都存在且互不重复的元素 Array(T) 示例 使用示例

Query

SELECT
arrayIntersect([1, 2], [1, 3], [2, 3]) AS empty_intersection,
arrayIntersect([1, 2], [1, 3], [1, 4]) AS non_empty_intersection

Response

┌─empty_intersection─┬─non_empty_intersection─┐
│ []                 │ [1]                    │
└────────────────────┴────────────────────────┘

arrayJaccardIndex

引入版本：v23.7.0 返回两个数组的 Jaccard 指数。语法

arrayJaccardIndex(arr_x, arr_y)

参数

arr_x — 第一个数组。Array(T)
arr_y — 第二个数组。Array(T)

返回值 返回 arr_x 和 arr_y 的 Jaccard 指数。Float64 示例 使用示例

Query

SELECT arrayJaccardIndex([1, 2], [2, 3]) AS res

Response

0.3333333333333333

arrayJoin

Introduced in: v1.1.0 arrayJoin 函数会接收一行中包含的数组并将其展开，生成多行——数组中的每个元素对应一行。这与 ClickHouse 中的常规函数不同：常规函数是在同一行内将输入值映射为输出值，而聚合函数则接收一组行，并将其“压缩”或“归约”为单个汇总行 (如果与 GROUP BY 一起使用，则为汇总行中的单个值) 。各列中的所有值都会被直接复制，但应用此函数的那一列除外；该列中的值会被替换为对应的数组元素值。语法

arrayJoin(arr)

别名: unnest 参数

arr — 要展开的数组。Array(T)

返回值 返回由 arr 展开得到的一组行。示例 基本用法

Query

SELECT arrayJoin([1, 2, 3] AS src) AS dst, 'Hello', src

Response

┌─dst─┬─\'Hello\'─┬─src─────┐
│   1 │ Hello     │ [1,2,3] │
│   2 │ Hello     │ [1,2,3] │
│   3 │ Hello     │ [1,2,3] │
└─────┴───────────┴─────────┘

arrayJoin 会影响查询的各个部分

Query

-- arrayJoin 函数会影响查询的各个部分，包括 WHERE 子句。注意结果是 2，尽管子查询只返回了 1 行。

SELECT sum(1) AS impressions
FROM
(
    SELECT ['Istanbul', 'Berlin', 'Bobruisk'] AS cities
)
WHERE arrayJoin(cities) IN ['Istanbul', 'Berlin'];

Response

┌─impressions─┐
│           2 │
└─────────────┘

多个 arrayJoin 函数的用法

Query

- A query can use multiple arrayJoin functions. In this case, the transformation is performed multiple times and the rows are multiplied.

SELECT
    sum(1) AS impressions,
    arrayJoin(cities) AS city,
    arrayJoin(browsers) AS browser
FROM
(
    SELECT
        ['Istanbul', 'Berlin', 'Bobruisk'] AS cities,
        ['Firefox', 'Chrome', 'Chrome'] AS browsers
)
GROUP BY
    2,
    3

Response

┌─impressions─┬─city─────┬─browser─┐
│           2 │ Istanbul │ Chrome  │
│           1 │ Istanbul │ Firefox │
│           2 │ Berlin   │ Chrome  │
│           1 │ Berlin   │ Firefox │
│           2 │ Bobruisk │ Chrome  │
│           1 │ Bobruisk │ Firefox │
└─────────────┴──────────┴─────────┘

优化导致的非预期结果

Query

-- 由于优化，对同一表达式多次使用 arrayJoin 可能得不到预期结果。
-- 在这种情况下，可以考虑给重复的数组表达式附加一些不会影响 join 结果的额外操作。
- e.g. arrayJoin(arraySort(arr)), arrayJoin(arrayConcat(arr, []))

SELECT
    arrayJoin(dice) as first_throw,
    /* arrayJoin(dice) as second_throw */ -- 从技术上说这样写是正确的，但会让结果集为空
    arrayJoin(arrayConcat(dice, [])) as second_throw -- 有意改写表达式，以强制重新计算
FROM (
    SELECT [1, 2, 3, 4, 5, 6] as dice
);

Response

┌─first_throw─┬─second_throw─┐
│           1 │            1 │
│           1 │            2 │
│           1 │            3 │
│           1 │            4 │
│           1 │            5 │
│           1 │            6 │
│           2 │            1 │
│           2 │            2 │
│           2 │            3 │
│           2 │            4 │
│           2 │            5 │
│           2 │            6 │
│           3 │            1 │
│           3 │            2 │
│           3 │            3 │
│           3 │            4 │
│           3 │            5 │
│           3 │            6 │
│           4 │            1 │
│           4 │            2 │
│           4 │            3 │
│           4 │            4 │
│           4 │            5 │
│           4 │            6 │
│           5 │            1 │
│           5 │            2 │
│           5 │            3 │
│           5 │            4 │
│           5 │            5 │
│           5 │            6 │
│           6 │            1 │
│           6 │            2 │
│           6 │            3 │
│           6 │            4 │
│           6 │            5 │
│           6 │            6 │
└─────────────┴──────────────┘

使用 ARRAY JOIN 语法

Query

-- 请注意下方 `SELECT` 查询中的 ARRAY JOIN 语法，这种写法提供了更多可能性。
-- ARRAY JOIN 允许你一次性转换多个元素个数相同的数组。

SELECT
    sum(1) AS impressions,
    city,
    browser
FROM
(
    SELECT
        ['Istanbul', 'Berlin', 'Bobruisk'] AS cities,
        ['Firefox', 'Chrome', 'Chrome'] AS browsers
)
ARRAY JOIN
    cities AS city,
    browsers AS browser
GROUP BY
    2,
    3

Response

┌─impressions─┬─city─────┬─browser─┐
│           1 │ Istanbul │ Firefox │
│           1 │ Berlin   │ Chrome  │
│           1 │ Bobruisk │ Chrome  │
└─────────────┴──────────┴─────────┘

使用 Tuple

Query

-- 也可以使用 Tuple

SELECT
    sum(1) AS impressions,
    (arrayJoin(arrayZip(cities, browsers)) AS t).1 AS city,
    t.2 AS browser
FROM
(
    SELECT
        ['Istanbul', 'Berlin', 'Bobruisk'] AS cities,
        ['Firefox', 'Chrome', 'Chrome'] AS browsers
)
GROUP BY
    2,
    3

Response

┌─impressions─┬─city─────┬─browser─┐
│           1 │ Istanbul │ Firefox │
│           1 │ Berlin   │ Chrome  │
│           1 │ Bobruisk │ Chrome  │
└─────────────┴──────────┴─────────┘

arrayLast

引入版本：v1.1.0 返回源数组中最后一个使 lambda func(x [, y1, y2, ... yN]) 返回 true 的元素；否则返回默认值。语法

arrayLast(func(x[, y1, ..., yN]), source[, cond1, ... , condN_arr])

参数

func(x[, y1, ..., yN]) — 一个对源数组 (x) 和条件数组 (y) 中的元素进行处理的 lambda 函数。Lambda 函数。 - source — 要处理的源数组。Array(T)。 - [, cond1, ... , condN] — 可选。N 个条件数组，用于为 lambda 函数提供额外参数。Array(T)。

返回值 返回源数组中最后一个使 func 返回 true 的元素；否则返回 T 的默认值。示例 使用示例

Query

SELECT arrayLast(x, y -> x=y, ['a', 'b', 'c'], ['a', 'b', 'c'])

Response

无匹配项

Query

SELECT arrayFirst(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)

Response

0 UInt8

arrayLastIndex

首次引入版本：v1.1.0 返回源数组中最后一个使 func(x[, y1, y2, ... yN]) 返回 true 的元素索引；否则返回 ‘0’。语法

arrayLastIndex(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

参数

func(x[, y1, ..., yN]) — 对源数组 (x) 和条件数组 (y) 中的元素进行处理的 lambda 函数。Lambda 函数
source_arr — 要处理的源数组。Array(T)
[, cond1_arr, ... , condN_arr] — 可选。N 个条件数组，为 lambda 函数提供额外参数。Array(T)

返回值 返回源数组中最后一个使 func 为 true 的元素的索引；否则返回 0。UInt32 示例 用法示例

Query

SELECT arrayLastIndex(x, y -> x=y, ['a', 'b', 'c'], ['a', 'b', 'c']);

Response

无匹配项

Query

SELECT arrayLastIndex(x, y -> x=y, ['a', 'b', 'c'], ['d', 'e', 'f']);

Response

arrayLastOrNull

引入版本：v1.1.0 返回源数组中最后一个使 lambda func(x [, y1, y2, ... yN]) 返回 true 的元素；否则返回 NULL。语法

arrayLastOrNull(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

参数

func(x [, y1, ..., yN]) — 一个对源数组 (x) 和条件数组 (y) 中的元素进行处理的 lambda 函数。Lambda 函数。 - source_arr — 要处理的源数组。Array(T)。 - [, cond1_arr, ... , condN_arr] — 可选。N 个条件数组，用于为 lambda 函数提供额外参数。Array(T)。

返回值 返回源数组中最后一个使 λ 不为 true 的元素，否则返回 NULL。示例 用法示例

Query

SELECT arrayLastOrNull(x, y -> x=y, ['a', 'b', 'c'], ['a', 'b', 'c'])

Response

无匹配

Query

SELECT arrayLastOrNull(x, y -> x=y, [0, 1, 2], [3, 3, 3]) AS res, toTypeName(res)

Response

NULL Nullable(UInt8)

arrayLevenshteinDistance

引入版本：v25.4.0 计算两个数组之间的 Levenshtein 距离。语法

arrayLevenshteinDistance(from, to)

参数

from — 第一个数组。Array(T)。 - to — 第二个数组。Array(T)。

返回值 第一个数组和第二个数组之间的 Levenshtein 距离。Float64 示例 用法示例

Query

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

Response

arrayLevenshteinDistanceWeighted

引入版本：v25.4.0 计算两个数组的 Levenshtein 距离，并为每个元素应用自定义权重。数组中的元素数量应与其权重数量一致。语法

arrayLevenshteinDistanceWeighted(from, to, from_weights, to_weights)

参数

from — 第一个数组。Array(T)。 - to — 第二个数组。Array(T)。 - from_weights — 第一个数组中各元素的权重。Array((U)Int*|Float*)
to_weights — 第二个数组中各元素的权重。Array((U)Int*|Float*)

返回值 带有各元素自定义权重的第一个数组与第二个数组之间的 Levenshtein 距离。Float64 示例 使用示例

Query

SELECT arrayLevenshteinDistanceWeighted(['A', 'B', 'C'], ['A', 'K', 'L'], [1.0, 2, 3], [3.0, 4, 5])

Response

arrayMap

始于版本：v1.1.0 返回一个通过对原始数组中的每个元素应用 lambda function 而生成的数组。语法

arrayMap(func, arr)

参数

func — 一个作用于源数组 (x) 和条件数组 (y) 元素的 lambda 函数。Lambda 函数
arr — 要处理的 N 个数组。Array(T)

返回值 返回由 lambda 函数结果组成的数组 Array(T) 示例 使用示例

Query

SELECT arrayMap(x -> (x + 2), [1, 2, 3]) as res;

Response

[3, 4, 5]

从不同数组中创建由元素组成的元组

Query

SELECT arrayMap((x, y) -> (x, y), [1, 2, 3], [4, 5, 6]) AS res

Response

[(1, 4),(2, 5),(3, 6)]

arrayMax

引入版本：v21.1.0 返回输入数组中的最大元素。如果指定了 lambda 函数 func，则返回 lambda 计算结果中的最大元素。语法

arrayMax([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])

参数

func(x[, y1, ..., yN]) — 可选。对源数组 (x) 和条件数组 (y) 中的元素进行处理的 Lambda 函数。Lambda 函数
source_arr — 要处理的源数组。Array(T)
[, cond1_arr, ... , condN_arr] — 可选。N 个条件数组，为 Lambda 函数提供额外参数。Array(T)

返回值 返回源数组中的最大元素；如果提供了 Lambda 函数，则返回 Lambda 结果中的最大元素。示例 基本示例

Query

SELECT arrayMax([5, 3, 2, 7]);

Response

与 lambda function 一起使用

Query

SELECT arrayMax(x, y -> x/y, [4, 8, 12, 16], [1, 2, 1, 2]);

Response

arrayMin

引入版本：v21.1.0 返回源数组中的最小元素。如果指定了 Lambda 函数 func，则返回 lambda 计算结果中的最小元素。语法

arrayMin([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])

参数

func(x[, y1, ..., yN]) — 可选。一个作用于源数组 (x) 和条件数组 (y) 元素的 lambda 函数。Lambda function
source_arr — 要处理的源数组。Array(T)
cond1_arr, ... — 可选。N 个条件数组，用于为 lambda 函数提供额外参数。Array(T)

返回值 返回源数组中的最小元素；如果提供了 lambda 函数，则返回 lambda 计算结果中的最小元素。示例 基本示例

Query

SELECT arrayMin([5, 3, 2, 7]);

Response

与 lambda 函数结合使用

Query

SELECT arrayMin(x, y -> x/y, [4, 8, 12, 16], [1, 2, 1, 2]);

Response

arrayNormalizedGini

自 v25.1.0 起引入计算归一化 Gini 系数。语法

arrayNormalizedGini(predicted, label)

参数

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

返回值 一个 Tuple，其中包含预测值的 Gini 系数、归一化值的 Gini 系数，以及归一化 Gini 系数 (= 前两个 Gini 系数的比值) Tuple(Float64, Float64, Float64) 示例 使用示例

Query

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

Response

(0.18055555555555558, 0.2638888888888889, 0.6842105263157896)

arrayPartialReverseSort

引入版本：v23.2.0 此函数与 arrayReverseSort 相同，但额外提供了一个 limit 参数，以支持部分排序。

如需仅保留已排序的元素，请使用 arrayResize。

语法

arrayPartialReverseSort([f,] arr [, arr1, ... ,arrN], limit)

参数

f(arr[, arr1, ... ,arrN]) — 应用于数组 arr 元素的 lambda 函数。Lambda function
arr — 要排序的数组。Array(T)
arr1, ... ,arrN — 当 f 接受多个参数时，额外的 N 个数组。Array(T)
limit — 排序进行到的索引位置。(U)Int*

返回值 返回一个与原始数组大小相同的数组，其中 [1..limit] 范围内的元素按降序排序，其余元素 (limit..N] 的顺序未指定。示例 simple_int

Query

SELECT arrayPartialReverseSort(2, [5, 9, 1, 3])

Response

[9, 5, 1, 3]

simple_string

Query

SELECT arrayPartialReverseSort(2, ['expenses','lasso','embolism','gladly'])

Response

['lasso','gladly','expenses','embolism']

retain_sorted

Query

SELECT arrayResize(arrayPartialReverseSort(2, [5, 9, 1, 3]), 2)

Response

[9, 5]

lambda_simple

Query

SELECT arrayPartialReverseSort((x) -> -x, 2, [5, 9, 1, 3])

Response

[1, 3, 5, 9]

lambda_complex

Query

SELECT arrayPartialReverseSort((x, y) -> -y, 1, [0, 1, 2], [1, 2, 3]) as res

Response

[0, 1, 2]

arrayPartialShuffle

引入版本：v23.2.0 返回一个与原始数组大小相同的数组，其中 [1..limit] 范围内的元素是原始数组中的一个随机子集。其余的 (limit..n] 部分包含不在 [1..limit] 范围内的元素，顺序未定义。 limit 的取值应在 [1..n] 范围内。超出该范围的值等同于执行完整的 arrayShuffle：

此函数不会将常量物化。limit 的取值应在 [1..N] 范围内。超出该范围的值等同于执行完整的 arrayShuffle。

语法

arrayPartialShuffle(arr [, limit[, seed]])

参数

arr — 要随机打乱的数组。Array(T)
seed — 可选。用于生成随机数的种子。如果未提供，则使用随机种子。(U)Int*
limit — 可选。限制元素交换次数的数值，取值范围为 [1..N]。(U)Int*

返回值 元素被部分打乱后的数组。Array(T) 示例 no_limit1

Query

SELECT arrayPartialShuffle([1, 2, 3, 4], 0)

Response

[2, 4, 3, 1]

no_limit2

Query

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

Response

[4, 1, 3, 2]

random_seed

Query

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

Response

[3, 4, 1, 2]

explicit_seed

Query

SELECT arrayPartialShuffle([1, 2, 3, 4], 2, 41)

Response

[3, 2, 1, 4]

物化

Query

SELECT arrayPartialShuffle(materialize([1, 2, 3, 4]), 2, 42), arrayPartialShuffle([1, 2, 3], 2, 42) FROM numbers(10)

Response

┌─arrayPartial⋯4]), 2, 42)─┬─arrayPartial⋯ 3], 2, 42)─┐
│ [3,2,1,4]                │ [3,2,1]                  │
│ [3,2,1,4]                │ [3,2,1]                  │
│ [4,3,2,1]                │ [3,2,1]                  │
│ [1,4,3,2]                │ [3,2,1]                  │
│ [3,4,1,2]                │ [3,2,1]                  │
│ [1,2,3,4]                │ [3,2,1]                  │
│ [1,4,3,2]                │ [3,2,1]                  │
│ [1,4,3,2]                │ [3,2,1]                  │
│ [3,1,2,4]                │ [3,2,1]                  │
│ [1,3,2,4]                │ [3,2,1]                  │
└──────────────────────────┴──────────────────────────┘

arrayPartialSort

引入版本：v23.2.0 此函数与 arraySort 相同，但额外提供了 limit 参数，可进行部分排序。

如需仅保留已排序的元素，请使用 arrayResize。

语法

arrayPartialSort([f,] arr [, arr1, ... ,arrN], limit)

参数

f(arr[, arr1, ... ,arrN]) — 用于处理数组 x 中元素的 lambda 函数。Lambda function
arr — 要排序的数组。Array(T)
arr1, ... ,arrN — 当 f 接受多个参数时，额外的 N 个数组。Array(T)
limit — 排序将进行到的索引值。(U)Int*

返回值 返回一个与原始数组大小相同的数组，其中 [1..limit] 范围内的元素按升序排序。其余元素 (limit..N] 的顺序未指定。示例 simple_int

Query

SELECT arrayPartialSort(2, [5, 9, 1, 3])

Response

[1, 3, 5, 9]

simple_string

Query

SELECT arrayPartialSort(2, ['expenses', 'lasso', 'embolism', 'gladly'])

Response

['embolism', 'expenses', 'gladly', 'lasso']

retain_sorted

Query

SELECT arrayResize(arrayPartialSort(2, [5, 9, 1, 3]), 2)

Response

[1, 3]

lambda_simple

Query

SELECT arrayPartialSort((x) -> -x, 2, [5, 9, 1, 3])

Response

[9, 5, 1, 3]

lambda_complex

Query

SELECT arrayPartialSort((x, y) -> -y, 1, [0, 1, 2], [1, 2, 3]) as res

Response

[2, 1, 0]

arrayPopBack

引入版本：v1.1.0 移除数组中的最后一个元素。语法

arrayPopBack(arr)

参数

arr — 要移除其最后一个元素的数组。Array(T)

返回值 返回一个与 arr 相同但不包含其最后一个元素的数组 Array(T) 示例 使用示例

Query

SELECT arrayPopBack([1, 2, 3]) AS res;

Response

[1, 2]

arrayPopFront

Introduced in: v1.1.0 删除数组中的第一个元素。 Syntax

arrayPopFront(arr)

参数

arr — 要删除其首个元素的数组。Array(T)

返回值 返回一个与 arr 相同但不包含其首个元素的数组 Array(T) 示例 用法示例

Query

SELECT arrayPopFront([1, 2, 3]) AS res;

Response

[2, 3]

arrayProduct

引入版本：v21.1.0 返回源数组中各元素的乘积。如果指定了 lambda 函数 func，则返回 lambda 计算结果中各元素的乘积。语法

arrayProduct([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])

参数

func(x[, y1, ..., yN]) — 可选。对源数组 (x) 和条件数组 (y) 中的元素进行处理的 lambda 函数。lambda function
source_arr — 要处理的源数组。Array(T)
[, cond1_arr, ... , condN_arr] — 可选。N 个条件数组，用于为 lambda 函数提供额外参数。Array(T)

返回值 返回源数组中各元素的乘积；如果提供了 lambda 函数，则返回 lambda 计算结果中各元素的乘积。Float64 示例 基本示例

Query

SELECT arrayProduct([1, 2, 3, 4]);

Response

结合 lambda 函数使用

Query

SELECT arrayProduct(x, y -> x+y, [2, 2], [2, 2]) AS res;

Response

arrayPushBack

引入版本：v1.1.0 在数组末尾添加一个元素。语法

arrayPushBack(arr, x)

参数

arr — 要在其末尾添加值 x 的数组。Array(T)
x —
要添加到数组末尾的单个值。Array(T)。

只有数值才能添加到数值数组中，只有字符串才能添加到字符串数组中。
添加数值时，ClickHouse 会根据数组的数据类型自动设置 x 的类型。
可以为 NULL。该函数会向数组中添加一个 NULL 元素，并将数组元素的类型转换为 Nullable。

有关 ClickHouse 中数据类型的更多信息，请参见数据类型。

返回值 返回一个与 arr 相同、但在数组末尾额外添加了值 x 的数组 Array(T) 示例 使用示例

Query

SELECT arrayPushBack(['a'], 'b') AS res;

Response

['a','b']

arrayPushFront

自 v1.1.0 起引入在数组的开头添加一个元素。语法

arrayPushFront(arr, x)

参数

arr — 要在末尾添加值 x 的数组。Array(T)。- x —
要添加到数组开头的单个值。Array(T)。

只有数值才能添加到数值数组中，只有字符串才能添加到字符串数组中。
添加数值时，ClickHouse 会根据数组的数据类型自动设置 x 的类型。
可以为 NULL。该函数会向数组中添加一个 NULL 元素，并将数组元素的类型转换为 Nullable。

有关 ClickHouse 中数据类型的更多信息，请参见数据类型。

返回值 返回一个与 arr 相同的数组，但在数组开头额外添加了一个值 x Array(T) 示例 使用示例

Query

SELECT arrayPushFront(['b'], 'a') AS res;

Response

['a','b']

arrayROCAUC

引入版本：v20.4.0 计算受试者工作特征 (ROC) 曲线下面积。 ROC 曲线通过在所有阈值下，以 y 轴表示真正率 (TPR) 、以 x 轴表示假正率 (FPR) 来绘制。结果值的范围为 0 到 1，值越高表示模型性能越好。 ROC AUC (也简称为 AUC) 是机器学习中的一个概念。更多详情，请参见这里、这里和这里。语法

arrayROCAUC(scores, labels[, scale[, partial_offsets]])

别名: arrayAUC 参数

scores — 预测模型给出的分数。Array((U)Int*) 或 Array(Float*)
labels — 样本标签，通常正样本为 1，负样本为 0。Array((U)Int*) 或 枚举
scale — 可选。决定是否返回归一化后的面积。如果为 false，则返回 TP (真正例) × FP (假正例) 曲线下的面积。默认值：true。Bool
partial_offsets —
一个包含四个非负整数的数组，用于计算 ROC 曲线下的部分面积 (相当于 ROC 空间中的一个垂直带) ，而不是整个 AUC。此选项适用于 ROC AUC 的分布式计算。该数组必须包含以下元素 [higher_partitions_tp, higher_partitions_fp, total_positives, total_negatives]。Array (元素为非负 Integer) 。可选。
- 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 示例 用法示例

Query

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

Response

0.75

arrayRandomSample

引入版本：v23.10.0 返回输入数组中随机选取的 samples 个元素组成的子集。如果 samples 超过输入数组的大小，则样本数会限制为数组大小，也就是说会返回数组中的所有元素，但不保证其顺序。该函数既可处理扁平数组，也可处理嵌套数组。语法

arrayRandomSample(arr, samples)

参数

arr — 用于从中抽样元素的输入数组或多维数组。Array(T)
samples — 随机样本中包含的元素个数。(U)Int*

返回值 一个数组，包含从输入数组中随机抽取的元素 Array(T) 示例 使用示例

Query

SELECT arrayRandomSample(['apple', 'banana', 'cherry', 'date'], 2) as res;

Response

['cherry','apple']

使用多维数组

Query

SELECT arrayRandomSample([[1, 2], [3, 4], [5, 6]], 2) as res;

Response

[[3,4],[5,6]]

arrayReduce

Introduced in：v1.1.0 对数组元素应用聚合函数，并返回其结果。聚合函数的名称以单引号括起的字符串形式传入，例如 'max'、'sum'。使用参数化聚合函数时，参数写在函数名后的括号中，例如 'uniqUpTo(6)'。 Syntax

arrayReduce(agg_f, arr1[, arr2, ... , arrN])

参数

agg_f — 聚合函数的名称，必须为常量。String
arr1[, arr2, ... , arrN] — 与 agg_f 的参数相对应的 N 个数组。Array(T)

返回值 返回聚合函数的结果。示例 用法示例

Query

SELECT arrayReduce('max', [1, 2, 3]);

Response

┌─arrayReduce('max', [1, 2, 3])─┐
│                             3 │
└───────────────────────────────┘

使用多个参数的聚合函数示例

Query

--如果聚合函数接受多个参数，则必须将该函数应用于多个大小相同的数组。

SELECT arrayReduce('maxIf', [3, 5], [1, 0]);

Response

┌─arrayReduce('maxIf', [3, 5], [1, 0])─┐
│                                    3 │
└──────────────────────────────────────┘

参数化聚合函数示例

Query

SELECT arrayReduce('uniqUpTo(3)', [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);

Response

┌─arrayReduce('uniqUpTo(3)', [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])─┐
│                                                           4 │
└─────────────────────────────────────────────────────────────┘

arrayReduceInRanges

引入版本：v20.4.0 对给定范围内的数组元素应用聚合函数，并返回一个数组，其中包含每个范围对应的结果。该函数返回的结果与多次执行 arrayReduce(agg_func, arraySlice(arr1, index, length), ...) 相同。语法

arrayReduceInRanges(agg_f, ranges, arr1[, arr2, ... ,arrN])

参数

agg_f — 要使用的聚合函数名称。String
ranges — 要聚合的范围。由元组 (i, r) 组成的数组，其中 i 表示起始索引，r 表示聚合范围。Array(T) 或 Tuple(T)
arr1[, arr2, ... ,arrN] — 作为聚合函数参数的 N 个数组。Array(T)

返回值 返回一个数组，包含在指定范围内执行聚合函数得到的结果。Array(T) 示例 使用示例

Query

SELECT arrayReduceInRanges(
    'sum',
    [(1, 5), (2, 3), (3, 4), (4, 4)],
    [1000000, 200000, 30000, 4000, 500, 60, 7]
) AS res

Response

┌─res─────────────────────────┐
│ [1234500,234000,34560,4567] │
└─────────────────────────────┘

arrayRemove

引入版本：v25.11.0 从数组中删除所有等于给定值的元素。 NULL 视为相等。语法

arrayRemove(arr, elem)

别名：array_remove 参数

arr — Array(T) - elem — T

返回值 返回源数组的一个子集 Array(T) 示例 示例 1

Query

SELECT arrayRemove([1, 2, 2, 3], 2)

Response

[1, 3]

示例 2

Query

SELECT arrayRemove(['a', NULL, 'b', NULL], NULL)

Response

['a', 'b']

arrayResize

引入于：v1.1.0 修改数组的长度。语法

arrayResize(arr, size[, extender])

参数

arr — 要调整大小的数组。Array(T)
size — -数组的新长度。如果 size 小于数组的原始长度，则从右侧截断数组。如果 size 大于数组的初始长度，则在右侧使用 extender 值或数组元素数据类型的默认值对数组进行扩展。
extender — 用于扩展数组的值。可以为 NULL。

返回值 长度为 size 的数组。Array(T) 示例 示例 1

Query

SELECT arrayResize([1], 3);

Response

[1,0,0]

示例 2

Query

SELECT arrayResize([1], 3, NULL);

Response

[1,NULL,NULL]

arrayReverse

引入版本：v1.1.0 将给定数组中元素的顺序反转。

函数 reverse(arr) 具有相同的功能，但除了 Array 类型外，还可用于其他数据类型。

语法

arrayReverse(arr)

参数

arr — 要反转的数组。Array(T)

返回值 返回一个与原始数组大小相同、元素顺序相反的数组。Array(T) 示例 使用示例

Query

SELECT arrayReverse([1, 2, 3])

Response

[3,2,1]

arrayReverseFill

Introduced in：v20.1.0 arrayReverseFill 函数会从最后一个元素开始，按顺序向前处理源数组直到第一个元素，并在每个位置使用源数组和条件数组中的元素对 lambda 条件进行求值。当位置 i 处的条件求值结果为 false 时，函数会用数组当前状态中位置 i+1 处的元素替换该位置的元素。无论条件如何，最后一个元素始终会被保留。 Syntax

arrayReverseFill(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

参数

func(x[, y1, ..., yN]) — 一个 lambda 函数，对源数组 (x) 和条件数组 (y) 中的元素进行处理。Lambda function
source_arr — 要处理的源数组。Array(T)
[, cond1_arr, ... , condN_arr] — 可选。N 个条件数组，为 lambda 函数提供额外参数。Array(T)

返回值 返回一个数组，其中源数组中的元素会被替换为 lambda 函数的结果。Array(T) 示例 单个数组示例

Query

SELECT arrayReverseFill(x -> not isNull(x), [1, null, 2, null]) AS res

Response

[1, 2, 2, NULL]

两个数组的示例

Query

SELECT arrayReverseFill(x, y, z -> x > y AND x < z, [5, 3, 6, 2], [4, 7, 1, 3], [10, 2, 8, 5]) AS res;

Response

[5, 6, 6, 2]

arrayReverseSort

引入版本：v1.1.0 按降序对数组元素进行排序。如果指定了函数 f，则会根据该函数作用于数组元素后得到的结果对给定数组排序，然后再将排序后的数组反转。如果 f 接受多个参数，则会向 arrayReverseSort 函数传入多个数组，这些数组分别对应 func 的参数。如果待排序的数组包含 -Inf、NULL、NaN 或 Inf，它们将按以下顺序排序：

-Inf
Inf
NaN
NULL

arrayReverseSort 是一个高阶函数。语法

arrayReverseSort([f,] arr [, arr1, ... ,arrN)

参数

f(y1[, y2 ... yN]) — 应用于数组 x 元素的 Lambda 函数。 - arr — 要排序的数组。Array(T) - arr1, ..., yN — 可选。当 f 接受多个参数时，表示额外的 N 个数组。

返回值 如果未提供 Lambda 函数，则返回按降序排序的数组 x；否则，返回先按所提供 Lambda 函数的逻辑排序、再反转后的数组。Array(T)。示例 示例 1

Query

SELECT arrayReverseSort((x, y) -> y, [4, 3, 5], ['a', 'b', 'c']) AS res;

Response

[5,3,4]

示例 2

Query

SELECT arrayReverseSort((x, y) -> -y, [4, 3, 5], [1, 2, 3]) AS res;

Response

[4,3,5]

arrayReverseSplit

Introduced in：v20.1.0 将源数组拆分为多个数组。当 func(x[, y1, ..., yN]) 返回非零值时，数组会在该元素右侧拆分。最后一个元素之后不会拆分。语法

arrayReverseSplit(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

参数

func(x[, y1, ..., yN]) — 对源数组 (x) 和条件数组 (y) 中的元素执行操作的 lambda 函数。Lambda 函数
source_arr — 要处理的源数组。Lambda 函数
[, cond1_arr, ... , condN_arr] — 可选。N 个条件数组，为 lambda 函数提供额外参数。Array(T)

返回值 返回一个嵌套数组。Array(Array(T)) 示例 使用示例

Query

SELECT arrayReverseSplit((x, y) -> y, [1, 2, 3, 4, 5], [1, 0, 0, 1, 0]) AS res

Response

[[1], [2, 3, 4], [5]]

arrayRotateLeft

引入版本：v23.8.0 将数组按指定的元素个数向左旋转。n 为负值时，会按旋转量的绝对值向右旋转。语法

arrayRotateLeft(arr, n)

参数

arr — 要旋转其元素的数组。Array(T)。 - n — 要旋转的元素个数。(U)Int8/16/32/64。

返回值 按指定个数向左旋转后的数组 Array(T) 示例 使用示例

Query

SELECT arrayRotateLeft([1,2,3,4,5,6], 2) as res;

Response

[3,4,5,6,1,2]

n 为负值时

Query

SELECT arrayRotateLeft([1,2,3,4,5,6], -2) as res;

Response

[5,6,1,2,3,4]

arrayRotateRight

引入版本：v23.8.0 将数组按指定的元素个数向右旋转。n 为负值时，会按其绝对值向左旋转。语法

arrayRotateRight(arr, n)

参数

arr — 其元素需要进行旋转的数组。Array(T)。 - n — 要旋转的元素个数。(U)Int8/16/32/64。

返回值 按指定元素个数向右旋转后的数组 Array(T) 示例 用法示例

Query

SELECT arrayRotateRight([1,2,3,4,5,6], 2) as res;

Response

[5,6,1,2,3,4]

n 为负值时

Query

SELECT arrayRotateRight([1,2,3,4,5,6], -2) as res;

Response

[3,4,5,6,1,2]

arrayShiftLeft

引入版本：v23.8.0 将数组按指定的元素数量向左移位。新元素用提供的参数或数组元素类型的默认值填充。如果元素数量为负数，则数组会向右移位。语法

arrayShiftLeft(arr, n[, default])

参数

arr — 要进行元素移位的数组。Array(T)。 - n — 要移位的元素个数。(U)Int8/16/32/64。 - default — 可选。新元素的默认值。

返回值 按指定元素个数向左移位后的数组 Array(T) 示例 使用示例

Query

SELECT arrayShiftLeft([1,2,3,4,5,6], 2) as res;

Response

[3,4,5,6,0,0]

n 为负值时

Query

SELECT arrayShiftLeft([1,2,3,4,5,6], -2) as res;

Response

[0,0,1,2,3,4]

使用默认值

Query

SELECT arrayShiftLeft([1,2,3,4,5,6], 2, 42) as res;

Response

[3,4,5,6,42,42]

arrayShiftRight

Introduced in: v23.8.0 将数组按指定的元素个数向右移位。新增元素将用提供的参数或数组元素类型的默认值填充。如果元素个数为负数，则数组会向左移位。 Syntax

arrayShiftRight(arr, n[, default])

参数

arr — 要进行元素移位的数组。Array(T)
n — 要移位的元素个数。(U)Int8/16/32/64
default — 可选。新元素的默认值。

返回值 按指定元素个数向右移位后的数组 Array(T) 示例 使用示例

Query

SELECT arrayShiftRight([1, 2, 3, 4, 5, 6], 2) as res;

Response

[0, 0, 1, 2, 3, 4]

n 为负值时

Query

SELECT arrayShiftRight([1, 2, 3, 4, 5, 6], -2) as res;

Response

[3, 4, 5, 6, 0, 0]

使用默认值

Query

SELECT arrayShiftRight([1, 2, 3, 4, 5, 6], 2, 42) as res;

Response

[42, 42, 1, 2, 3, 4]

arrayShingles

版本引入：v24.1.0 生成一个由 shingle 组成的数组 (类似于字符串的 ngram) ，即按指定长度从输入数组中生成连续的子数组。语法

arrayShingles(arr, l)

参数

arr — 用于生成 shingle 数组的 Array。Array(T)
l — 每个 shingle 的长度。(U)Int*

返回值 生成的 shingle 数组 Array(T) 示例 使用示例

Query

SELECT arrayShingles([1, 2, 3, 4], 3) as res;

Response

[[1, 2, 3], [2, 3, 4]]

arrayShuffle

引入版本：v23.2.0 返回一个与原始数组大小相同、元素顺序已被打乱的数组。元素会以这样的方式重新排序：这些元素的每一种可能排列出现的概率都相同。

此函数不会物化常量。

语法

arrayShuffle(arr [, seed])

参数

arr — 要随机打乱的数组。Array(T)
seed (optional) — 可选。用于生成随机数的种子值。若未提供，则会使用随机种子。(U)Int*

返回值 元素顺序被打乱后的数组 Array(T) 示例 不带 seed 的示例 (结果不稳定)

Query

SELECT arrayShuffle([1, 2, 3, 4]);

Response

[1,4,2,3]

未使用 seed 的示例 (结果稳定)

Query

SELECT arrayShuffle([1, 2, 3, 4], 41);

Response

[3,2,1,4]

arraySimilarity

引入版本：v25.4.0 基于加权 Levenshtein 距离，计算两个数组在 0 到 1 范围内的相似度。语法

arraySimilarity(from, to, from_weights, to_weights)

参数

from — 第一个数组 Array(T)
to — 第二个数组 Array(T)
from_weights — 第一个数组的权重 Array((U)Int*|Float*)
to_weights — 第二个数组的权重 Array((U)Int*|Float*)

返回值 返回基于加权 Levenshtein 距离计算出的两个数组之间介于 0 和 1 之间的相似度 Float64 示例 使用示例

Query

SELECT arraySimilarity(['A', 'B', 'C'], ['A', 'K', 'L'], [1.0, 2, 3], [3.0, 4, 5]);

Response

0.2222222222222222

arraySlice

引入版本：v1.1.0 返回数组的一个切片，其中包含 NULL 元素。语法

arraySlice(arr, offset [, length])

参数

arr — 要切片的数组。Array(T)
offset — 相对于数组边界的偏移量。正值表示从左侧开始偏移，负值表示从右侧开始偏移。数组元素从 1 开始编号。(U)Int*
length — 所需切片的长度。如果指定负值，函数返回一个开区间切片 [offset, array_length - length]。如果省略该值，函数返回切片 [offset, the_end_of_array]。(U)Int*

返回值 返回从指定 offset 开始、包含 length 个元素的数组切片。Array(T) 示例 用法示例

Query

SELECT arraySlice([1, 2, NULL, 4, 5], 2, 3) AS res;

Response

[2, NULL, 4]

arraySort

引入版本：v1.1.0 将给定数组中的元素按升序排序。如果指定了 lambda function f，排序顺序将由该 lambda function 作用于数组每个元素后的结果决定。如果该 lambda function 接受多个参数，arraySort 函数会传入多个数组，这些数组分别对应 f 的各个参数。如果待排序的数组包含 -Inf、NULL、NaN 或 Inf，它们将按以下顺序排序：

-Inf
Inf
NaN
NULL

arraySort 是一个高阶函数。语法

arraySort([f,] arr [, arr1, ... ,arrN])

参数

f(y1[, y2 ... yN]) — 应用于数组 x 元素的 lambda 函数。 - arr — 要排序的数组。Array(T) - arr1, ..., yN — 可选。当 f 接受多个参数时，表示另外 N 个数组。

返回值 如果未提供 lambda 函数，则返回按升序排序的数组 arr；否则，返回根据所提供 lambda 函数逻辑排序后的数组。Array(T)。示例 示例 1

Query

SELECT arraySort([1, 3, 3, 0]);

Response

[0,1,3,3]

示例 2

Query

SELECT arraySort(['hello', 'world', '!']);

Response

['!','hello','world']

示例 3

Query

SELECT arraySort([1, nan, 2, NULL, 3, nan, -4, NULL, inf, -inf]);

Response

[-inf,-4,1,2,3,inf,nan,nan,NULL,NULL]

arraySplit

引入版本：v20.1.0 将源数组拆分成多个数组。当 func(x [, y1, ..., yN]) 返回非零值时，会在该元素左侧拆分数组。第一个元素之前不会发生拆分。语法

arraySplit(func(x[, y1, ..., yN]), source_arr[, cond1_arr, ... , condN_arr])

参数

func(x[, y1, ..., yN]) — 一个对源数组 (x) 和条件数组 (y) 中的元素进行操作的 Lambda 函数。Lambda 函数。 - source_arr — 要拆分的源数组 Array(T)。 - [, cond1_arr, ... , condN_arr] — 可选。为 Lambda 函数提供附加参数的 N 个条件数组。Array(T)。

返回值 返回一个嵌套数组 Array(Array(T)) 示例 使用示例

Query

SELECT arraySplit((x, y) -> y, [1, 2, 3, 4, 5], [1, 0, 0, 1, 0]) AS res

Response

[[1, 2, 3], [4, 5]]

arraySum

引入版本：v21.1.0 返回源数组中所有元素的总和。如果指定了 lambda 函数 func，则返回 lambda 计算结果之和。语法

arraySum([func(x[, y1, ..., yN])], source_arr[, cond1_arr, ... , condN_arr])

参数

func(x[, y1, ..., yN]) — 可选。对源数组 (x) 和条件数组 (y) 中的元素执行操作的 Lambda 函数。Lambda function
source_arr — 要处理的源数组。Array(T)
, cond1_arr, ... , condN_arr] — 可选。N 个条件数组，用于为 Lambda 函数提供额外参数。Array(T)

返回值 返回源数组中元素之和；如果提供了 lambda，则返回 lambda 计算结果元素之和。示例 基本示例

Query

SELECT arraySum([1, 2, 3, 4]);

Response

与 lambda 函数结合使用

Query

SELECT arraySum(x, y -> x+y, [1, 1, 1, 1], [1, 1, 1, 1]);

Response

arraySymmetricDifference

引入版本：v25.4.0 接受多个数组，并返回一个包含未出现在所有源数组中的元素的数组。结果仅包含唯一值。

两个以上集合的对称差在数学上定义为：由所有出现在奇数个输入集合中的元素组成的集合。相比之下，函数 arraySymmetricDifference 只是返回未出现在所有输入集合中的输入元素集合。

语法

arraySymmetricDifference(arr1, arr2, ... , arrN)

参数

arrN — 用于构造新数组的 N 个数组。Array(T)。

返回值 返回一个数组，其中包含并非在所有源数组中都存在的去重元素 Array(T) 示例 用法示例

Query

SELECT
arraySymmetricDifference([1, 2], [1, 2], [1, 2]) AS empty_symmetric_difference,
arraySymmetricDifference([1, 2], [1, 2], [1, 3]) AS non_empty_symmetric_difference;

Response

┌─empty_symmetric_difference─┬─non_empty_symmetric_difference─┐
│ []                         │ [3,2]                          │
└────────────────────────────┴────────────────────────────────┘

arrayTranspose

在 v26.4.0 中引入对二维数组进行转置。所有内层数组的长度必须相同。语法

arrayTranspose(arr)

参数

arr — 要进行转置的二维数组。所有内层数组的长度都必须相同。Array(Array(T))

返回值 转置后的二维数组，其中结果中的元素 [i][j] 等于输入中的元素 [j][i]。Array(Array(T)) 示例方阵

Query

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

Response

[[1, 3], [2, 4]]

非方阵

Query

SELECT arrayTranspose([[1, 2, 3], [4, 5, 6]])

Response

[[1, 4], [2, 5], [3, 6]]

String 类型元素

Query

SELECT arrayTranspose([['a', 'b'], ['c', 'd']])

Response

[['a', 'c'], ['b', 'd']]

arrayUnion

引入版本：v24.10.0 接收多个数组，并返回一个包含各源数组中所有元素的数组。结果中仅包含唯一值。语法

arrayUnion(arr1, arr2, ..., arrN)

参数

arrN — 用于构造新数组的 N 个数组。Array(T)

返回值 返回一个数组，包含源数组中的去重元素。Array(T) 示例 使用示例

Query

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

Response

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

arrayUniq

Introduced in：v1.1.0 传入单个参数时，计算数组中不同元素的个数。传入多个参数时，计算多个数组中对应位置元素组成的不同元组的个数。例如，SELECT arrayUniq([1,2], [3,4], [5,6]) 会形成以下 Tuple：

位置 1：(1,3,5)
位置 2：(2,4,6)

然后再统计唯一 Tuple 的个数。本例中结果为 2。所有传入的数组长度必须相同。

如果你想获取数组中唯一元素的列表，可以使用 arrayReduce('groupUniqArray', arr)。

Syntax

arrayUniq(arr1[, arr2, ..., arrN])

参数

arr1 — 用于统计不同元素数量的数组。Array(T)
[, arr2, ..., arrN] — 可选。附加数组，用于统计多个数组中对应位置元素组成的不同 Tuple 的数量。Array(T)

返回值 如果只有一个参数，则返回不同元素的数量。如果有多个参数，则返回由各数组对应位置元素组成的不同 Tuple 的数量。 UInt32 示例 单个参数

Query

SELECT arrayUniq([1, 1, 2, 2])

Response

多个参数

Query

SELECT arrayUniq([1, 2, 3, 1], [4, 5, 6, 4])

Response

arrayWithConstant

Introduced in: v20.1.0 创建一个长度为 length 的数组，并用常量 x 填充。语法

arrayWithConstant(N, x)

参数

length — 数组中的元素个数。(U)Int*
x — 数组中 N 个元素的值，可以是任意类型。

返回值 返回一个包含 N 个元素且每个元素的值都为 x 的数组。Array(T) 示例 用法示例

Query

SELECT arrayWithConstant(3, 1)

Response

[1, 1, 1]

arrayZip

引入版本：v20.1.0 将多个数组合并为一个数组。结果数组包含源数组中对应位置的元素，并按参数列出的顺序将其组合为元组。语法

arrayZip(arr1, arr2, ... , arrN)

参数

arr1, arr2, ... , arrN — 要合并成单个数组的 N 个数组。Array(T)

返回值 返回一个数组，其中包含来自源数组的元素，并按元组组合。元组中的数据类型与输入数组的类型相同，顺序也与传入数组的顺序一致。Array(T) 示例 使用示例

Query

SELECT arrayZip(['a', 'b', 'c'], [5, 2, 1]);

Response

[('a', 5), ('b', 2), ('c', 1)]

arrayZipUnaligned

引入版本：v20.1.0 将多个数组组合成一个数组，并允许数组不对齐 (即长度不同) 。结果数组会按参数列出的顺序，将各源数组中对应位置的元素组合成元组。语法

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

参数

arr1, arr2, ..., arrN — 将 N 个数组合并为一个数组。Array(T)

返回值 返回一个数组，其中包含按元组组合的源数组元素。元组中的数据类型与输入数组的数据类型相同，顺序也与传入数组的顺序一致。Array(T) 或 Tuple(T1, T2, ...) 示例 使用示例

Query

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

Response

[('a', 1),(NULL, 2),(NULL, 3)]

countEqual

引入版本：v1.1.0 返回数组中等于 x 的元素数量。等价于 arrayCount(elem -> elem = x, arr)。 NULL 元素会作为单独的值处理。语法

countEqual(arr, x)

参数

arr — 待搜索的数组。Array(T)
x — 要在数组中统计的值。任意类型。

返回值 返回数组中等于 x 的元素数量 UInt64 示例 使用示例

Query

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

Response

empty

引入版本：v1.1.0 检查输入数组是否为空。如果数组不包含任何元素，则视为空数组。

启用 optimize_functions_to_subcolumns setting 后可对此进行优化。将 optimize_functions_to_subcolumns = 1 时，该函数只会读取 size0 子列，而不是读取并处理整个数组列。查询 SELECT empty(arr) FROM TABLE; 会转换为 SELECT arr.size0 = 0 FROM TABLE;。

该函数也适用于 String 或 UUID。语法

empty(arr)

参数

arr — 输入数组。Array(T)

返回值 空数组返回 1，非空数组返回 0。UInt8 示例 用法示例

Query

SELECT empty([]);

Response

emptyArrayDate

引入版本：v1.1.0 返回一个空的 Date 数组语法

emptyArrayDate()

参数

无。

返回值 空的 Date 数组。Array(T) 示例 用法示例

Query

SELECT emptyArrayDate

Response

[]

emptyArrayDateTime

引入版本：v1.1.0 返回一个空的 DateTime 数组语法

emptyArrayDateTime()

参数

无。

返回值 空的 DateTime 数组。Array(T) 示例 使用示例

Query

SELECT emptyArrayDateTime

Response

[]

emptyArrayFloat32

在 v1.1.0 中引入返回一个空 Float32 数组语法

emptyArrayFloat32()

参数

无。

返回值 一个空的 Float32 数组。Array(T) 示例 使用示例

Query

SELECT emptyArrayFloat32

Response

[]

emptyArrayFloat64

引入版本：v1.1.0 返回一个空的 Float64 数组语法

emptyArrayFloat64()

参数

无。

返回值 一个空的 Float64 数组。Array(T) 示例 使用示例

Query

SELECT emptyArrayFloat64

Response

[]

emptyArrayInt16

引入版本：v1.1.0 返回空的 Int16 数组语法

emptyArrayInt16()

参数

无。

返回值 一个空的 Int16 类型数组。Array(T) 示例 用法示例

Query

SELECT emptyArrayInt16

Response

[]

emptyArrayInt32

引入版本：v1.1.0 返回一个空 Int32 数组语法

emptyArrayInt32()

参数

无。

返回值 一个空的 Int32 数组。Array(T) 示例 使用示例

Query

SELECT emptyArrayInt32

Response

[]

emptyArrayInt64

引入版本：v1.1.0 返回一个空的 Int64 数组语法

emptyArrayInt64()

参数

无。

返回值 空的 Int64 数组。Array(T) 示例 用法示例

Query

SELECT emptyArrayInt64

Response

[]

emptyArrayInt8

自 v1.1.0 起引入返回一个空 Int8 数组语法

emptyArrayInt8()

参数

无。

返回值 空的 Int8 数组。Array(T) 示例 使用示例

Query

SELECT emptyArrayInt8

Response

[]

emptyArrayString

引入版本：v1.1.0 返回一个空的 String 数组语法

emptyArrayString()

参数

无。

返回值 空的 String 数组。Array(T) 示例 用法示例

Query

SELECT emptyArrayString

Response

[]

emptyArrayToSingle

引入版本：v1.1.0 接受一个空数组，并返回一个只包含默认值的单元素数组。语法

emptyArrayToSingle(arr)

参数

arr — 空数组。Array(T)

返回值 包含一个 Array 默认类型值的数组。Array(T) 示例 基础示例

Query

CREATE TABLE test (
  a Array(Int32),
  b Array(String),
  c Array(DateTime)
)
ENGINE = MergeTree
ORDER BY tuple();

INSERT INTO test VALUES ([], [], []);

SELECT emptyArrayToSingle(a), emptyArrayToSingle(b), emptyArrayToSingle(c) FROM test;

Response

┌─emptyArrayToSingle(a)─┬─emptyArrayToSingle(b)─┬─emptyArrayToSingle(c)───┐
│ [0]                   │ ['']                  │ ['1970-01-01 01:00:00'] │
└───────────────────────┴───────────────────────┴─────────────────────────┘

emptyArrayUInt16

引入于：v1.1.0 返回一个空的 UInt16 数组语法

emptyArrayUInt16()

参数

无。

返回值 一个空的 UInt16 数组。Array(T) 示例 用法示例

Query

SELECT emptyArrayUInt16

Response

[]

emptyArrayUInt32

引入版本：v1.1.0 返回一个空的 UInt32 数组语法

emptyArrayUInt32()

参数

无。

返回值 一个空的 UInt32 数组。Array(T) 示例 用法示例

Query

SELECT emptyArrayUInt32

Response

[]

emptyArrayUInt64

引入版本：v1.1.0 返回一个空的 UInt64 数组语法

emptyArrayUInt64()

参数

无。

返回值 空的 UInt64 数组。Array(T) 示例 用法示例

Query

SELECT emptyArrayUInt64

Response

[]

emptyArrayUInt8

引入版本：v1.1.0 返回一个空的 UInt8 数组语法

emptyArrayUInt8()

参数

无。

返回值 空的 UInt8 数组。Array(T) 示例 使用示例

Query

SELECT emptyArrayUInt8

Response

[]

has

引入版本：v1.1.0 返回数组是否包含指定元素、Map 是否包含指定键，或 JSON 对象是否包含指定路径。对于 JSON，支持使用点表示法访问嵌套路径 (例如 ‘a.b.c’) 。当第一个参数是常量数组、第二个参数是列或表达式时，has(constant_array, column) 的行为类似于 column IN (constant_array)，并且可利用主键和跳过索引进行优化。例如，如果 id 是 PRIMARY KEY 的一部分，则 has([1, 10, 100], id) 可以利用主键索引。当列被单调函数包裹时，此优化同样适用 (例如，has([...], toDate(ts))) 。语法

has(haystack, needle)

参数

haystack — 源数组、Map 或 JSON。Array 或 Map 或 JSON
needle — 要查找的值 (数组中的元素、Map 中的键，或 JSON 中的路径字符串) 。

返回值 如果 haystack 中包含指定的 needle，则返回 1；否则返回 0。UInt8 示例 数组基本用法

Query

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

Response

找不到数组

Query

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

Response

Map 的基本用法

Query

SELECT has(map('a', 1, 'b', 2), 'b')

Response

JSON 路径

Query

SELECT has('{"a": {"b": 1}}'::JSON, 'a.b')

Response

hasAll

Introduced in：v1.1.0 检查一个数组是否是另一个数组的子集。

空数组是任何数组的子集。
Null 会被视为一个值处理。
两个数组中值的顺序都不重要。

Syntax

hasAll(set, subset)

参数

set — 任意类型的数组，包含一组元素。Array(T)
subset — 任意类型的数组，与 set 具有共同超类型，包含需要测试是否为 set 子集的元素。Array(T)

返回值

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

如果 set 和 subset 的元素不具有共同超类型，则会引发 NO_COMMON_TYPE 异常。示例 空数组

Query

SELECT hasAll([], [])

Response

包含 NULL 值的数组

Query

SELECT hasAll([1, Null], [Null])

Response

包含不同类型值的数组

Query

SELECT hasAll([1.0, 2, 3, 4], [1, 3])

Response

包含 String 值的数组

Query

SELECT hasAll(['a', 'b'], ['a'])

Response

没有公共类型的数组

Query

SELECT hasAll([1], ['a'])

Response

抛出 NO_COMMON_TYPE 异常

嵌套数组

Query

SELECT hasAll([[1, 2], [3, 4]], [[1, 2], [3, 5]])

Response

hasAny

引入版本：v1.1.0 检查两个数组是否存在相同的元素。

Null 会作为一个值处理。
两个数组中值的顺序都不影响结果。

语法

hasAny(arr_x, arr_y)

参数

arr_x — 任意类型的数组，包含一组元素。Array(T)
arr_y — 任意类型的数组，并且与数组 arr_x 的元素共享共同超类型。Array(T)

返回值

1，如果 arr_x 和 arr_y 至少有一个相同的元素。
0，否则。

如果两个数组中的任意元素之间不存在共同超类型，则会引发 NO_COMMON_TYPE 异常。示例 一个数组为空

Query

SELECT hasAny([1], [])

Response

包含 NULL 值的数组

Query

SELECT hasAny([Null], [Null, 1])

Response

包含不同类型值的数组

Query

SELECT hasAny([-128, 1., 512], [1])

Response

没有公共类型的数组

Query

SELECT hasAny([[1, 2], [3, 4]], ['a', 'c'])

Response

会引发 `NO_COMMON_TYPE` 异常

嵌套数组

Query

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

Response

hasSubstr

首次引入版本：v20.6.0 检查 array2 的所有元素是否按完全相同的顺序出现在 array1 中。因此，当且仅当 array1 = prefix + array2 + suffix 时，该函数才会返回 1。换句话说，该函数会像 hasAll 函数一样，检查 array2 的所有元素是否都包含在 array1 中。此外，它还会检查这些元素在 array1 和 array2 中的出现顺序是否一致。

如果 array2 为空，函数将返回 1。
NULL 会作为一个值处理。换句话说，hasSubstr([1, 2, NULL, 3, 4], [2,3]) 将返回 0。但是，hasSubstr([1, 2, NULL, 3, 4], [2,NULL,3]) 将返回 1
两个数组中值的顺序都很重要。

如果两个数组中的任意元素不具有共同超类型，则会引发 NO_COMMON_TYPE 异常。语法

hasSubstr(arr1, arr2)

参数

arr1 — 包含一组元素的任意类型 数组。Array(T)
arr2 — 包含一组元素的任意类型 数组。Array(T)

返回值 如果数组 arr1 包含数组 arr2，则返回 1；否则返回 0。UInt8 示例 两个数组都为空

Query

SELECT hasSubstr([], [])

Response

包含 NULL 值的数组

Query

SELECT hasSubstr([1, Null], [Null])

Response

包含不同类型值的数组

Query

SELECT hasSubstr([1.0, 2, 3, 4], [1, 3])

Response

包含字符串元素的数组

Query

SELECT hasSubstr(['a', 'b'], ['a'])

Response

具有有效排序的数组

Query

SELECT hasSubstr(['a', 'b' , 'c'], ['a', 'b'])

Response

排序无效的数组

Query

SELECT hasSubstr(['a', 'b' , 'c'], ['a', 'c'])

Response

嵌套数组

Query

SELECT hasSubstr([[1, 2], [3, 4], [5, 6]], [[1, 2], [3, 4]])

Response

无共同类型的数组

Query

SELECT hasSubstr([1, 2, NULL, 3, 4], ['a'])

Response

引发 `NO_COMMON_TYPE` 异常

indexOf

引入版本：v1.1.0 如果数组中存在值为 ‘x’ 的元素，则返回第一个此类元素的索引 (从 1 开始) 。如果数组不包含要查找的值，则函数返回 0。值为 NULL 的元素会被视为普通值处理。语法

indexOf(arr, x)

参数

arr — 要在其中搜索 x 的数组。Array(T)
x — arr 中要返回其索引的第一个匹配元素的值。UInt64

返回值 如果 arr 中存在 x，则返回第一个 x 的索引 (从 1 开始编号) ；否则返回 0。UInt64 示例 基本示例

Query

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

Response

含有 NULL 的数组

Query

SELECT indexOf([1, 3, NULL, NULL], NULL)

Response

indexOfAssumeSorted

版本引入：v24.12.0 如果数组中包含值为 ‘x’ 的元素，则返回第一个此类元素的索引 (从 1 开始) 。如果数组不包含要查找的值，函数将返回 0。

与 indexOf 函数不同，此函数假定数组已按升序排列。如果数组未排序，则结果未定义。

语法

indexOfAssumeSorted(arr, x)

参数

arr — 要搜索的已排序数组。Array(T)
x — 已排序 arr 中要返回其索引的第一个匹配元素的值。UInt64

返回值 如果 arr 中存在 x，则返回第一个 x 的索引 (从 1 开始) 。否则返回 0。UInt64 示例 基本示例

Query

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

Response

kql_array_sort_asc

引入版本：v23.10.0 按升序对一个或多个数组进行排序。第一个数组会被排序，后续数组会按第一个数组排序后的顺序重新排列。NULL 值会排在末尾。这是一个 KQL (Kusto 查询语言) 兼容函数。语法

kql_array_sort_asc(array1[, array2, ..., nulls_last])

参数

array1 — 要排序的数组。Array(T)
array2 — 可选。会按照 array1 的排序顺序重新排列的其他数组。Array(T)
nulls_last — 可选。布尔值，指示是否将 null 放在最后。默认为 true。UInt8

返回值 返回一个由按升序排序的数组组成的 Tuple。Tuple(Array, ...) 示例 基本用法

Query

SELECT kql_array_sort_asc([3, 1, 2])

Response

([1, 2, 3])

kql_array_sort_desc

引入版本：v23.10.0 将一个或多个数组按降序排序。第一个数组会被排序，后续数组会按第一个数组的排序结果重新排列。空值会放在末尾。这是一个 KQL (Kusto 查询语言) 兼容函数。语法

kql_array_sort_desc(array1[, array2, ..., nulls_last])

参数

array1 — 要排序的数组。Array(T)
array2 — 可选的附加数组，会根据 array1 的排序顺序重新排序。Array(T)
nulls_last — 可选布尔值，用于指示是否将 null 排在最后。默认值为 true。UInt8

返回值 返回按降序排序的数组 Tuple。Tuple(Array, ...) 示例 基本用法

Query

SELECT kql_array_sort_desc([3, 1, 2])

Response

([3, 2, 1])

length

Introduced in：v1.1.0 计算字符串或数组的长度。

对于 String 或 FixedString 参数：计算字符串中的字节数。
对于 Array 参数：计算数组中的元素数量。
如果应用于 FixedString 参数，该函数是一个常量表达式。

请注意，字符串中的字节数不等于 Unicode“码点”的数量，也不等于 Unicode“字素簇”的数量 (也就是我们通常所说的“字符”) ，也不等于字符串的可见宽度。字符串中可以包含 ASCII NULL 字节，这些字节也会被计入。 Syntax

length(x)

别名: OCTET_LENGTH 参数

x — 要计算其字节数 (对于 String/FixedString) 或元素个数 (对于 Array) 的值。String 或 FixedString 或 Array(T)

返回值 返回 String/FixedString x 的字节数，或数组 x 的元素个数。UInt64 示例 String 示例

Query

SELECT length('Hello, world!')

Response

Array 示例

Query

SELECT length(['Hello', 'world'])

Response

constexpr 示例

Query

WITH 'hello' || toString(number) AS str
SELECT str,
isConstant(length(str)) AS str_length_is_constant,
isConstant(length(str::FixedString(6))) AS fixed_str_length_is_constant
FROM numbers(3)

Response

┌─str────┬─str_length_is_constant─┬─fixed_str_length_is_constant─┐
│ hello0 │                      0 │                            1 │
│ hello1 │                      0 │                            1 │
│ hello2 │                      0 │                            1 │
└────────┴────────────────────────┴──────────────────────────────┘

Unicode 示例

Query

SELECT 'ёлка' AS str1, length(str1), lengthUTF8(str1), normalizeUTF8NFKD(str1) AS str2, length(str2), lengthUTF8(str2)

Response

┌─str1─┬─length(str1)─┬─lengthUTF8(str1)─┬─str2─┬─length(str2)─┬─lengthUTF8(str2)─┐
│ ёлка │            8 │                4 │ ёлка │           10 │                5 │
└──────┴──────────────┴──────────────────┴──────┴──────────────┴──────────────────┘

ascii_vs_utf8 示例

Query

SELECT 'ábc' AS str, length(str), lengthUTF8(str)

Response

┌─str─┬─length(str)──┬─lengthUTF8(str)─┐
│ ábc │            4 │               3 │
└─────┴──────────────┴─────────────────┘

notEmpty

版本引入：v1.1.0 检查输入数组是否非空。如果数组至少包含一个元素，则视为非空。

可通过启用 optimize_functions_to_subcolumns 设置进行优化。当 optimize_functions_to_subcolumns = 1 时，该函数只会读取 size0 子列，而不是读取并处理整个数组列。查询 SELECT notEmpty(arr) FROM table 会转换为 SELECT arr.size0 != 0 FROM TABLE。

该函数也适用于 String 或 UUID。语法

notEmpty(arr)

参数

arr — 输入数组。Array(T)

返回值 非空数组返回 1，空数组返回 0 UInt8 示例 使用示例

Query

SELECT notEmpty([1,2]);

Response

range

Introduced in: v1.1.0 返回一个数字 Array，从 start 开始，以 step 为步长，到 end - 1 结束。支持的类型有：

UInt8/16/32/64
Int8/16/32/64]
所有参数 start、end、step 都必须是上述支持的类型之一。返回的数组元素类型将是这些参数的超类型。
如果函数返回的数组总长度超过设置 function_range_max_elements_in_block 指定的元素个数，则会抛出异常。
如果任一参数的类型为 Nullable(nothing)，则返回 NULL。如果任一参数的值为 NULL (Nullable(T) 类型) ，则会抛出异常。

Syntax

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

参数

start — 可选。数组的第一个元素。使用 step 时为必填。默认值：0。- end — 必填。数组将生成到该数字之前。- step — 可选。指定数组中相邻元素之间的递增步长。默认值：1。

返回值 从 start 到 end - 1、步长为 step 的数字数组。Array(T) 示例 使用示例

Query

SELECT range(5), range(1, 5), range(1, 5, 2), range(-1, 5, 2);

Response

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

replicate

发布于：v1.1.0 创建一个只包含单个值的数组。语法

replicate(x, arr)

参数

x — 用于填充结果数组的值。Any
arr — 数组。Array(T)

返回值 返回一个长度与 arr 相同、且所有元素都为 x 的数组。Array(T) 示例 使用示例

Query

SELECT replicate(1, ['a', 'b', 'c']);

Response

┌─replicate(1, ['a', 'b', 'c'])───┐
│ [1, 1, 1]                       │
└─────────────────────────────────┘

reverse

引入版本：v1.1.0 将输入数组中元素的顺序或输入字符串中字符的顺序反转。语法

reverse(arr | str)

参数

arr | str — 源数组或字符串。Array(T) 或 String

返回值 返回一个数组或字符串，其中元素或字符的顺序已被反转。示例 反转数组

Query

SELECT reverse([1, 2, 3, 4]);

Response

[4, 3, 2, 1]

字符串反转

Query

SELECT reverse('abcd');

Response

'dcba'

距离函数

所有受支持的函数都在距离函数文档中有详细说明。

​array

​arrayAUCPR

​arrayAll

​arrayAutocorrelation

​arrayAvg

​arrayCompact

​arrayConcat

​arrayCount

​arrayCumSum

​arrayCumSumNonNegative

​arrayDifference

​arrayDistinct

​arrayDotProduct

​arrayElement

​arrayElementOrNull

​arrayEnumerate

​arrayEnumerateDense

​arrayEnumerateDenseRanked

​arrayEnumerateUniq

​arrayEnumerateUniqRanked

​arrayExcept

​arrayExists

​arrayFill

​arrayFilter

​arrayFirst

​arrayFirstIndex

​arrayFirstOrNull

​arrayFlatten

​arrayFold

​arrayIntersect

​arrayJaccardIndex

​arrayJoin

​arrayLast

​arrayLastIndex

​arrayLastOrNull

​arrayLevenshteinDistance

​arrayLevenshteinDistanceWeighted

​arrayMap

​arrayMax

​arrayMin

​arrayNormalizedGini

​arrayPartialReverseSort

​arrayPartialShuffle

​arrayPartialSort

​arrayPopBack

​arrayPopFront

​arrayProduct

​arrayPushBack

​arrayPushFront

​arrayROCAUC

​arrayRandomSample

​arrayReduce

​arrayReduceInRanges

​arrayRemove

​arrayResize

​arrayReverse

​arrayReverseFill

​arrayReverseSort

​arrayReverseSplit

​arrayRotateLeft

​arrayRotateRight

​arrayShiftLeft

​arrayShiftRight

​arrayShingles

​arrayShuffle

​arraySimilarity

​arraySlice

​arraySort

​arraySplit

​arraySum

​arraySymmetricDifference

​arrayTranspose

​arrayUnion

​arrayUniq

​arrayWithConstant

​arrayZip

​arrayZipUnaligned

​countEqual

​empty

​emptyArrayDate

array

arrayAUCPR

arrayAll

arrayAutocorrelation

arrayAvg

arrayCompact

arrayConcat

arrayCount

arrayCumSum

arrayCumSumNonNegative

arrayDifference

arrayDistinct

arrayDotProduct

arrayElement

arrayElementOrNull

arrayEnumerate

arrayEnumerateDense

arrayEnumerateDenseRanked

arrayEnumerateUniq

arrayEnumerateUniqRanked

arrayExcept

arrayExists

arrayFill

arrayFilter

arrayFirst

arrayFirstIndex

arrayFirstOrNull

arrayFlatten

arrayFold

arrayIntersect

arrayJaccardIndex

arrayJoin

arrayLast

arrayLastIndex

arrayLastOrNull

arrayLevenshteinDistance

arrayLevenshteinDistanceWeighted

arrayMap

arrayMax

arrayMin

arrayNormalizedGini

arrayPartialReverseSort

arrayPartialShuffle

arrayPartialSort

arrayPopBack

arrayPopFront

arrayProduct

arrayPushBack

arrayPushFront

arrayROCAUC

arrayRandomSample

arrayReduce

arrayReduceInRanges

arrayRemove

arrayResize

arrayReverse

arrayReverseFill

arrayReverseSort

arrayReverseSplit

arrayRotateLeft

arrayRotateRight

arrayShiftLeft

arrayShiftRight

arrayShingles

arrayShuffle

arraySimilarity

arraySlice

arraySort

arraySplit

arraySum

arraySymmetricDifference

arrayTranspose

arrayUnion

arrayUniq

arrayWithConstant

arrayZip

arrayZipUnaligned

countEqual

empty

emptyArrayDate