array #

从函数参数创建一个数组。
参数必须是常量，并且具有最小公共类型的类型。必须传递至少一个参数。否则，不清楚要创建哪种类型的数组。也就是说，您不能使用此函数创建一个空数组（为此，请使用上面描述的“emptyArray*”函数）。
语法

array(x1, …)

参数

• x1,...– 必须是常量，并且具有最小公共类型的类型

返回值

• 返回“Array(T)”类型的结果，其中“T”是传递参数中最小的公共类型。

示例

SELECT array(1,2,3);

┌─array(1, 2, 3)─┐
│ [1, 2, 3]      │
└────────────────┘

arrayAll #

func如果中所有元素的返回值都不是 0 ，则返回 1。arr否则，返回 0。
请注意，arrayAll是一个高阶函数。您可以将 lambda 函数作为第一个参数传递给它。
语法

arrayAll([func,] arr1, …)

参数

• func– 高阶函数必须返回 UInt8
• arr1,..数组作为函数的输入

返回值

• func如果返回的所有元素都不是 0，则返回 1arr

示例

SELECT arrayAll((x,y)->x==y,[1,2,3],[4,5,6]);

┌─arrayAll(lambda(tuple(x, y), equals(x, y)), [1, 2, 3], [4, 5, 6])─┐
│ 0                                                                 │
└───────────────────────────────────────────────────────────────────┘

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

┌─arrayAll(lambda(tuple(x, y), equals(x, y)), [1, 2, 3], [1, 2, 3])─┐
│ 1                                                                 │
└───────────────────────────────────────────────────────────────────┘

empty #

检查输入的数组是否为空。
语法

empty([x])

如果一个数组中不包含任何元素，则此数组为空数组。
参数

• [x] — 输入的数组，类型为数组。

返回值

• 对于空数组返回1，对于非空数组返回0。

类型: UInt8。
示例
查询语句:

SELECT empty([]);

结果:

┌─empty(array())─┐
│              1 │
└────────────────┘

notEmpty #

检测输入的数组是否非空。
语法

notEmpty([x])

如果一个数组至少包含一个元素，则此数组为非空数组。
参数

• [x] — 输入的数组，类型为数组。

返回值

• 对于空数组返回0，对于非空数组返回1。

类型: UInt8.
示例
查询语句:

SELECT notEmpty([1,2]);

结果:

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

length #

返回数组中的元素个数。 结果类型是UInt64。 该函数也适用于字符串。
示例

SELECT length(arr) FROM table

emptyArrayString #

不接受任何参数并返回适当类型的空数组。

emptyArrayToSingle #

接受一个空数组并返回一个仅包含一个默认值元素的数组。

range #

返回一个以step作为增量步长的从start到end - 1的整形数字数组， 支持类型包括UInt8, UInt16, UInt32, UInt64, Int8, Int16, Int32, Int64。
语法

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

参数

• start — 数组的第一个元素。可选项，如果设置了step时同样需要start，默认值为：0。
• end — 计数到end结束，但不包括end，必填项。
• step — 确定数组中每个元素之间的增量步长。可选项，默认值为：1。

返回值

• 以step作为增量步长的从start到end - 1的数字数组。

注意事项

• 所有参数start、end、step必须属于以下几种类型之一：UInt8, UInt16, UInt32, UInt64, Int8, Int16, Int32, Int64。结果数组的元素数据类型为所有入参类型的最小超类，也必须属于以上几种类型之一。

示例
查询语句:

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

arrayConcat #

合并参数中传递的所有数组。
语法

arrayConcat(arrays)

参数

• arrays – 任意数量的阵列类型的参数.

示例

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

┌─res───────────┐
│ [1,2,3,4,5,6] │
└───────────────┘

arr #

从数组arr中获取索引为«n»的元素。 n必须是任何整数类型。 数组中的索引从一开始。 支持负索引。在这种情况下，它选择从末尾开始编号的相应元素。例如，arr [-1]是数组中的最后一项。
语法

arr[n]

如果索引超出数组的边界，则返回默认值（数字为0，字符串为空字符串等）。

has #

检查’arr’数组是否具有’elem’元素。 如果元素不在数组中，则返回0；如果在，则返回1。
语法

has(arr,elem)

示例

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

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

hasAll #

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

hasAll(set, subset)

参数

• set – 具有一组元素的任何类型的数组。
• subset – 任何类型的数组，其元素应该被测试为set的子集。

返回值

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

特殊的定义

• 空数组是任何数组的子集。
• «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']) --返回0。
SELECT hasAll([[1, 2], [3, 4]], [[1, 2], [3, 5]]) --返回0。

hasAny #

检查两个数组是否存在交集。
语法

hasAny(array1, array2)

参数

• array1 – 具有一组元素的任何类型的数组。
• array2 – 具有一组元素的任何类型的数组。

返回值

• 1， 如果array1和array2存在交集。
• 0， 否则。

特殊的定义

• «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']) --返回 0.
SELECT hasAll([[1, 2], [3, 4]], [[1, 2], [1, 2]]) --返回 1.

hasSubstr #

检查 array2 的所有元素是否以相同的顺序出现在 array1 中。当且仅当 array1 = prefix + array2 + suffix时，该函数将返回 1。
语法

hasSubstr(array1, array2)

换句话说，函数将检查 array2 的所有元素是否都包含在 array1 中，就像 hasAll 函数一样。此外，它将检查元素在“array1”和“array2”中的出现顺序是否相同。
示例

hasSubstr([1,2,3,4], [2,3]) --返回1。
hasSubstr([1,2,3,4], [3,2]) --返回0。

hasSubstr([1,2,3,4], [1,2,3]) --返回1。
hasSubstr([1,2,3,4], [1,2,4]) --返回0。

参数

• array1 – 具有一组元素的任何类型数组。
• array2 – 具有一组元素的任何类型数组。

返回值

• 如果array1中包含array2，返回1。
• 其他情况返回0。

特殊属性

• 当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。

indexOf #

返回数组中第一个’x’元素的索引（从1开始），如果’x’元素不存在在数组中，则返回0。
语法

indexOf(arr,x)

示例

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

┌─indexOf([1, 3, NULL, NULL], NULL)─┐
│                                 3 │
└───────────────────────────────────┘

设置为«NULL»的元素将作为普通的元素值处理。

arrayCount #

返回 arr 数组中 func 返回非 0 值的元素数量。如果未指定“func”，则返回数组中非零元素的数量。
请注意，这arrayCount是一个高阶函数。您可以将 lambda 函数作为第一个参数传递给它。
语法

arrayCount([func,] arr1, …)

参数

• func– 高阶函数必须返回 UInt8
• arr1,..数组作为函数的输入

返回值

• arr 数组中 func 返回非 0 值的元素数量

示例

SELECT arrayCount((x,y)->x==y,[1,2,3],[1,5,3]);

┌─arrayCount(lambda(tuple(x, y), equals(x, y)), [1, 2, 3], [1, 5, 3])─┐
│ 2                                                                   │
└─────────────────────────────────────────────────────────────────────┘

arrayCumSum #

返回源数组中元素的部分和的数组（运行和）。如果func指定了该函数，则在求和之前，该函数将转换数组元素的值。
请注意，这arrayCumSum是一个高阶函数。您可以将 lambda 函数作为第一个参数传递给它。
语法

arrayCumSum([func,] arr1, …)

参数

• func– 高阶函数
• arr1,..数组作为函数的输入

返回值

• 源数组中元素的部分和的数组

示例

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

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

SELECT arrayCumSum(x->x+1,[1, 1, 1, 1]) AS res

┌─res──────────┐
│ [2, 4, 6, 8] │
└──────────────┘

arrayCumSumNonNegative #

与 相同arrayCumSum，返回源数组中元素的部分和的数组（运行和）。不同之处在于arrayCumSum，当返回值包含小于零的值时，该值将替换为零，并使用零参数执行后续计算。例如：
请注意，这arraySumNonNegative是一个高阶函数。您可以将 lambda 函数作为第一个参数传递给它。
语法

arrayCumSumNonNegative([func,] arr1, …)

参数

• func– 高阶函数
• arr1,..数组作为函数的输入

返回值

• 源数组中元素的部分和的数组

示例

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

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

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

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

countEqual #

返回数组中等于x的元素的个数。相当于arrayCount（elem - > elem = x，arr）。
NULL值将作为单独的元素值处理。
示例

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

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

arrayEnumerate #

返回 Array [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 │
└─────────┴─────────┴────────┘

在此示例中，每个GoalID都计算转换次数（目标嵌套数据结构中的每个元素都是达到的目标，我们称之为转换）和会话数。如果没有ARRAY JOIN，我们会将会话数计为总和（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并在此结构中跨多个元素进一步聚合时，这是必需的。

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 – 单个值。只能将数字添加到带数字的数组中，并且只能将字符串添加到字符串数组中。添加数字时，ByteHouse会自动为数组的数据类型设置single_value类型。

示例

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

┌─res───────┐
│ ['a','b'] │
└───────────┘

arrayPushFront #

将一个元素添加到数组的开头。
语法

arrayPushFront(array, single_value)

参数

• array – 数组。
• single_value – 单个值。只能将数字添加到带数字的数组中，并且只能将字符串添加到字符串数组中。添加数字时，ByteHouse会自动为数组的数据类型设置single_value类型。该函数向数组添加一个«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»的数组元素作为普通的数组元素值处理。

arraySort #

以升序对arr数组的元素进行排序。如果指定了func函数，则排序顺序由func函数的调用结果决定。如果func接受多个参数，那么arraySort函数也将解析与func函数参数相同数量的数组参数。更详细的示例在arraySort的末尾。
语法

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

整数排序示例:

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，因此源数组中的实际值不会影响结果的顺序。所以，’world’将是结果中的第一个元素，’hello’将是结果中的第二个元素。
其他示例如下所示。

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

arrayReverseSort #

以降序对arr数组的元素进行排序。如果指定了func函数，则排序顺序由func函数的调用结果决定。如果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的前面。

注意：arraySort是高阶函数。您可以将lambda函数作为第一个参数传递给它。如下示例所示。

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

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

数组按以下方式排序:

1. 首先，根据lambda函数的调用结果对源数组（[1, 2, 3]）进行排序。 结果是[3, 2, 1]。
2. 反转上一步获得的数组。 所以，最终的结果是[1, 2, 3]。

lambda函数可以接受多个参数。在这种情况下，您需要为arrayReverseSort传递与lambda参数个数相同的数组。函数使用第一个输入的数组中的元素组成返回结果；使用接下来传入的数组作为排序键。例如：

SELECT arrayReverseSort((x, y) -> y, ['hello', 'world'], [2, 1]) as res;

┌─res───────────────┐
│ ['hello','world'] │
└───────────────────┘

在这个示例中，数组按以下方式排序：

1. 首先，根据lambda函数的调用结果对源数组（[‘hello’，‘world’]）进行排序。 其中，在第二个数组（[2,1]）中定义了源数组中相应元素的排序键。 所以，排序结果[‘world’，‘hello’]。
2. 反转上一步骤中获得的排序数组。 所以，最终的结果是[‘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] │
└─────────┘

arrayUniq #

如果传递一个参数，则计算数组中不同元素的数量。 如果传递了多个参数，则它计算多个数组中相应位置的不同元素元组的数量。
语法

arrayUniq(arr, ...)

如果要获取数组中唯一项的列表，可以使用arrayReduce（‘groupUniqArray’，arr）。

arrayJoin #

这是一个非常有用的函数。
语法

arrayJoin(arr)

普通函数不会更改结果集的行数，而只是计算每行中的值（map）。 聚合函数将多行压缩到一行中（fold或reduce）。 ’arrayJoin’函数获取每一行并将他们展开到多行（unfold）。
此函数将数组作为参数，并将该行在结果集中复制数组元素个数。 除了应用此函数的列中的值之外，简单地复制列中的所有值;它被替换为相应的数组值。
查询可以使用多个arrayJoin函数。在这种情况下，转换被执行多次。
请注意SELECT查询中的ARRAY JOIN语法，它提供了更广泛的可能性。
示例

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

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

arrayDifference #

计算相邻数组元素之间的差异。返回一个数组，其中第一个元素为 0，第二个是 a[1] - a[0] 之差等。结果数组中元素的类型由减法的类型推断规则确定（例如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（[10,20,10,30]）= [1,2,1,3]。
语法

arrayEnumerateDense(arr)

示例

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

┌─arrayEnumerateDense([10, 20, 10, 30])─┐
│ [1,2,1,3]                             │
└───────────────────────────────────────┘

arrayIntersect #

返回所有数组元素的交集。
语法

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

arrayReduce #

将聚合函数应用于数组元素并返回其结果。聚合函数的名称以单引号 'max'、'sum' 中的字符串形式传递。使用参数聚合函数时，参数在括号中的函数名称后指示“uniqUpTo(6)”。
语法

arrayReduce(agg_func, arr1, arr2, ..., arrN)

参数

• agg_func — 聚合函数的名称，应该是一个常量string。
• 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 │
└─────────────────────────────────────────────────────────────┘

arrayReduceInRanges #

将聚合函数应用于给定范围内的数组元素，并返回一个包含与每个范围对应的结果的数组。该函数将返回与多个 arrayReduce(agg_func, arraySlice(arr1, index, length), ...) 相同的结果。
语法

arrayReduceInRanges(agg_func, ranges, arr1, arr2, ..., arrN)

参数

• agg_func — 聚合函数的名称，应该是一个常量string。
• 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] │
└─────────────────────────────┘

arrayReverse #

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

arrayReverse(arr)

示例

SELECT arrayReverse([1, 2, 3])

┌─arrayReverse([1, 2, 3])─┐
│ [3,2,1]                 │
└─────────────────────────┘

reverse #

与“arrayReverse”作用相同。
语法

reverse(arr)

arrayFlatten #

将嵌套的数组展平。
函数:

• 适用于任何深度的嵌套数组。
• 不会更改已经展平的数组。

展平后的数组包含来自所有源数组的所有元素。
语法

flatten(array_of_arrays)

别名: flatten.
参数

• array_of_arrays — 嵌套数组。 例如：[[1,2,3], [4,5]]。

示例

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

┌─flatten(array(array([1]), array([2], [3])))─┐
│ [1,2,3]                                     │
└─────────────────────────────────────────────┘

arrayCompact #

从数组中删除连续的重复元素。结果值的顺序由源数组中的顺序决定。
语法

arrayCompact(arr)

参数
arr — 类型为数组。
返回值
没有重复元素的数组。
类型为: Array。
示例
查询语句:

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

结果:

┌─arrayCompact([1, 1, nan, nan, 2, 3, 3, 3])─┐
│ [1,nan,nan,2,3]                            │
└────────────────────────────────────────────┘

arrayZip #

将多个数组组合成一个数组。结果数组包含按列出的参数顺序分组为元组的源数组的相应元素。
语法

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

参数

• arrN — N个数组。

该函数可以采用任意数量的不同类型的数组。所有输入数组的大小必须相等。
返回值

• 将源数组中的元素分组为元组的数组。元组中的数据类型与输入数组的类型相同，并且与传递数组的顺序相同。

类型为: 数组。
示例
查询语句:

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

结果:

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

arrayAUC #

计算AUC。
AUC：ROC曲线下的面积，这是机器学习中的一个概念，更多细节请查看：https://en.wikipedia.org/wiki/Receiver_operating_characteristic#Area_under_the_curve
语法

arrayAUC(arr_scores, arr_labels)

参数

• arr_scores — 分数预测模型给出。
• arr_labels — 样本的标签，通常为 1 表示正样本，0 表示负样本。

返回值
返回 Float64 类型的 AUC 值。
示例
查询语句:

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

结果:

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

arrayMap #

将从 func 函数的原始应用中获得的数组返回给 arr 数组中的每个元素。
语法

arrayMap(func, arr1, ...)

示例:

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 #

返回一个仅包含 arr1 中的元素的数组，其中 func 返回的值不是 0。
语法

arrayFilter(func, arr1, ...)

示例

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 #

从第一个元素到最后一个元素扫描arr1，如果func返回0，则用arr1[i - 1]替换arr1[i]。arr1的第一个元素不会被替换。
语法

arrayFill(func, 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 #

从最后一个元素到第一个元素扫描arr1，如果func返回0，则用arr1[i + 1]替换arr1[i]。arr1的最后一个元素不会被替换。
语法

arrayReverseFill(func, 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 #

将 arr1 拆分为多个数组。当 func 返回 0 以外的值时，数组将在元素的左侧拆分。数组不会在第一个元素之前被拆分。
语法

arraySplit(func, arr1, ...)

示例

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 #

将 arr1 拆分为多个数组。当 func 返回 0 以外的值时，数组将在元素的右侧拆分。数组不会在最后一个元素之后被拆分。
语法

arrayReverseSplit(func, arr1, ...)

示例

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 #

如果 arr 中至少有一个元素 func 返回 0 以外的值，则返回 1。否则，它返回 0。
请注意，arrayExists是一个高阶函数。
语法

arrayExists([func,] arr1, …)

参数

• func– 高阶函数必须返回 UInt8
• arr1,..- 数组作为函数的输入

返回值

• arr如果for中至少有一个元素func返回非 0 的值，则返回 1。否则返回 0。

示例

SELECT arrayExists((x,y)->x==y,[1, 2, 2, 3, 1],[4, 5, 6, 7, 8]);

┌─arrayExists(lambda(tuple(x, y), equals(x, y)), [1, 2, 2, 3, 1], [4, 5, 6, 7, 8])─┐
│ 0                                                                                │
└──────────────────────────────────────────────────────────────────────────────────┘

SELECT arrayExists((x,y)->x==y,[1, 2, 2, 3, 1],[1, 5, 6, 7, 8]);

┌─arrayExists(lambda(tuple(x, y), equals(x, y)), [1, 2, 2, 3, 1], [1, 5, 6, 7, 8])─┐
│ 1                                                                                │
└──────────────────────────────────────────────────────────────────────────────────┘

arrayAll #

如果 func 为 arr 中的所有元素返回 0 以外的值，则返回 1。否则，它返回 0。
语法

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

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

arrayFirst #

返回 arr1 数组中 func 返回非 0 的值的第一个元素，如果找不到该值，将返回默认值。
语法

arrayFirst(func, arr1, ...)

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

arrayLast #

返回 arr1 数组中的最后一个元素，其中 func 返回的值不是 0。如果找不到该值，将返回默认值。
语法

arrayLast(func, arr1, ...)

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

arrayFirstIndex #

返回 arr1 数组中第一个元素的索引，其中 func 返回的值不是 0。如果找不到该值，将返回0。
语法

arrayFirstIndex(func, arr1, ...)

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

arrayLastIndex #

返回 arr1 数组中最后一个元素的索引，其中 func 返回的值不是 0。如果找不到该值，将返回0。
语法

arrayLastIndex(func, arr1, ...)

请注意，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 函数，则数组元素的值在求和之前由该函数转换。
语法

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

示例:

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

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

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

arrayCumSumNonNegative #

与 arrayCumSum 相同，返回源数组中元素的部分和的数组（运行总和）。不同的arrayCumSum，当返回值包含小于零的值时，将该值替换为零，并以零参数执行后续计算。
示例:

arrayCumSumNonNegative(arr)

示例

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

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

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

arrayProduct #

将一个数组中的元素相乘。
语法

arrayProduct(arr)

参数

• arr — 数值类型的数组。

返回值

• 数组元素的乘积。

类型为: Float64.
示例
查询语句：

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

结果：

┌─res───┐
│ 720   │
└───────┘

查询语句：

SELECT arrayProduct([toDecimal64(1,8), toDecimal64(2,8), toDecimal64(3,8)]) as res, toTypeName(res);

返回值类型总是Float64. 结果：

┌─res─┬─toTypeName(arrayProduct(array(toDecimal64(1, 8), toDecimal64(2, 8), toDecimal64(3, 8))))─┐
│ 6   │ Float64                                                                                  │
└─────┴──────────────────────────────────────────────────────────────────────────────────────────┘

arrayElement #

n从数组中获取具有索引的元素arr。n必须是任意整数类型。
数组中的索引从一开始。
支持负索引。在这种情况下，它会选择从末尾开始编号的相应元素。例如，arr[-1]是数组中的最后一项。
如果索引超出了数组的边界，它将返回一些默认值（数字为 0，字符串为空字符串等），非常量数组和常量索引 0 的情况除外（在这种情况下会出现错误Array indices are 1-based）。
语法

arrayElement(array, n)

参数

• array数组。
• n数组中的索引。

返回值

• n从数组中获取具有索引的元素arr

示例

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

┌─arrayElement([1, 2, 2, 3, 1], 3)─┐
│ 2                                │
└──────────────────────────────────┘