面向OLAP的列式存储DBMS-10-[ClickHouse]的常用数组操作

最新推荐文章于 2024-07-11 17:22:20 发布
最新推荐文章于 2024-07-11 17:22:20 发布
阅读量1.5k 收藏 4
点赞数 1
分类专栏： ClickHouse 文章标签： clickhouse
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_20466211/article/details/127829334
版权

参考ClickHouse 中的数据查询以及各种子句
ClickHouse 数组的相关操作函数，一网打尽

在关系型数据库里面我们一般都不太喜欢用数组，但是在 ClickHouse 中数组会用的非常多，并且操作起来非常简单。ClickHouse 里面提供了非常多的函数，用好了的话，就相当于分布式的 pandas。
在这里插入图片描述

下面就先来看一下关于数组的一些函数，这里先介绍一部分，提前感受一下ClickHouse的强大。

docker start docker-clickhouse

1 创建测试表

首先我们创建一张新表，并写入测试数据：

CREATE TABLE t2 (
    dt Date,
    cash Array(UInt8)
) ENGINE = Memory();

-- 然后写入数据
INSERT INTO t2 VALUES ('2020-01-01', [10,10,10]),
('2020-01-02', [20,20,20]), 
('2020-01-01', [10,10,10]),
('2020-01-02', [20,20]), 
('2020-01-03', []),
('2020-01-03', [30,30,30]);

-- 查询
SELECT * FROM t2;
dt        |cash      |
----------+----------+
2020-01-01|[10,10,10]|
2020-01-02|[20,20,20]|
2020-01-01|[10,10,10]|
2020-01-02|[20,20]   |
2020-01-03|[]        |
2020-01-03|[30,30,30]|

2 常用数组操作

2.1 groupArray和groupUniqArray

这个函数已经出现过一次了，我们说它是把多行数据合并成一个数组，相当于是聚合函数的一种。

select dt,groupArray(cash) from t2 group by dt;

dt        |groupArray(cash)       |
----------+-----------------------+
2020-01-01|[[10,10,10],[10,10,10]]|
2020-01-02|[[20,20,20],[20,20]]   |
2020-01-03|[[],[30,30,30]]        |

我们看到 groupArray 就等同于类似 count、sum 这样的聚合函数，将同一组的数据组合成一个新的数组。由于本来的元素就是数组，所以这里就是数组嵌套数组。

除了groupArray之外，还有一个groupUniqArray，在组合的时候会对元素进行去重：

select dt,groupUniqArray(cash) from t2 group by dt;

我们看到 '2020-01-01' 这行数据被去重了。
dt        |groupUniqArray(cash)|
----------+--------------------+
2020-01-01|[[10,10,10]]        |
2020-01-02|[[20,20],[20,20,20]]|
2020-01-03|[[],[30,30,30]]     |

2.2 arrayFlatten

SELECT dt, 
       groupArray(cash),
       arrayFlatten(groupArray(cash)) FROM t2 GROUP BY dt;
dt        |groupArray(cash)       |arrayFlatten(groupArray(cash))|
----------+-----------------------+------------------------------+
2020-01-01|[[10,10,10],[10,10,10]]|[10,10,10,10,10,10]           |
2020-01-02|[[20,20,20],[20,20]]   |[20,20,20,20,20]              |
2020-01-03|[[],[30,30,30]]        |[30,30,30]                    |

相信该函数的作用显而易见的，就是将多个嵌套数组扁平化，另外这里的查询语句还可以美化一下：

-- 使用 WITH 子句，提前将 groupArray(cash) 起一个别名
WITH groupArray(cash) AS group_cash
SELECT dt, 
       group_cash,
       arrayFlatten(group_cash) FROM t2 GROUP BY dt;
       
       
-- 或者这么做
SELECT dt,
       groupArray(cash) AS group_cash,
       arrayFlatten(group_cash) FROM t2 GROUP BY dt;

-- 我们看到即使是在 SELECT 里面起的别名也是可以被使用的
-- 另外顺序也没有限制，比如下面的做法也是合法的
SELECT dt, 
       arrayFlatten(group_cash), 
       groupArray(cash) AS group_cash FROM t2 GROUP BY dt;

2.3 splitByChar

将字符串按照指定字符分割成数组。

SELECT splitByChar('^', 'komeiji^koishi');

splitByChar('^', 'komeiji^koishi')|
----------------------------------+
['komeiji','koishi']              |

2.4 arrayJoin

该函数和 ARRAY JOIN 子句的作用非常类似：

select * from t1;
title|value  |
-----+-------+
food |[1,2,3]|
fruit|[3,4]  |
meat |[]     |

select title,arrayJoin(value) from t1;
title|arrayJoin(value)|
-----+----------------+
food |               1|
food |               2|
food |               3|
fruit|               3|
fruit|               4|

2.5 arrayMap

对数组中的每一个元素都以相同的规则进行映射：

-- arrayMap(x -> x * 2, value)表示将value中的每一个元素都乘以2，然后返回一个新数组
-- 而mapV 就是变换过后的新数组，直接拿来用即可
SELECT title, arrayMap(x -> x * 2, value) AS mapV, v
FROM t1 LEFT ARRAY JOIN mapV as v

title|mapV   |v|
-----+-------+-+
food |[2,4,6]|2|
food |[2,4,6]|4|
food |[2,4,6]|6|
fruit|[6,8]  |6|
fruit|[6,8]  |8|
meat |[]     |0|

-- 另外展开的字段也可以不止一个
SELECT title, 
       arrayMap(x -> x * 2, value) AS mapV, v,
       value, v_1
FROM t1 LEFT ARRAY JOIN mapV as v, value AS v_1

title|mapV   |v|value  |v_1|
-----+-------+-+-------+---+
food |[2,4,6]|2|[1,2,3]|  1|
food |[2,4,6]|4|[1,2,3]|  2|
food |[2,4,6]|6|[1,2,3]|  3|
fruit|[6,8]  |6|[3,4]  |  3|
fruit|[6,8]  |8|[3,4]  |  4|
meat |[]     |0|[]     |  0|

3 数组的相关操作函数

在一般的关系型数据库，相信很多人都不怎么使用数组这个结构，如果真的需要数组，那么会选择将其变成数组格式的字符串进行存储。但在ClickHouse中，数组的使用频率是非常高的，因为它内置了大量和数组有关的函数。

SELECT VERSION() ;
输出22.1.3.7
SELECT COUNT() FROM system.functions WHERE  name LIKE '%array%'; 
输出50，如下所示:
arrayEnumerateUniqRanked |
arrayJoin                |
arrayFilter              |
arrayDifference          |
arrayCumSumNonNegative   |
arrayCumSum              |
arraySort                |
arrayReverseSplit        |
arrayReverseFill         |
arrayFill                |
arrayLastIndex           |
arrayFirst               |
arrayProduct             |
arrayAvg                 |
arrayMax                 |
arrayMin                 |
arrayAll                 |
arrayExists              |
arrayMap                 |
arrayZip                 |
arraySlice               |
arrayAUC                 |
arrayStringConcat        |
arrayElement             |
arrayCount               |
arrayLast                |
arrayDistinct            |
array                    |
arrayReverseSort         |
arrayEnumerateDenseRanked|
arraySplit               |
arrayCompact             |
arrayIntersect           |
arrayPushFront           |
arrayConcat              |
arrayWithConstant        |
arrayFlatten             |
arrayPopFront            |
arrayFirstIndex          |
arrayUniq                |
arrayEnumerateUniq       |
arrayEnumerateDense      |
arrayResize              |
arrayReduceInRanges      |
arrayReduce              |
arrayPopBack             |
arrayPushBack            |
arraySum                 |
arrayReverse             |
arrayEnumerate           |

当前的 ClickHouse 是 22.1.3.7版本，关于数组的函数有50个，通过这个50个函数，我们可以对数组进行各种骚操作。当然也有一些函数不是专门针对数组的，但是可以用在数组身上，我们就也放在一起说了，下面就来依次介绍相关函数的用法。

3.1 检测数组或字符串是否为空empty

--检测数组是否为空
SELECT empty([1,2]),empty([]);
SELECT notEmpty([1,2]),notEmpty([]);  

--检测字符串是否为空
SELECT empty('test'),empty('');
SELECT notEmpty('test'),notEmpty('');

--返回字符串或数组长度
SELECT LENGTH([]),LENGTH([1,2]),LENGTH('test'),LENGTH('');

3.2 创建指定类型的空数组array

emptyArrayUInt8、emptyArrayUInt16、
emptyArrayUInt32、emptyArrayUInt64、
emptyArrayInt8、emptyArrayInt16、
emptyArrayInt32、emptyArrayInt64、
emptyArrayFloat32、emptyArrayFloat64、
emptyArrayDate、emptyArrayDateTime、emptyArrayString

-- 数组元素的类型为 nothing，因为没有指定任何元素
SELECT [] v, toTypeName(v);
/*
┌─v──┬─toTypeName(array())─┐
│ [] │ Array(Nothing)      │
└────┴─────────────────────┘
*/

-- 采用最小类型存储，因为 1 和 2 都在 UInt8 的范围内
SELECT [1, 2] v, toTypeName(v);
/*
┌─v─────┬─toTypeName([1, 2])─┐
│ [1,2] │ Array(UInt8)       │
└───────┴────────────────────┘
*/

-- 但是我们可以创建指定类型的数组
SELECT emptyArrayDateTime() v, toTypeName(v);
/*
┌─v──┬─toTypeName(emptyArrayDateTime())─┐
│ [] │ Array(DateTime)                  │
└────┴──────────────────────────────────┘
*/

array：也是创建一个数组，和直接使用方括号类似。但是 array 函数要求必须至少传递一个常量，否则就不知道要创建哪种类型的数组。如果想创建指定类型的空数组，那么使用上面的emptyArray* 系列函数即可
不管是使用array创建，还是使用[]创建，里面的元素都必须具有相同的类型，或者能够兼容。

SELECT array(1,2),[1,2];
-----------+------+
[1,2]      |[1,2] |

3.3 range

SELECT range(5);
-----------+
[0,1,2,3,4]|

SELECT range(3,6);
-----------+
[3,4,5]    |

SELECT range(1,6,2);
--------------+
[1,3,5]       |

3.4 合并数组arrayConat

arrayConat：将多个数组进行合并，得到一个新的数组

-- SELECT 中起的别名可以被直接其它字段所使用
SELECT [1, 2] v1, [11] v2, [111, 222] v3, arrayConcat(v1, v2, v3);
/*
v1   |v2  |v3       |arrayConcat([1, 2], [11], [111, 222])|
-----+----+---------+-------------------------------------+
[1,2]|[11]|[111,222]|[1,2,11,111,222]                     |
*/

3.5 查找指定索引的元素arrayElement

arrayElement：查找指定索引的元素，索引从1开始，也可以通过方括号直接取值；另外也支持负数索引，-1代表最后一个元素。

-- 索引从1开始，所以arr[1] 就表示第1个元素，也就是 32
with [32,24] as arr
select arrayElement(arr,1),arr[2],arr[-1];
/*
arrayElement(arr, 1)|arrayElement(arr, 2)|arrayElement(arr, -1)|
--------------------+--------------------+---------------------+
                  32|                  24|                   24|               
*/

3.6 判断数组里面是否包含某个元素has

has：判断数组里面是否包含某个元素，如果包含，返回 1；不包含，返回0

WITH [1, 2, Null] AS arr 
SELECT has(arr, 2), has(arr, 0), has(arr, Null);
/*
┌─has(arr, 2)─┬─has(arr, 0)─┬─has(arr, NULL)─┐
│           1 │           0 │              1 │
└─────────────┴─────────────┴────────────────┘
*/

-- 嵌套数组也是可以的
with [[1, 2]] as arr
SELECT has(arr, [1, 2]),has(arr,[1]);
/*
has(arr, [1, 2])|has(arr, [1])|
----------------+-------------+
               1|            0|
*/

3.7 判断数组里面是否包含某个子数组hasAll

hasAll：判断数组里面是否包含某个子数组，如果包含，返回1；不包含，返回0。
注意：空数组是任意数组的子集；
注意：Null 会被看成是普通的值；
注意：数组中的元素顺序没有要求；
注意：1.0 和 1 被视为相等。

hasAll([], [])：返回1。
hasAll([1, Null], [Null])：返回1。
hasAll([1.0, 2.0, 3.0], [2.0, 3.0, 1.0])：返回1，因为元素顺序无影响，并且 1.0和1被视为相等
hasAll(['a', 'b'], ['a'])：返回 1
hasAll(['a', 'b'], ['c'])：返回 0
hasAll([[1, 2], [3, 4]], [[1, 2], [3, 4]])：返回 1，嵌套数组也是可以的
在 has 函数里面也有嵌套数组，但是维度不同。比如 has(a, b)：如果 a 是维度为 N 的数组，那么 b 必须是维度为 N - 1 的数组；而 hasAll 则要求 a 和 b 的维度必须相同。

WITH [[1, 2], [11, 22]] AS arr, [[1, 2], [11, 22]] AS subset SELECT hasAll(arr, subset)
/*
┌─hasAll(arr, subset)─┐
│                   1 │
└─────────────────────┘
*/

-- 我们说 SELECT 里面别名可以给其它字段使用，因此下面这种做法也是合法的
WITH [[1, 2], [11, 22]] AS arr, arr AS subset SELECT hasAll(arr, subset)
/*
┌─hasAll(arr, subset)─┐
│                   1 │
└─────────────────────┘
*/

3.8 判断两个数组里面是否有相同的元素hasAny

hasAny：判断两个数组里面是否有相同的元素，只要有1个相同的元素，返回 1；否则，返回0。

SELECT hasAny([1.0, 2.0], [1]), hasAny([Null], [1, Null])
/*
┌─hasAny([1., 2.], [1])─┬─hasAny([NULL], [1, NULL])─┐
│                     1 │                         1 │
└───────────────────────┴───────────────────────────┘
*/

SELECT hasAny([[1, 2], [3, 4]], [[3, 4]])
/*
┌─hasAny([[1, 2], [3, 4]], [[3, 4]])─┐
│                                  1 │
└────────────────────────────────────┘
*/

3.9 hasSubstr

hasSubstr：和 hasAll 类似，但是顺序有要求，hasAll(arr, subset) 要求的是 subset 中的元素在 arr 中都出现即可；但是 hasSubstr 函数则不仅要求 subset 中的元素在 arr 中都出现，并且还要以相同的顺序。举个栗子：

hasSubstr([1, 2, 3], [2, 3])：返回 1
hasSubstr([1, 2, 3], [3, 2])：返回 0
hasSubstr([[1, 2], [2, 1], [3, 2]], [[3, 2]])：返回 1
-- 两个数组的维度必须相同
SELECT hasSubstr([1, 2, 3], [3, 2]), hasSubstr([1, 2, 3], [2, 3]);
/*
┌─hasSubstr([1, 2, 3], [3, 2])─┬─hasSubstr([1, 2, 3], [2, 3])─┐
│                            0 │                            1 │
└──────────────────────────────┴──────────────────────────────┘
*/

3.10 indexOf

indexOf：查找某个元素第一次在数组中出现的位置，索引从 1 开始；如果不存在，则返回 0

WITH [1, 2, 3, Null, 99] AS arr SELECT indexOf(arr, 100), indexOf(arr, 99), indexOf(arr, Null);
/*
┌─indexOf(arr, 100)─┬─indexOf(arr, 99)─┬─indexOf(arr, NULL)─┐
│                 0 │                5 │                  4 │
└───────────────────┴──────────────────┴────────────────────┘
*/

3.11 arrayCount

arrayCount：查找一个数组中非 0 元素的个数，该数组类的元素类型必须是 UInt8，并且不能包含 Null 值。因为一旦包含 Null，那么类型就不是 UInt8 了，而是 Nullable(UInt8)

SELECT arrayCount([1, 2, 3]), arrayCount([1, 2, 3, 4, 0]);
/*
┌─arrayCount([1, 2, 3])─┬─arrayCount([1, 2, 3, 4, 0])─┐
│                     3 │                           4 │
└───────────────────────┴─────────────────────────────┘
*/
此外 arrayCount 还有一种用法，就是接收一个函数和一个数组：

WITH [1, 2, 3, 4, 0] AS arr 
SELECT arrayCount(arr), 
       arrayCount(x -> cast(x + 1 AS UInt8), arr)
/*
┌─arrayCount(arr)─┬─arrayCount(lambda(tuple(x), CAST(plus(x, 1), 'UInt8')), arr)─┐
│               4 │                                                            5 │
└─────────────────┴──────────────────────────────────────────────────────────────┘
*/

ClickHouse 中的函数类似于 C++ 中的 lambda 表达式，x -> x + 1 相当于将 arr 中的每一个元素都加上 1，但结果得到整型是 UInt16，所以需要使用 cast 转成 UInt8，否则报错。另外，加上 1 之后就没有为 0 的元素了，所以返回的结果是 5。

3.12 countEqual返回某元素在数组中出现的次数

with [1,1,1,2,Null,Null] as arr
select countEqual(arr,1),countEqual(arr,Null);
/*
countEqual(arr, 1)|countEqual(arr, NULL)|
------------------+---------------------+
                 3|                    2|
*/

3.13 arrayEnumerate

arrayEnumerate：等价于先计算出数组的长度，假设为 N，然后返回 range(1, N + 1)

with range(1,5) as arr1,
[2,2,2,2] as arr2
select arr1,arrayEnumerate(arr2);
/*
arr1     |arrayEnumerate(arr2)|
---------+--------------------+
[1,2,3,4]|[1,2,3,4]           |
*/

3.14 arrayEnumerateUniq

arrayEnumerateUniq：从数组的第一个元素开始，每重复一次就加 1。

with ['a', 'a', 'c', 'b', 'c', 'a', 'b', 'b'] as arr
SELECT arrayEnumerateUniq(arr);
/*
arrayEnumerateUniq(arr)|
-----------------------+
[1,2,1,1,2,3,2,3]      |
*/

在这里插入图片描述
arrayEnumerateUniq 还可以接收多个数组，这些数据具有相同的长度。
此时会将多个数组作为一个整体来进行判断，因此这些数组都必须有相同的长度。

SELECT arrayEnumerateUniq(['a','a','b','a'], [1,1,5,1]);
等价于
select arrayEnumerateUniq([('a',1), ('a',1), ('b',5), ('a',1)]);

/*
arrayEnumerateUniq(['a', 'a', 'b', 'a'], [1, 1, 5, 1])|
------------------------------------------------------+
[1,2,1,3]                                             |
*/

3.15 arrayPopBack移除数组中的最后一个元素

显然它是可以被嵌套的：
注意：对空数组使用 arrayPopBack 不会报错，得到的还是空数组。

with [1,2,3] as arr
select arrayPopBack(arr),arrayPopBack(arrayPopBack(arr));
/*
arrayPopBack(arr)|arrayPopBack(arrayPopBack(arr))|
-----------------+-------------------------------+
[1,2]            |[1]                            |
*/

3.16 arrayPopFront移除数组中的第一个元素

也可以被嵌套，并且对空数组使用也不会报错，还是得到空数组。

with [1,2,3] as arr
select arrayPopFront(arr),arrayPopFront(arrayPopFront(arr));
/*
arrayPopFront(arr)|arrayPopFront(arrayPopFront(arr))|
------------------+---------------------------------+
[2,3]             |[3]                              |
*/

3.17 arrayPushBack从数组的尾部塞进一个元素

添加的时候记得类型要匹配，如果添加了 Null，那么数组会变成 Nullable。

select arrayPushBack([1,2],3);
/*
arrayPushBack([1, 2], 3)|
------------------------+
[1,2,3]                 |
*/

3.18 arrayPushFront从数组的头部塞进一个元素

SELECT arrayPushFront(['a', 'b', 'c'], 'd');
/*
┌─arrayPushFront(['a', 'b', 'c'], 'd')─┐
│ ['d','a','b','c']                    │
└──────────────────────────────────────┘
*/

添加的时候记得类型要匹配，如果添加了 Null，那么数组会变成 Nullable。

3.19 arrayResize改变数组的长度

如果指定的长度比原来的长度大，那么会用零值从尾部进行填充。
如果指定的长度比原来的长度小，那么会从尾部进行截断。

SELECT arrayResize(range(4),7), arrayResize(range(4),2);
/*
┌─arrayResize(range(4), 7)─┬─arrayResize(range(4), 2)─┐
│ [0,1,2,3,0,0,0]          │ [0,1]                    │
└──────────────────────────┴──────────────────────────┘
*/

在填充的时候，也可以使用指定的值进行填充：
注意Null会被补成0。

SELECT arrayResize(range(4), 7, 66), arrayResize(range(4), 7, Null);
/*
arrayResize(range(4), 7, 66)|arrayResize(range(4), 7, NULL)|
----------------------------+------------------------------+
[0,1,2,3,66,66,66]          |[0,1,2,3,0,0,0]               |
*/

3.20 arraySlice返回数组的一个片段

arraySlice(arr, M)：返回从索引为 M 开始以及之后的所有元素。
arraySlice(arr, M, N)：从索引为 M 的元素开始，总共返回 N 个元素。

SELECT arraySlice(range(1,10),3), arraySlice(range(1,10),3,4);
/*
┌─arraySlice(range(1, 10), 3)─┬─arraySlice(range(1, 10), 3, 4)─┐
│ [3,4,5,6,7,8,9]             │ [3,4,5,6]                      │
└─────────────────────────────┴────────────────────────────────┘
*/

3.21 arraySort对数据进行排序然后返回

SELECT arraySort([2,3,1]), arraySort(['abc','ab','c']);
/*
┌─arraySort([2, 3, 1])─┬─arraySort(['abc', 'ab', 'c'])─┐
│ [1,2,3]              │ ['ab','abc','c']              │
└──────────────────────┴───────────────────────────────┘
*/

字符串会按照字典序排序返回，整型、浮点型、日期都会按照大小返回。问题来了，如果我们希望按照字符串的长度排序该怎么办呢？所以 arraySort 还支持传递一个自定义函数：

-- 按照数组中元素的长度进行排序
SELECT arraySort(x -> length(x),['abc','ab','c']);
/*
┌─arraySort(lambda(tuple(x), length(x)), ['abc', 'ab', 'c'])─┐
│ ['c','ab','abc']                                           │
└────────────────────────────────────────────────────────────┘
*/

-- 按照正负号排序，小于0的排在大于0的左边
SELECT arraySort(x -> (x>0), [-3,1,3,-1,-2,2]);
/*
arraySort(lambda(tuple(x), greater(x, 0)), [-3, 1, 3, -1, -2, 2])|
-----------------------------------------------------------------+
[-3,-1,-2,1,3,2]                                                 |
*/

-- 按照绝对值进行排序
SELECT arraySort(x -> (abs(x)), [-3,1,3,-1,-2,2]);
/*
arraySort(lambda(tuple(x), abs(x)), [-3, 1, 3, -1, -2, 2])|
----------------------------------------------------------+
[1,-1,-2,2,-3,3]                                          |
*/


-- 先按照正负号排序，小于0的排在大于0的左边，然后各自再按照绝对值进行排序
SELECT arraySort(x -> (x > 0, abs(x)), [-3, 1, 2, -1, -2, 3]);
/*
┌─arraySort(lambda(tuple(x), tuple(greater(x, 0), abs(x))), [-3, 1, 2, -1, -2, 3])─┐
│ [-1,-2,-3,1,2,3]                                                                 │
└──────────────────────────────────────────────────────────────────────────────────┘
*/

这 ClickHouse 也太强大了吧，这简直不像是在写 SQL 了，都有点像写 Python 代码了，所以 ClickHouse 这么火不是没有原因的。

另外当出现空值或 NaN 的话，它们的顺序如下：

-inf 普通数值 inf NaN Null

所以 arraySort 如果接收一个参数，那么该参数必须是一个数组，然后 ClickHouse 按照默认的规则进行排序；如果接收两个参数，那么第一个参数是匿名函数，第二个参数是数组，此时 ClickHouse 会按照我们定义的函数来给数组排序；但其实 arraySort 还可以接收三个参数，第一个参数依旧是函数，然后第二个参数和第三个参数都是数组，此时会用数组给数组排序：

-- 因为有两个数组，所以匿名函数要有两个参数，x表示第一个数组、y表示第二个数组
-- 首先不管排序规则是什么，最终输出的都是第一个数组
-- x, y -> y 就表示按照第二个数组来给第一个数组进行排序输出
SELECT arraySort(x, y -> y, [1, 2, 3], [22, 11, 33]);
/*
┌─arraySort(lambda(tuple(x, y), y), [1, 2, 3], [22, 11, 33])─┐
│ [2,1,3]                                                    │
└────────────────────────────────────────────────────────────┘
*/

-- 同理 x, y -> x 返回的还是 [1, 2, 3]、 x, y -> -x 返回的是 [3, 2, 1]
-- 只不过此时第二个数组就用不上了

3.22 arrayReverseSort对数据进行逆序排序然后返回

该函数你可以认为它是先按照 arraySort 排序，然后将结果再反过来，举个栗子：

SELECT arraySort(x -> -x, [1, 2, 3]) sort, arrayReverseSort(x -> -x, [1, 2, 3]) reverse_sort;
/*
┌─sort────┬─reverse_sort─┐
│ [3,2,1] │ [1,2,3]      │
└─────────┴──────────────┘
*/

指定了匿名函数，按照相反数进行排序，因为 -3 < -2 < -1，所示 arraySort 排序之后就是 [3, 2, 1]，然后 arrayReverseSort 则是在其基础上直接返回，所以得到的还是 [1, 2, 3]。

至于其它用法和 arraySort 都是一样的，可以看做是在 arraySort 的基础上做了一次反转。不过有一点需要注意，那就是 Null 值和 NaN：

arraySort：-inf 普通数值 inf NaN Null
arrayReverseSort：inf 普通数值 -inf NaN Null

即使是 arrayReverseSort，NaN 和 Null 依然排在最后面。

3.23 arrayUniq返回数组中不同元素的数量

SELECT arrayUniq([1, 2, 3, 1, 4]);
/*
┌─arrayUniq([1, 2, 3, 1, 4])─┐
│                          4 │
└────────────────────────────┘
*/

也可以传递多个长度相同的数组，会依次取出所有数组中相同位置的元素，然后拼成元组，并计算这些不重复的元组的数量，举个栗子：

-- 相当于判断 arrayUniq( [('a', 1, 3), ('a', 1, 3), ('b', 2, 3)] )
SELECT arrayUniq(['a', 'a', 'b'], [1, 1, 2], [3, 3, 3]);
/*
┌─arrayUniq(['a', 'a', 'b'], [1, 1, 2], [3, 3, 3])─┐
│                                                2 │
└──────────────────────────────────────────────────┘
*/

3.24 arrayJoin将数组展开成多行

SELECT arrayJoin(range(1,3));
/*
arrayJoin(range(1, 3))|
----------------------+
                     1|
                     2|
*/

-- ||表示字符串拼接，当arrayJoin展开成多行的时候，会自动和其它字段组合
with range(1,3) as arr
SELECT arrayJoin(arr) AS v, 'A00' || cast(v AS String);
/*
v|concat('A00', CAST(arrayJoin(arr), 'String'))|
-+---------------------------------------------+
1|A001                                         |
2|A002                                         |
*/

-- 如果出现了多个arrayJoin ，那么会做笛卡尔积：
SELECT arrayJoin([1, 2]), arrayJoin([11, 22]);
/*
arrayJoin([1, 2])|arrayJoin([11, 22])|
-----------------+-------------------+
                1|                 11|
                1|                 22|
                2|                 11|
                2|                 22|
*/

3.25 groupArray将多行数据合并成数组

提到了arrJoin，那么就必须提一下groupArray，这算是一个聚合函数，它和 arrayJoin作用相反，将多行数据合并成数组。

SELECT number FROM numbers(3);
/*
number|
------+
     0|
     1|
     2|
*/

SELECT groupArray(number) FROM numbers(3);
/*
groupArray(number)|
------------------+
[0,1,2]           |
*/

3.26 groupUniqArray将多行数据去重合并成数组

除了groupArray，还有一个groupUniqArray，从名字上看显然多了一个去重的功能。

-- SELECT arrayJoin([1, 1, 2, 2, 3]) 会自动展开成多行
-- 当然我们也可以将它作为一张表
SELECT v FROM (SELECT arrayJoin([1, 1, 2, 2, 3]) v);
/*
┌─v─┐
│ 1 │
│ 1 │
│ 2 │
│ 2 │
│ 3 │
└───┘
*/

-- 通过 groupArray 再变成原来的数组
SELECT groupArray(v) FROM (SELECT arrayJoin([1, 1, 2, 2, 3]) v);
/*
┌─groupArray(v)─┐
│ [1,1,2,2,3]   │
└───────────────┘
*/

-- 如果使用 groupUniqArray 的话
SELECT groupUniqArray(v) FROM (SELECT arrayJoin([1, 1, 2, 2, 3]) v);
/*
┌─groupUniqArray(v)─┐
│ [2,1,3]           │
└───────────────────┘
*/

3.27 arrayDifference数组每相邻两个元素的差值

-- 第一个元素固定为0，第二个元素为3-1，第三个元素为4-3，以此类推
-- 相邻元素相减
SELECT arrayDifference([1, 3, 4, 7, 10])
/*
┌─arrayDifference([1, 3, 4, 7, 10])─┐
│ [0,2,1,3,3]                       │
└───────────────────────────────────┘
*/

3.28 arrayDistinct对数组中的元素进行去重

SELECT arrayDistinct([1, 1, 1, 2, 2, 3]);
/*
┌─arrayDistinct([1, 1, 1, 2, 2, 3])─┐
│ [1,2,3]                           │
└───────────────────────────────────┘
*/

3.29 arrayEnumerateDense

arrayEnumerateDense：返回一个和原数组大小相等的数组，并指示每个元素在原数组中首次出现的位置（索引都是从 1 开始）

-- 22 首次出现在索引为 1 的位置、1 首次出现在索引为 2 的位置
-- 13 首次出现在索引为 4 的位置，因此结果为 [1, 2, 1, 3, 2, 3]
SELECT arrayEnumerateDense([22, 1, 22, 13, 1, 13]);
/*
┌─arrayEnumerateDense([22, 1, 22, 13, 1, 13])─┐
│ [1,2,1,3,2,3]                               │
└─────────────────────────────────────────────┘
*/

3.30 arrayIntersect接收多个数组并取它们的交集

SELECT arrayIntersect([1, 2], [2, 3], [3, 4]), arrayIntersect([1, 2], [2, 3], [2, 4]);
/*
┌─arrayIntersect([1, 2], [2, 3], [3, 4])─┬─arrayIntersect([1, 2], [2, 3], [2, 4])─┐
│ []                                     │ [2]                                    │
└────────────────────────────────────────┴────────────────────────────────────────┘
*/

3.31 arrayReduce将一个聚合函数作用在数组上

SELECT arrayReduce('max',[1,23,6]), arrayReduce('sum',[1,23,6]);
/*
┌─arrayReduce('max', [1, 23, 6])─┬─arrayReduce('sum', [1, 23, 6])─┐
│                             23 │                             30 │
└────────────────────────────────┴────────────────────────────────┘
*/

可能有人觉得直接用聚合函数不就好了，答案是不行的，因为这些聚合函数针对的都是多行结果集，而不是数组。

-- 相当于只有一行数据，所以返回其本身
-- 如果是 sum 就直接报错了， 因为数组之间不能进行加法运算
SELECT max([11, 33, 22]);
/*
┌─max([11, 33, 22])─┐
│ [11,33,22]        │
└───────────────────┘
*/

-- 如果想返回 33，我们应该将这个数组给展开，变成多行
SELECT max(arrayJoin([11, 33, 22]));
/*
┌─max(arrayJoin([11, 33, 22]))─┐
│                           33 │
└──────────────────────────────┘
*/

所以聚合函数针对的是多行，而不是数组，如果想用聚合函数，那么应该将数组给展开。或者使用这里的 arrayReduce，相当于将两步合在一起了。当然我们也可以不用 arrayReduce，因为 ClickHouse 为了数组专门提供了相应的操作，比如求数组中最大的元素可以使用更强大的 arrayMax，后面说。

3.32 arrayReduceInRanges

对给定范围内的数组元素应用聚合函数

-- 会对数组中索引为 1 开始向后的 5 个元素进行 sum，结果为 15
-- 会对数组中索引为 2 开始向后的 4 个元素进行 sum，结果为 14
-- 会对数组中索引为 1 开始向后的 3 个元素进行 sum，结果为 6
SELECT arrayReduceInRanges(
    'sum',
    [(1, 5), (2, 4), (1, 3)],
    [1, 2, 3, 4, 5]
)
/*
┌─arrayReduceInRanges('sum', array((1, 5), (2, 4), (1, 3)), [1, 2, 3, 4, 5])─┐
│ [15,14,6]                                                                  │
└────────────────────────────────────────────────────────────────────────────┘
*/

-- 以上等价于
WITH [1, 2, 3, 4, 5] AS arr 
SELECT [arrayReduce('sum', arraySlice(arr, 1, 5)), 
        arrayReduce('sum', arraySlice(arr, 2, 4)),
        arrayReduce('sum', arraySlice(arr, 1, 3))] AS v
/*
┌─v─────────┐
│ [15,14,6] │
└───────────┘
*/

3.33 arrayReverse对数组进行逆序

我们之前还介绍了一个 arrayReverseSort，它在逆序之前会先排序，而这里的 arrayReverse 只是单纯的逆序

-- arrayReverse 和 reverse 作用相同
SELECT arrayReverse([22, 33, 11]), reverse([22, 33, 11]);
/*
┌─arrayReverse([22, 33, 11])─┬─reverse([22, 33, 11])─┐
│ [11,33,22]                 │ [11,33,22]            │
└────────────────────────────┴───────────────────────┘
*/

3.34 arrayFlatten将数组扁平化

-- arrayFlatten 也可以使用 flatten 代替
SELECT arrayFlatten([[1, 2, 3], [11, 22, 33]]);
/*
┌─arrayFlatten([[1, 2, 3], [11, 22, 33]])─┐
│ [1,2,3,11,22,33]                        │
└─────────────────────────────────────────┘
*/

我们之前还介绍了一个 arrayConcat，可以对比一下两者的区别

SELECT arrayConcat ([1, 2, 3], [11, 22, 33]);
/*
┌─arrayConcat([1, 2, 3], [11, 22, 33])─┐
│ [1,2,3,11,22,33]                     │
└──────────────────────────────────────┘
*/

3.35 arrayCompact从数组中删除连续重复的元素

SELECT arrayCompact([2, 2, 1, 1, 1, 3, 3, Null, Null]);
/*
┌─arrayCompact([2, 2, 1, 1, 1, 3, 3, NULL, NULL])─┐
│ [2,1,3,NULL]                                    │
└─────────────────────────────────────────────────┘
*/

我们看到作用类似于之前介绍的 arrayDistinct，但两者还是有区别的。

SELECT arrayDistinct([2, 2, 1, 1, 1, 3, 3, NULL, NULL])
/*
┌─arrayDistinct([2, 2, 1, 1, 1, 3, 3, NULL, NULL])─┐
│ [2,1,3]                                          │
└──────────────────────────────────────────────────┘
*/

我们发现 arrayDistinct 不包含 Null 值。

3.36 arrayZip类似于Python中的zip

SELECT arrayZip(['a', 'b', 'c'], [1, 2, 3], ['x', 'y', 'z']);
/*
┌─arrayZip(['a', 'b', 'c'], [1, 2, 3], ['x', 'y', 'z'])─┐
│ [('a',1,'x'),('b',2,'y'),('c',3,'z')]                 │
└───────────────────────────────────────────────────────┘
*/

3.37 arrayMap对数组每个元素作用相同的函数

arrayMap：对数组中每一个元素都作用相同的函数，根据函数的返回值创建一个新的数组，非常常用的一个功能。

SELECT arrayMap(x -> (x, 1), ['a', 'b', 'c']);
/*
┌─arrayMap(lambda(tuple(x), tuple(x, 1)), ['a', 'b', 'c'])─┐
│ [('a',1),('b',1),('c',1)]                                │
└──────────────────────────────────────────────────────────┘
*/

SELECT arrayMap(x -> x * 2, [1, 2, 3]) v1, sum(arrayJoin(v1)) v2, arrayReduce('sum', v1) v3;
/*
┌─v1──────┬─v2─┬─v3─┐
│ [2,4,6] │ 12 │ 12 │
└─────────┴────┴────┘
*/
当然也可以作用嵌套数组：

SELECT arrayMap(x -> arrayReduce('sum', x), [[1, 2, 3], [11, 22, 33], [33, 44, 55]]);
/*
┌─arrayMap(lambda(tuple(x), arrayReduce('sum', x)), [[1, 2, 3], [11, 22, 33], [33, 44, 55]])─┐
│ [6,66,132]                                                                                 │
└────────────────────────────────────────────────────────────────────────────────────────────┘
*/

SELECT arrayMap(x -> arrayReduce('max', x), [[1, 2, 3], [11, 22, 33], [33, 44, 55]]);
/*
┌─arrayMap(lambda(tuple(x), arrayReduce('max', x)), [[1, 2, 3], [11, 22, 33], [33, 44, 55]])─┐
│ [3,33,55]                                                                                  │
└────────────────────────────────────────────────────────────────────────────────────────────┘
*/

SELECT arrayMap(x -> arrayReduce('min', x), [[1, 2, 3], [11, 22, 33], [33, 44, 55]]);
/*
┌─arrayMap(lambda(tuple(x), arrayReduce('max', x)), [[1, 2, 3], [11, 22, 33], [33, 44, 55]])─┐
│ [1,11,33]                                                                                  │
└────────────────────────────────────────────────────────────────────────────────────────────┘
*/
也可以作用多个数组，这些数组的长度必须相等。此外，有多个数组，函数就要有多少个参数：

-- 得到的是 [1 + 11 + 33, 2 + 22 + 44, 3 + 33 + 55]
-- 如果是 arrayMap(x -> arrayReduce('sum', x), [[1, 2, 3], [11, 22, 33], [33, 44, 55]])
-- 那么得到的是 [1 + 2 + 3, 11 + 22 + 33, 33 + 44 + 55]
SELECT arrayMap(x, y, z -> arrayReduce('sum', [x, y, z]), [1, 2, 3], [11, 22, 33], [33, 44, 55]) AS v;
/*
┌─v──────────┐
│ [45,68,91] │
└────────────┘
*/

SELECT arrayMap(x, y, z -> (x + y, z), [1, 2, 3], [11, 22, 33], [33, 44, 55]) AS v;
/*
┌─v─────────────────────────┐
│ [(12,33),(24,44),(36,55)] │
└───────────────────────────┘
*/

3.38 arrayFilter对数组中每个元素作用相同的函数

arrayFilter：对数组中每一个元素都作用相同的函数，如果函数返回值为真（非 0），则该元素保留，否则不保留。

SELECT arrayFilter(x -> x > 5, [1, 4, 5, 7, 10]);
/*
┌─arrayFilter(lambda(tuple(x), greater(x, 5)), [1, 4, 5, 7, 10])─┐
│ [7,10]                                                         │
└────────────────────────────────────────────────────────────────┘
*/

SELECT arrayFilter(x -> length(x) > 1, ['a', 'aa', 'aaa']);
/*
┌─arrayFilter(lambda(tuple(x), greater(length(x), 1)), ['a', 'aa', 'aaa'])─┐
│ ['aa','aaa']                                                             │
└──────────────────────────────────────────────────────────────────────────┘
*/

SELECT arrayFilter(x -> x LIKE 'sa%', ['satori', 'koishi']);
/*
┌─arrayFilter(lambda(tuple(x), like(x, 'sa%')), ['satori', 'koishi'])─┐
│ ['satori']                                                          │
└─────────────────────────────────────────────────────────────────────┘
*/

3.39 arrayFill对数组中每个元素作用相同的函数

arrayFill：对数组中每一个元素都作用相同的函数，如果函数返回值为真，则该元素保留，否则被替换为前一个元素。

-- 2 会被替换成 4，1 会被替换成 5
SELECT arrayFill(x -> x >= 3, [3, 4, 2, 5, 1]);
/*
┌─arrayFill(lambda(tuple(x), greaterOrEquals(x, 3)), [3, 4, 2, 5, 1])─┐
│ [3,4,4,5,5]                                                         │
└─────────────────────────────────────────────────────────────────────┘
*/

-- 第一个元素永远不会被替换，2、3、4、5 都不满足条件，因此都要换成前一个元素
-- 换 2 的时候，2 已经变成了 1，所以 3 的前面是 1，于是 3 也会变成 1
-- 4 和 5 也是同理，因此最终所有值都会变成 1
SELECT arrayFill(x -> x >= 6, [1, 2, 3, 4, 5]);
/*
┌─arrayFill(lambda(tuple(x), greaterOrEquals(x, 6)), [1, 2, 3, 4, 5])─┐
│ [1,1,1,1,1]                                                         │
└─────────────────────────────────────────────────────────────────────┘
*/

3.40 arrayReverseFill对数组每个元素作用相同的函数

arrayReverseFill：对数组中每一个元素都作用相同的函数，如果函数返回值为真，则该元素保留，否则被替换为后一个元素。注意：此时数组是从后往前扫描的

-- 2 会被替换成 5，1 还是 1，最后一个元素不会被替换
SELECT arrayReverseFill(x -> x >= 3, [3, 4, 2, 5, 1]);
/*
┌─arrayReverseFill(lambda(tuple(x), greaterOrEquals(x, 3)), [3, 4, 2, 5, 1])─┐
│ [3,4,5,5,1]                                                                │
└────────────────────────────────────────────────────────────────────────────┘
*/

-- 因为数组从后往前扫描，所以 4 变成 5、3 也会变成 5，所有值都会变成 5
SELECT arrayReverseFill(x -> x >= 6, [1, 2, 3, 4, 5]);
/*
┌─arrayReverseFill(lambda(tuple(x), greaterOrEquals(x, 6)), [1, 2, 3, 4, 5])─┐
│ [5,5,5,5,5]                                                                │
└────────────────────────────────────────────────────────────────────────────┘
*/

3.41 arrayMin返回数组中最小的元素

arrayMin：返回数组中最小的元素

WITH [11, 22, 8, 33] AS arr 
SELECT arrayMin(arr) v1, min(arrayJoin(arr)) v2, arrayReduce('min', arr) v3;
/*
┌─v1─┬─v2─┬─v3─┐
│  8 │  8 │  8 │
└────┴────┴────┘
*/

arrayMin 里面还可以传递一个匿名函数：

SELECT arrayMin(x -> -x, [11, 22, 8, 33])
/*
┌─arrayMin(lambda(tuple(x), negate(x)), [11, 22, 8, 33])─┐
│                                                    -33 │
└────────────────────────────────────────────────────────┘
*/

会按照调用匿名函数的返回值进行判断，选择最小的元素，这里 33 在调用之后返回 -33，显然是最小值。但是这里有一个需要注意的地方，就是它返回的也是匿名函数的返回值。个人觉得应该返回 33 才对，应为我们指定函数只是希望 ClickHouse 能够按照我们指定的规则进行排序，而值还是原来的值，但 ClickHouse 这里设计有点莫测高深了。如果我们以字符串为例，那么会看的更加明显：

SELECT arrayMin(x -> length(x), ['ab', 'abc', 'a']) v;
/*
┌─v─┐
│ 1 │
└───┘
*/

我们看到居然返回了一个 1，我们的本意是想选择长度最短的字符串，但是返回的是最短字符串的长度，也就是返回的不是 ‘a’，而是 length(‘a’)。

3.42 arrayMax返回数组中最大的元素

WITH [11, 22, 8, 33] AS arr 
SELECT arrayMax(arr) v1, max(arrayJoin(arr)) v2, arrayReduce('max', arr) v3;
/*
┌─v1─┬─v2─┬─v3─┐
│ 33 │ 33 │ 33 │
└────┴────┴────┘
*/

也可以加上一个匿名函数，作用和 arrayMin 完全一样，并且返回的也是函数调用之后的结果。

3.43 arraySum对数组求总和

WITH range(1, 101) AS arr 
SELECT arraySum(arr), arrayReduce('sum', arr), sum(arrayJoin(arr));
/*
┌─arraySum(arr)─┬─arrayReduce('sum', arr)─┬─sum(arrayJoin(arr))─┐
│          5050 │                    5050 │                5050 │
└───────────────┴─────────────────────────┴─────────────────────┘
*/

同样可以加一个匿名函数：

WITH range(1, 101) AS arr SELECT arraySum(x -> x * 2, arr);
/*
┌─arraySum(lambda(tuple(x), multiply(x, 2)), arr)─┐
│                                           10100 │
└─────────────────────────────────────────────────┘
*/

3.44 arrayProduct对数组求总乘积

SELECT arrayProduct([1, 2, 3, 4, 5]);
/*
┌─arrayProduct([1, 2, 3, 4, 5])─┐
│                           120 │
└───────────────────────────────┘
*/

同样可以加一个匿名函数：

SELECT arrayProduct(x -> x + 1, [1, 2, 3, 4, 5]);
/*
┌─arrayProduct(lambda(tuple(x), plus(x, 1)), [1, 2, 3, 4, 5])─┐
│                                                         720 │
└─────────────────────────────────────────────────────────────┘
*/

3.45 arrayAvg对数组取平均值

WITH range(1, 101) AS arr 
SELECT arrayAvg(arr), arrayReduce('avg', arr), avg(arrayJoin(arr));
/*
┌─arrayAvg(arr)─┬─arrayReduce('avg', arr)─┬─avg(arrayJoin(arr))─┐
│          50.5 │                    50.5 │                50.5 │
└───────────────┴─────────────────────────┴─────────────────────┘
*/

同样可以加一个匿名函数：

WITH range(1, 101) AS arr 
SELECT arrayAvg(x -> x * 2, arr);
/*
┌─arrayAvg(lambda(tuple(x), multiply(x, 2)), arr)─┐
│                                             101 │
└─────────────────────────────────────────────────┘
*/

3.46 arrayCumSum对数组进行累和

-- 第一个元素不变
SELECT arrayCumSum([1, 2, 3, 4, 5]);
/*
┌─arrayCumSum([1, 2, 3, 4, 5])─┐
│ [1,3,6,10,15]                │
└──────────────────────────────┘
*/

同样可以加一个匿名函数：

-- 第一个元素不变
SELECT arrayCumSum(x -> x * 2, [1, 2, 3, 4, 5]), arrayCumSum([2, 4, 6, 8, 10]);
/*
┌─arrayCumSum(lambda(tuple(x), multiply(x, 2)), [1, 2, 3, 4, 5])─┬─arrayCumSum([2, 4, 6, 8, 10])─┐
│ [2,6,12,20,30]                                                 │ [2,6,12,20,30]                │
└────────────────────────────────────────────────────────────────┴───────────────────────────────┘
*/

4 小结

以上就是关于 ClickHouse 数组的一些函数操作，可以说是非常强大了，不光是功能强大，用起来也很舒服，仿佛有种在写 Python 代码的感觉。当然以上并不是关于数组的全部操作（绝大部分），但说实话已经够用了，即使你当前的需求，某一个函数不能解决，那么也能多个函数组合来解决。比如我们想要计算两个数组中相同位置的元素的差，那么就可以这么做：

-- 一个函数即可解决
SELECT arrayMap(x, y -> x - y, [1, 2, 3], [3, 2, 1]);
/*
┌─arrayMap(lambda(tuple(x, y), minus(x, y)), [1, 2, 3], [3, 2, 1])─┐
│ [-2,0,2]                                                         │
└──────────────────────────────────────────────────────────────────┘
*/

再比如，计算数组中每个元素减去上一个元素的值，由于第一个元素上面没有值，那么设为空：

-- 我们只需要选择 arr 的前 N - 1 个元素，然后再在头部插入一个 Null，[Null, 11, 22, 33, 44, 55]
-- 最后让 arr 和它的对应元素依次相减即可
WITH [11, 22, 33, 44, 55, 66] AS arr
SELECT arrayMap(
    x, y -> x - y, 
    arr, 
    arrayPushFront(arraySlice(arr, 1, length(arr) - 1), Null)
) v;
/*
┌─v─────────────────────┐
│ [NULL,11,11,11,11,11] │
└───────────────────────┘
*/

显然即使是复杂的需求，也可以通过多个函数组合完成，怎么样，是不是有点酷呢？ClickHouse 内建了很多的函数，这些函数给我们一种仿佛在用编程语言写代码的感觉。

皮皮冰燃
关注
专栏目录
clickhouse-jdbc（从0.2.4到0.3.2版本）.zip
01-12
Clickhouse是一个高性能的列式数据库管理系统（DBMS），特别适用于在线分析处理(OLAP)场景。而JDBC驱动则是Java开发者在处理Clickhouse时的关键组件。以下是关于这些版本中可能涉及的一些关键知识点： 1. **版本...
【clickhouse】Array数组查询操作
微雨停了的博客
01-19 2008
判断数组里是否含有元素，第一个参数是表达式，表示x经过运算是否=元素，第二个参数即是数组，可用ck列名代替，如果含有即是1，不含即为0。coalesce可将NULL值替换成空字符串或0，便于操作。搭配>0或=1使用。
ClickHouse 聚合函数
热门推荐
thinker
03-18 2万+
ClickHouse 聚合函数 本贴最后更新于783天前，其中的信息可能已经水流花落 背景 ClickHouse 中内置许多标准 SQL 外的函数。 这里记录一下其中聚合函数的学习笔记。 聚合函数 常用函数 count 返回记录条数。 如 SELECT count() FROM table 注：如果求COUNT(DISTINCT x)，则使用uniq函数 ...
clickhouse高阶函数--数组去重,拼接,排序,增删,排序
最新发布
weixin_53734409的博客
07-11 281
clickhouse高阶函数--数组去重,拼接,排序,增删,排序
clickhouse将字段拆分成数组
您的电脑已关机
02-03 2239
clickhouse将字段拆分成数组
数组
qq_40587369的博客
09-11 386
数组 一维数组 ​ 一维数组的声明 ​ int[] arr; ​ int arr[]; ​ 数组的创建; ​ arr = {1,2,3}; ​ arr= new int[10]; ​ arr= new int[]{1,2,3}; 二维数组 ​ 二维数组的声明 ​ int[] [] arr; ​ int [] arr []; ​ 二维数组的创建 ​ arr = new int[ 10] [ ]; ​ arr = new int[ 10] [10]; 数组的内存模型 冒泡排序 方法的调用 无参无返回值 无参有
ClickHouse聚合函数groupUniqArray如何理解？
宋发元
03-18 957
假设我们有一个包含用户ID和其所喜欢的水果的数据表，我们想要按照用户ID进行分组，并将每个用户喜欢的水果收集到一个数组中。ClickHouse是一个面向列的分布式数据库管理系统，它提供了丰富的聚合函数来对数据进行分析和处理。现在，我们想要按用户ID进行分组，并将每个用户所喜欢的水果收集到一个数组中。这样，我们就实现了按用户ID分组，并将每个用户所喜欢的水果收集到一个数组中的功能。是一种聚合函数，用于在对数据进行分组时，将每个组内的唯一值组合成一个数组。函数确保在每个数组中只包含唯一的水果值。
nim-clickhouse：Nim Clickhouse界面
02-03
7. **性能优化**：利用Nim的高效特性和ClickHouse的列式存储优势，nim-clickhouse库在性能上进行了优化，使得大数据操作更为快速。 **使用nim-clickhouse** 要使用nim-clickhouse库，首先需要安装Nim和nimble（Nim...
ansible-role-clickhouse:ClickHouse的角色
05-15
ClickHouse 是一个高性能、列式存储的分布式数据库管理系统（DBMS），特别适合在线分析处理（OLAP）。它能够实时处理大量数据，并且提供了SQL查询接口，使得数据查询和分析变得简单高效。以下是一些关于 ClickHouse ...
clickhouse-jdbc-bridgeRPM安装包适应于centos8
01-04
ClickHouse是一款高性能的开源列式数据库管理系统（Column-Oriented DBMS），主要用于在线分析处理（OLAP）。在大数据分析领域，ClickHouse因其优秀的查询性能和数据处理能力而受到广泛欢迎。JDBC桥（clickhouse-...
clickhouse-rs:ClickHouse的Rust客户端库
03-18
ClickHouse是一个高性能的列式数据库管理系统（Column-Oriented DBMS），常用于在线分析处理（OLAP）场景，特别适合大数据量的数据查询。 ClickHouse的主要特性包括其卓越的查询速度、支持SQL语法以及对分布式处理...
ClickHouse数据查询
花&败
04-28 3649
1.查询语法 [WITH expr_list|(subquery)] SELECT [DISTINCT] expr_list [FROM [db.]table | (subquery) | table_function] [FINAL] [SAMPLE sample_coeff] [ARRAY JOIN ...] [GLOBAL] [ANY|ALL|ASOF] [INNER|LEFT|RIGHT|FULL|CROSS] [OUTER|SEMI|ANTI] JOIN (subquery)|table (
Clickhouse 行列转换
vkingnew 的技术博客
07-09 8526
CREATE TABLE datasets.t_city ( `province` String, `city` String, `createtime` DateTime, `city_level` Int8 ) ENGINE = MergeTree() ORDER BY province SETTINGS index_granularity = 8192； insert into t_city values('Hubei','Wuhan',now(),2),.
全网最细最全OLAP之clickhouse笔记|clickhouse文档|clickhouse揭秘文档(四)--clickhouse的数据类型
HANG.NIAN
08-15 1531
1 数据类型 在建表的时候指定字段的数据类型, 数据类型在使用的时候是区分大小写的 ,所以在定义字段的时候一定注意数据类型的书写 1.1 整数数据类型 Int Ranges Int8 - [-128 : 127] Int16 - [-32768 : 32767] Int32 - [-2147483648 : 2147483647] Int64 - [-9223372036854775808 : 9223372036854775807] Uint Ranges UInt8 - [0 : 2..
Clickhouse 字符串切分 及 一行转多行函数
weixin_42282445的博客
03-23 7829
Clickhouse 字符串切分 及 一行转多行函数 1.字符串切分 字符串拆分函数 splitByChar（分隔符，s) 例如： ​ 对字符串 123_456_142354_23543__ 进行切割 select splitByChar('_', '123_456_142354_23543__') AS arr； 如图所示，可以得到切割之后的字符串数组。 2.数组类型的元素 一行打散转多行 ’arrayJoin’函数获取每一行并将他们展开到多行（unfold）。 例如： ​ 将上诉字符串数组展开打散到多
【总结卡】clickhouse数据库常用高级函数
积跬步，慕至千里的博客
11-07 1680
clickhouse常用高级函数总结
ClickHouse高级学习（四）Clickhouse数据查询（待更新）
qq_41816516的博客
04-18 5380
文章目录数据查询WITH子句SAMPLE子句ARRAY JOIN子句JOIN 子句LIMIT BY 子句LIMIT查看SQL执行计划 数据查询 注意事项： 在clickhouse里面不要使用select * 这样的语句，这种语句对于列式存储来说很容易消耗内存 WITH子句 Clickhouse 支持CTE 也就是公共表达式，用于增强查询语句的表达，表现如下： With子句的第一种用法：定义变量，这些变量可以在后续的查询子句中被直接访问 With子句的第二种用法：调用函数，可以访问S
Hive / ClickHouse 行转列函数 collect_set() / groupUniqArray() 入门
牛肉胡辣汤
11-02 1045
以上就是在 Hive 和 ClickHouse 中使用 collect_set() 和 groupUniqArray() 函数实现行转列操作的介绍和示例。[["技能A", "初级"], ["技能B", "中级"]][["技能A", "中级"], ["技能C", "高级"]][["技能A", "初级"], ["技能C", "高级"]]​ 函数用于将一列的数据转换为一个无重复元素的数组。假设我们有一个用户表，记录每个用户的技能和对应的级别。​ 函数可以将同一个学生的科目和成绩转换为数组。
clickhouse里的数组数据类型与相关使用介绍
闫玉林的博客
05-02 4779
本次主要介绍clickhouse最传统的数组 Array(T)，Array(T)是一种将T类型的值组合成一个有序列表的数据结构，存储的数值类型必须是T数组类型可以使用[]语法来表示，数组类型创建查询包含查询
ClickHouse深度解析：列式数据库在OLAP中的优势
列式存储使得ClickHouse在处理分析查询时表现出色，因为数据按列存储，对于只需要读取部分列的查询，I/O操作显著减少，同时数据更容易被压缩，降低了存储需求。此外，列式数据库在处理宽表（包含大量列）时，相比于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

皮皮冰燃

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值