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。 该函数也适用于字符串。
emptyArrayUInt8, emptyArrayUInt16, emptyArrayUInt32, emptyArrayUInt64
emptyArrayInt8, emptyArrayInt16, emptyArrayInt32, emptyArrayInt64
emptyArrayFloat32, emptyArrayFloat64
emptyArrayDate, emptyArrayDateTime
emptyArrayString
不接受任何参数并返回适当类型的空数组。
range(end), range([start, ] end [, step])
返回一个以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的数字数组。
示例
查询语句:
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] │
└───────────────┘arrayElement(arr,n),运算符arr[n]
从数组arr中获取索引为«n»的元素。 n必须是任何整数类型。 数组中的索引从一开始。 支持负索引。在这种情况下，它选择从末尾开始编号的相应元素。例如，arr [-1]是数组中的最后一项。
如果索引超出数组的边界，则返回默认值（数字为0，字符串为空字符串等）。
has(arr,elem)
检查’arr’数组是否具有’elem’元素。 如果元素不在数组中，则返回0;如果在，则返回1。
NULL 值的处理。
SELECT has([1, 2, NULL], NULL)
┌─has([1, 2, NULL], NULL)─┐
│ 1 │
└─────────────────────────┘hasAll
检查一个数组是否是另一个数组的子集。
hasAll(set, subset)参数
set– 具有一组元素的任何类型的数组。subset– 任何类型的数组，其元素应该被测试为set的子集。
返回值
1， 如果set包含subset中的所有元素。0， 否则。
特殊的定义
- 空数组是任何数组的子集。
- «Null»作为数组中的元素值进行处理。
- 忽略两个数组中的元素值的顺序。
hasAny
检查两个数组是否存在交集。
hasAny(array1, array2)参数
array1– 具有一组元素的任何类型的数组。array2– 具有一组元素的任何类型的数组。
返回值
1， 如果array1和array2存在交集。0， 否则。
特殊的定义
- «Null»作为数组中的元素值进行处理。
- 忽略两个数组中的元素值的顺序。
示例
SELECT hasAny([1], []) 返回 0.
SELECT hasAny([Null], [Null, 1]) 返回 1.
indexOf(arr,x)
返回数组中第一个’x’元素的索引（从1开始），如果’x’元素不存在在数组中，则返回0。
示例:
SELECT indexOf([1, 3, NULL, NULL], NULL)┌─indexOf([1, 3, NULL, NULL], NULL)─┐
│ 3 │
└───────────────────────────────────┘设置为«NULL»的元素将作为普通的元素值处理。
arrayCount([func,] arr1, …)
func将arr数组作为参数，其返回结果为非零值的数量。如果未指定“func”，则返回数组中非零元素的数量。
请注意，arrayCount是一个高阶函数。您可以将 lambda 函数作为第一个参数传递给它。
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)
返回 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 │
└─────────┴───────┘arrayEnumerateUniq(arr, …)
返回与源数组大小相同的数组，其中每个元素表示与其下标对应的源数组元素在源数组中出现的次数。 例如：arrayEnumerateUniq（ [10,20,10,30 ]）= [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– 单个值。只能将数字添加到带数字的数组中，并且只能将字符串添加到字符串数组中。添加数字时，ClickHouse会自动为数组的数据类型设置single_value类型。
示例
SELECT arrayPushBack(['a'], 'b') AS res┌─res───────┐
│ ['a','b'] │
└───────────┘arrayPushFront
将一个元素添加到数组的开头。
arrayPushFront(array, single_value)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] │
└────────────┘arraySort([func,] arr, …)
以升序对arr数组的元素进行排序。如果指定了func函数，则排序顺序由func函数的调用结果决定。如果func接受多个参数，那么arraySort函数也将解析与func函数参数相同数量的数组参数。
整数排序示例:
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] │
└─────────┘arrayReverseSort([func,] arr, …)
以降序对arr数组的元素进行排序。如果指定了func函数，则排序顺序由func函数的调用结果决定
整数排序示例:
SELECT arrayReverseSort([1, 3, 3, 0]);┌─arrayReverseSort([1, 3, 3, 0])─┐
│ [3,3,1,0] │
└────────────────────────────────┘arrayUniq(arr, …)
如果传递一个参数，则计算数组中不同元素的数量。 如果传递了多个参数，则它计算多个数组中相应位置的不同元素元组的数量。
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] │
└─────┴───────────┴─────────┘arrayDistinct
返回一个包含所有数组中不同元素的数组。
语法
arrayDistinct(array)参数
array–类型为数组。
返回值
返回一个包含不同元素的数组。
示例
查询语句:
SELECT arrayDistinct([1, 2, 2, 3, 1]);结果:
┌─arrayDistinct([1, 2, 2, 3, 1])─┐
│ [1,2,3] │
└────────────────────────────────┘arrayEnumerateDense(arr)
返回与源数组大小相同的数组，指示每个元素首次出现在源数组中的位置。例如：arrayEnumerateDense（[10,20,10,30]）= [1,2,1,3]。
示例:
SELECT arrayEnumerateDense([10, 20, 10, 30])┌─arrayEnumerateDense([10, 20, 10, 30])─┐
│ [1,2,1,3] │
└───────────────────────────────────────┘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)参数
返回值
示例
查询语句:
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 │
└──────────────────────────────────────┘arrayReverse(arr)
返回一个与原始数组大小相同的数组，其中包含相反顺序的元素。
示例:
SELECT arrayReverse([1, 2, 3])┌─arrayReverse([1, 2, 3])─┐
│ [3,2,1] │
└─────────────────────────┘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)] │
└──────────────────────────────────────┘arrayMap(func, arr1, …)
将从 func 函数的原始应用中获得的数组返回给 arr 数组中的每个元素。
示例:
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 返回的值不是 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 函数作为第一个参数传递给它，并且不能省略。
arraySplit(func, arr1, …)
将 arr1 拆分为多个数组。当 func 返回 0 以外的值时，数组将在元素的左侧拆分。数组不会在第一个元素之前被拆分。
示例:
SELECT arraySplit((x, y) -> y, [1, 2, 3, 4, 5], [1, 0, 0, 1, 0]) AS res┌─res─────────────┐
│ [[1,2,3],[4,5]] │
└─────────────────┘arrayExists([func,] arr1, …)
如果 arr 中至少有一个元素 func 返回 0 以外的值，则返回 1。否则，它返回 0。
请注意，arrayExists是一个高阶函数。您可以将 lambda 函数作为第一个参数传递给它，并且不能省略。
arrayMin
返回源数组中的最小元素。
如果指定了 func 函数，则返回此函数转换的元素的最小值。
请注意，arrayMin是一个高阶函数。您可以将 lambda 函数作为第一个参数传递给它，并且不能省略。
语法
arrayMin([func,] arr)参数
返回值
- 函数值的最小值（或数组最小值）。
类型：如果指定了func，则匹配func返回值类型，否则匹配数组元素类型。
示例
查询语句:
SELECT arrayMin([1, 2, 4]) AS res;结果:
┌─res─┐
│ 1 │
└─────┘查询语句:
SELECT arrayMin(x -> (-x), [1, 2, 4]) AS res;结果:
┌─res─┐
│ -4 │
└─────┘arrayMax
返回源数组中元素的最大值。
如果指定了func 函数，则返回此函数转换的元素的最大值。
请注意，arrayMax是一个高阶函数. 您可以将 lambda 函数作为第一个参数传递给它，并且不能省略。
语法
arrayMax([func,] arr)参数
返回值
- 函数值的最大值（或数组最大值）。
类型：如果指定了func，则匹配func返回值类型，否则匹配数组元素类型。
示例
查询语句：
SELECT arrayMax([1, 2, 4]) AS res;结果：
┌─res─┐
│ 4 │
└─────┘查询语句：
SELECT arrayMax(x -> (-x), [1, 2, 4]) AS res;结果：
┌─res─┐
│ -1 │
└─────┘arraySum
返回源数组中元素的总和。
如果指定了 func 函数，则返回此函数转换的元素的总和。
请注意，arraySum是一个高阶函数. 您可以将 lambda 函数作为第一个参数传递给它，并且不能省略。
语法
arraySum([func,] arr)参数
返回值
- 函数值的总和（或数组总和）。
类型：源数组中的十进制数（或转换后的值，如果指定了func）-Decimal128， 对于浮点数 — Float64， 对于无符号数 — UInt64， 对于有符号数 — Int64。
示例
查询语句：
SELECT arraySum([2, 3]) AS res;结果：
┌─res─┐
│ 5 │
└─────┘查询语句：
SELECT arraySum(x -> x*x, [2, 3]) AS res;结果：
┌─res─┐
│ 13 │
└─────┘arrayAvg
返回源数组中元素的平均值。
如果指定了 func 函数，则返回此函数转换的元素的平均值。
请注意，arrayAvg是一个高阶函数. 您可以将 lambda 函数作为第一个参数传递给它，并且不能省略。
语法
arrayAvg([func,] arr)参数
返回值
- 函数值的平均值（或数组平均值）。
类型为: Float64.
示例
查询语句：
SELECT arrayAvg([1, 2, 4]) AS res;结果：
┌────────────────res─┐
│ 2.3333333333333335 │
└────────────────────┘查询语句：
SELECT arrayAvg(x -> (x * x), [2, 4]) AS res;结果：
┌─res─┐
│ 10 │
└─────┘arrayCumSum([func,] arr1, …)
返回源数组中元素的部分和的数组（运行总和）。如果指定了 func 函数，则数组元素的值在求和之前由该函数转换。
示例:
SELECT arrayCumSum([1, 1, 1, 1]) AS res┌─res──────────┐
│ [1, 2, 3, 4] │
└──────────────┘请注意，arrayCumSum是一个高阶函数. 您可以将 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 │
└─────┴──────────────────────────────────────────────────────────────────────────────────────────┘