ClickHouse基于数据分析常用函数-编程知识

文章标题

一、WITH语法-定义变量
- 1.1 定义变量
- 1.2 调用函数
- 1.3 子查询
二、GROUP BY子句（结合WITH ROLLUP、CUBE、TOTALS）
三、FORM语法
- 3.1表函数
- - 3.1.1 file
  - 3.1.2 numbers
  - 3.1.3 mysql
  - 3.1.4 hdfs
四、ARRAY JOIN语法（区别于arrayJoin(arr)函数）
五、连续销售案例
六、连接函数
- 6.1 连接精度
- - 6.1.1 ALL
  - 6.1.2 ANY
  - 6.1.3 ASOF
七、系统函数介绍
八、JSON解析案例
九、实用函数
十、语法注意事项

背景：基于初次接触数据分析，对ck函数的不熟悉，此文章主要基于ck特有的sql语法来做讲解；
官网：https://clickhouse.tech/docs/zh

一、WITH语法-定义变量

ClickHouse支持CTE（Common Table Expression,公共表达式），以增强查询语句的表达

SELECT pow(2, 2);┌─pow(2, 2)─┐
│         4 │
└───────────┘SELECT pow(pow(2, 2), 2);┌─pow(pow(2, 2), 2)─┐
│                16 │
└───────────────────┘

在改用CTE的形式后，可以极大地提高语句的可读性和维护性。

WITHpow(2, 2) AS a
SELECT pow(a, 2);┌─pow(a, 2)─┐
│        16 │
└───────────┘

1.1 定义变量

可以定义变量，这些变量能够在后续的查询子句中被直接访问。

# tb_mysql- 创建数据
DROP TABLE IF EXISTS tb_mysql;
CREATE TABLE tb_mysql (id UInt8,name String,age UInt8
)ENGINE = MergeTree()
ORDER BY id;
INSERT INTO tb_mysql VALUES ('1', 'tom', 23);
INSERT INTO tb_mysql VALUES ('2', 'lisa', 33);
INSERT INTO tb_mysql VALUES ('3', 'henry', 44);
INSERT INTO tb_mysql VALUES ('1', 'linda', 23);
INSERT INTO tb_mysql VALUES ('2', 'ross', 33);
INSERT INTO tb_mysql VALUES ('1', 'julie', 23);
INSERT INTO tb_mysql VALUES ('2', 'niki', 33);# 数据分析
WITH 1  AS constant
SELECTid + constant,name
FROMtb_mysql;┌─plus(id, constant)─┬─name─┐
│                  3 │ niki │
└────────────────────┴──────┘
┌─plus(id, constant)─┬─name──┐
│                  2 │ tom   │
│                  2 │ linda │
│                  2 │ julie │
│                  3 │ lisa  │
│                  3 │ ross  │
│                  4 │ henry │
└────────────────────┴───────┘

1.2 调用函数

可以访问SELECT子句中的列字段，并调用函数做进一步的加工处理

# tb_partition-创造数据
DROP TABLE IF EXISTS tb_partition;
CREATE TABLE tb_partition (id UInt8,name String,birthday String
)ENGINE = MergeTree()
ORDER BY id;
INSERT INTO tb_partition VALUES ('1', 'x1', '2024-05-20 10:50:46');
INSERT INTO tb_partition VALUES ('2', 'xy', '2024-05-20 11:17:47');
INSERT INTO tb_partition VALUES ('3', 'xf', '2024-05-19 11:11:12');# 数据分析
WITH toDate(birthday) AS bday
SELECTid,name,bday
FROMtb_partition;┌─id─┬─name─┬───────bday─┐
│  1 │ x1   │ 2024-05-20 │
└────┴──────┴────────────┘
┌─id─┬─name─┬───────bday─┐
│  2 │ xy   │ 2024-05-20 │
└────┴──────┴────────────┘
┌─id─┬─name─┬───────bday─┐
│  3 │ xf   │ 2024-05-19 │
└────┴──────┴────────────┘

1.3 子查询

可以定义子查询，在WITH中使用子查询时有一点需要特别注意，该查询语句只能返回一行数据，如果结果集的数据大于一行则会抛出异常；

WITH (SELECT *FROM tb_partitionWHERE tb_partition.id = '1') AS sub
SELECT* ,sub
FROM tb_partition;┌─id─┬─name─┬─birthday────────────┬─sub────────────────────────────┐
│  3 │ xf   │ 2024-05-19 11:11:12 │ (1,'x1','2024-05-20 10:50:46') │
└────┴──────┴─────────────────────┴────────────────────────────────┘
┌─id─┬─name─┬─birthday────────────┬─sub────────────────────────────┐
│  2 │ xy   │ 2024-05-20 11:17:47 │ (1,'x1','2024-05-20 10:50:46') │
└────┴──────┴─────────────────────┴────────────────────────────────┘
┌─id─┬─name─┬─birthday────────────┬─sub────────────────────────────┐
│  1 │ x1   │ 2024-05-20 10:50:46 │ (1,'x1','2024-05-20 10:50:46') │
└────┴──────┴─────────────────────┴────────────────────────────────┘

二、GROUP BY子句（结合WITH ROLLUP、CUBE、TOTALS）

ROLLUP：能够按照聚合键从右向左上卷数据，基于聚合函数依次生成分组小计和总计。如果设聚合键的个数为n，则最终会生成小计的个数为n+1
CUBE：像立方体模型一样，基于聚合键之间所有的组合生成小计信息。如果设聚合键的个数为n，则最终小计组合的个数为2的n次方。接下来用示例说明它的用法
TOTALS：会基于聚合函数对所有数据进行总计

# tb_with-创建数据
DROP TABLE IF EXISTS tb_with;
CREATE TABLE tb_with (id UInt8,vist UInt8,province String,city String,area String
)ENGINE = MergeTree()
ORDER BY id;
INSERT INTO tb_with VALUES (1, 12 ,'湖北', '黄冈', '武穴');
INSERT INTO tb_with VALUES (2, 12 ,'湖北', '黄冈', '黄州');
INSERT INTO tb_with VALUES (3, 12 ,'湖北', '黄冈', '麻城');
INSERT INTO tb_with VALUES (4, 32 ,'湖北', '黄冈', '黄梅');
INSERT INTO tb_with VALUES (5, 12 ,'湖北', '黄石', '下陆');
INSERT INTO tb_with VALUES (6, 54 ,'湖北', '黄石', '铁山');
INSERT INTO tb_with VALUES (7, 12 ,'湖北', '黄石', '石灰窑');
INSERT INTO tb_with VALUES (8, 89 ,'湖北', '荆州', '荆门');
INSERT INTO tb_with VALUES (9, 99 ,'湖北', '荆州', '钟祥');# 数据分析
SELECT province,city,area,sum(vist) AS total_visit
FROM tb_with
GROUP BY province, city, area WITH ROLLUP ;┌─province─┬─city─┬─area───┬─total_visit─┐
│ 湖北     │ 黄冈 │ 黄梅   │          32 │
│ 湖北     │ 荆州 │ 钟祥   │          99 │
│ 湖北     │ 黄冈 │ 麻城   │          12 │
│ 湖北     │ 荆州 │ 荆门   │          89 │
│ 湖北     │ 黄冈 │ 黄州   │          12 │
│ 湖北     │ 黄石 │ 下陆   │          12 │
│ 湖北     │ 黄石 │ 石灰窑 │          12 │
│ 湖北     │ 黄石 │ 铁山   │          54 │
│ 湖北     │ 黄冈 │ 武穴   │          12 │
└──────────┴──────┴────────┴─────────────┘
┌─province─┬─city─┬─area─┬─total_visit─┐
│ 湖北     │ 黄石 │      │          78 │
│ 湖北     │ 荆州 │      │         188 │
│ 湖北     │ 黄冈 │      │          68 │
└──────────┴──────┴──────┴─────────────┘
┌─province─┬─city─┬─area─┬─total_visit─┐
│ 湖北     │      │      │         334 │
└──────────┴──────┴──────┴─────────────┘
┌─province─┬─city─┬─area─┬─total_visit─┐
│          │      │      │         334 │
└──────────┴──────┴──────┴─────────────┘

三、FORM语法

SQL是一种面向集合的编程语言，from决定了程序从那里读取数据

表中查询数据
子查询中查询数据
表函数中查询数据 select * from numbers（3）

3.1表函数

构建表的函数，使用场景如下：
SELECT查询的（FROM）子句
创建表 AS 查询

请添加图片描述

3.1.1 file

请添加图片描述

-- 数据文件必须在指定的目录下 /var/lib/clickhouse/user_filesSELECT *
FROM file('demo.csv', 'CSV', 'id Int8,name String, age UInt8')
-- 文件夹下任意的文件
SELECT*
FROM file('*', 'CSV', 'id Int8, name String, age UInt8')

3.1.2 numbers

-- numbers(N) – 返回一个包含单个 ‘number’ 列(UInt64)的表，其中包含从0到N-1的整数。
-- numbers(N, M) - 返回一个包含单个 ‘number’ 列(UInt64)的表，其中包含从N到(N+M-1)的整数。
SELECT *
FROM numbers(10);SELECT *
FROM numbers(2, 10);SELECT *
FROM numbers(2, 10) 
LIMIT 3;SELECT toDate('2020-01-01') + number AS d
FROM 
numbers(365);

3.1.3 mysql

-- CH可以直接从mysql服务中查询数据
mysql('host:port', 'database', 'table', 'user', 'password'[, replace_query, 'on_duplicate_clause']);SELECT*
FROM mysql('linux01:3306', 'db_doit_ch', 'emp', 'root', 'root');

请添加图片描述

3.1.4 hdfs

SELECT *
FROMhdfs('hdfs://hdfs1:9000/test', 'TSV', 'column1 UInt32, column2 UInt32') 
LIMIT 2;SELECT*
FROMhdfs('hdfs://linux01:8020/demo.csv', 'CSV', 'id Int8, name String, age Int8')

请添加图片描述

四、ARRAY JOIN语法（区别于arrayJoin(arr)函数）

ARRAY JOIN子句允许在数据表的内部，与数组或嵌套类型的字段进行JOIN操作，从而将一行数组展开为多行，类似于hive中的explode炸裂函数的功能

# ARRAY JOIN-创建数据
DROP TABLE IF EXISTS tb_array_join;
CREATE TABLE tb_array_join (id Int8,hobby Array(String)
)ENGINE = Log;INSERT INTO tb_array_join VALUES (1, ['eat', 'drink', 'sleep']), (2, ['study', 'sport', 'read']), (2, ['study', 'sport']);# 查询数据
SELECT * FROM tb_array_join;
┌─id─┬─hobby────────────────────┐
│  1 │ ['eat','drink','sleep']  │
│  2 │ ['study','sport','read'] │
│  2 │ ['study','sport']        │
└────┴──────────────────────────┘# 分析1
SELECTid,hobby,hobby_expand
FROMtb_array_join
ARRAY JOIN
hobby AS hobby_expand;
┌─id─┬─hobby────────────────────┬─hobby_expand─┐
│  1 │ ['eat','drink','sleep']  │ eat          │
│  1 │ ['eat','drink','sleep']  │ drink        │
│  1 │ ['eat','drink','sleep']  │ sleep        │
│  2 │ ['study','sport','read'] │ study        │
│  2 │ ['study','sport','read'] │ sport        │
│  2 │ ['study','sport','read'] │ read         │
│  2 │ ['study','sport']        │ study        │
│  2 │ ['study','sport']        │ sport        │
└────┴──────────────────────────┴──────────────┘# 分析2
SELECTid,hobby,arrayEnumerate(hobby) AS indexs
FROMtb_array_join;
┌─id─┬─hobby────────────────────┬─indexs──┐
│  1 │ ['eat','drink','sleep']  │ [1,2,3] │
│  2 │ ['study','sport','read'] │ [1,2,3] │
│  2 │ ['study','sport']        │ [1,2]   │
└────┴──────────────────────────┴─────────┘# 分析3（将hobby展开，并与索引组成一列）
SELECTid,hobby_expand,index
FROMtb_array_join
ARRAY JOIN
hobby AS hobby_expand,
arrayEnumerate(hobby) AS index;┌─id─┬─hobby_expand─┬─index─┐
│  1 │ eat          │     1 │
│  1 │ drink        │     2 │
│  1 │ sleep        │     3 │
│  2 │ study        │     1 │
│  2 │ sport        │     2 │
│  2 │ read         │     3 │
│  2 │ study        │     1 │
│  2 │ sport        │     2 │
└────┴──────────────┴───────┘

五、连续销售案例

需求：对如下样本数据求每个店铺最高连续n天的销售情况

# tb_shop-创建数据
# 思路：
# 1、按照name和cdate排序；
# 2、对name和cdate相同的数据只保留一个，按此业务所以保留每天最大的营销额
# 基于上述需求，所以用ReplacingMergeTree引擎实现
# 3、然后基于下方的分析步骤进行逐步分析
DROP TABLE IF EXISTS tb_shop;
CREATE TABLE tb_shop (name String,cdate Date,cost Float64
)ENGINE = ReplacingMergeTree()
ORDER BY (name, cdate);
INSERT INTO tb_shop VALUES ('a', '2024-02-05', 200),
('a', '2024-02-04', 320),
('a', '2024-02-03', 260),
('a', '2024-01-29', 300),
('a', '2024-01-29', 230),
('a', '2024-01-28', 880),
('a', '2024-01-27', 900),
('a', '2024-01-26', 350),
('a', '2024-01-26', 500),
('a', '2024-01-26', 900),('b', '2024-02-05', 200),
('b', '2024-02-04', 320),
('b', '2024-02-03', 260),
('b', '2024-02-02', 670),('c', '2024-02-05', 200),
('c', '2024-02-05', 900),
('c', '2024-02-05', 800),
('c', '2024-02-05', 200);# 按照以下sql一步步排查
# 分析1
SELECT name,groupArray(cdate) AS arr
FROMtb_shop
GROUP BY name;
┌─name─┬─arr──────────────────────────────────────────────────────────────────────────────────────────┐
│ b    │ ['2024-02-02','2024-02-03','2024-02-04','2024-02-05']                                        │
│ c    │ ['2024-02-05']                                                                               │
│ a    │ ['2024-01-26','2024-01-27','2024-01-28','2024-01-29','2024-02-03','2024-02-04','2024-02-05'] │
└──────┴──────────────────────────────────────────────────────────────────────────────────────────────┘# 分析2
SELECTname,ct,arr_index
FROM(SELECTname,groupArray(cdate) AS arr,arrayEnumerate(arr) AS idxFROMtb_shopGROUP BY name)
ARRAY JOIN
arr AS ct,
idx AS arr_index;
┌─name─┬─────────ct─┬─arr_index─┐
│ b    │ 2024-02-02 │         1 │
│ b    │ 2024-02-03 │         2 │
│ b    │ 2024-02-04 │         3 │
│ b    │ 2024-02-05 │         4 │
│ c    │ 2024-02-05 │         1 │
│ a    │ 2024-01-26 │         1 │
│ a    │ 2024-01-27 │         2 │
│ a    │ 2024-01-28 │         3 │
│ a    │ 2024-01-29 │         4 │
│ a    │ 2024-02-03 │         5 │
│ a    │ 2024-02-04 │         6 │
│ a    │ 2024-02-05 │         7 │
└──────┴────────────┴───────────┘# 分析3
SELECTname,(ct - arr_index) AS diff
FROM(SELECTname,groupArray(cdate) AS arr,arrayEnumerate(arr) AS idxFROMtb_shopGROUP BY name)
ARRAY JOIN
arr AS ct,
idx AS arr_index;
┌─name─┬───────diff─┐
│ b    │ 2024-02-01 │
│ b    │ 2024-02-01 │
│ b    │ 2024-02-01 │
│ b    │ 2024-02-01 │
│ c    │ 2024-02-04 │
│ a    │ 2024-01-25 │
│ a    │ 2024-01-25 │
│ a    │ 2024-01-25 │
│ a    │ 2024-01-25 │
│ a    │ 2024-01-29 │
│ a    │ 2024-01-29 │
│ a    │ 2024-01-29 │
└──────┴────────────┘# 分析4
SELECTname,(ct - arr_index) AS diff,count(1)
FROM(SELECTname,groupArray(cdate) AS arr,arrayEnumerate(arr) AS idxFROMtb_shopGROUP BY name)
ARRAY JOIN
arr AS ct,
idx AS arr_index
GROUP BY name, diff;
┌─name─┬───────diff─┬─count()─┐
│ c    │ 2024-02-04 │       1 │
│ a    │ 2024-01-25 │       4 │
│ b    │ 2024-02-01 │       4 │
│ a    │ 2024-01-29 │       3 │
└──────┴────────────┴─────────┘
# 分析5
SELECTname,(ct - arr_index) AS diff,count(1) AS cc
FROM(SELECTname,groupArray(cdate) AS arr,arrayEnumerate(arr) AS idxFROMtb_shopGROUP BY name)
ARRAY JOIN
arr AS ct,
idx AS arr_index
GROUP BY name, diff
ORDER BY name, cc DESC;
┌─name─┬───────diff─┬─cc─┐
│ a    │ 2024-01-25 │  4 │
│ a    │ 2024-01-29 │  3 │
│ b    │ 2024-02-01 │  4 │
│ c    │ 2024-02-04 │  1 │
└──────┴────────────┴────┘# 分析6
SELECTname,(ct - arr_index) AS diff,count(1) AS cc
FROM(SELECTname,groupArray(cdate) AS arr,arrayEnumerate(arr) AS idxFROMtb_shopGROUP BY name)
ARRAY JOIN
arr AS ct,
idx AS arr_index
GROUP BY name, diff
ORDER BY name, cc DESC
LIMIT 1 BY name;
┌─name─┬───────diff─┬─cc─┐
│ a    │ 2024-01-25 │  4 │
│ b    │ 2024-02-01 │  4 │
│ c    │ 2024-02-04 │  1 │
└──────┴────────────┴────┘

六、连接函数

请添加图片描述

6.1 连接精度

连接精度决定了JOIN查询在连接数据时所使用的策略，目前支持ALL、ANY和ASOF三种类型。如果不主动声明，则默认是ALL。可以通过join_default_strictness配置参数修改默认的连接精度类型。
对数据是否连接匹配的判断是通过JOIN KEY进行的，目前只支持等式（EQUAL JOIN）。交叉连接（CROSS JOIN）不需要使用JOIN KEY，因为它会产生笛卡尔积。

# 准备数据
DROP TABLE IF EXISTS yg;
CREATE TABLE yg(id Int8,name String,age UInt8,bid Int8
)ENGINE = Log;
INSERT INTO yg VALUES(1, 'AA', 23, 1),
(2, 'BB', 24, 3),
(3, 'VV', 27, 1),
(4, 'CC', 13, 3),
(5, 'KK', 53, 3),
(6, 'MM', 33, 3);DROP TABLE IF EXISTS bm;
CREATE TABLE bm(bid Int8,name String
)ENGINE = Log;
INSERT INTO bm VALUES(1, 'x'),(2, 'Y'),(3, 'z');DROP TABLE IF EXISTS gz;
CREATE TABLE gz(id Int8,jb Int64,jj Int64
)ENGINE = Log;
INSERT INTO gz VALUES(1, 1000, 2000),
(1, 1000, 2000),(2, 2000, 1233),(3, 2000, 3000),(4, 4000, 1000);

6.1.1 ALL

如果左表内的一行数据，在右表中有多行数据与之连接匹配，则返回右表中全部连接的数据。而判断连接匹配的依据是左表与右表内的数据，基于连接键（JOIN KEY）的取值完全相等（equals），等同于left.key = right.key

# 分析1
SELECT *
FROMyg
ALL INNER JOIN gz ON yg.id = gz.id;
┌─id─┬─name─┬─age─┬─bid─┬─gz.id─┬───jb─┬───jj─┐
│  1 │ AA   │  23 │   1 │     1 │ 1000 │ 2000 │
│  1 │ AA   │  23 │   1 │     1 │ 1000 │ 2000 │
│  2 │ BB   │  24 │   3 │     2 │ 2000 │ 1233 │
│  3 │ VV   │  27 │   1 │     3 │ 2000 │ 3000 │
│  4 │ CC   │  13 │   3 │     4 │ 4000 │ 1000 │
└────┴──────┴─────┴─────┴───────┴──────┴──────┘

6.1.2 ANY

如果左表内的一行数据，在右表中有多行数据与之连接匹配，则返回右表中第一行连接的数据。ANY与ALL判断连接匹配的依据相同。

# 分析2
SELECT *
FROMyg
ANY INNER JOIN gz ON yg.id = gz.id;
┌─id─┬─name─┬─age─┬─bid─┬─gz.id─┬───jb─┬───jj─┐
│  1 │ AA   │  23 │   1 │     1 │ 1000 │ 2000 │
│  2 │ BB   │  24 │   3 │     2 │ 2000 │ 1233 │
│  3 │ VV   │  27 │   1 │     3 │ 2000 │ 3000 │
│  4 │ CC   │  13 │   3 │     4 │ 4000 │ 1000 │
└────┴──────┴─────┴─────┴───────┴──────┴──────┘

6.1.3 ASOF

ASOF连接键之后追加定义一个模糊连接的匹配条件ASOF_COLUMN。

DROP TABLE IF EXISTS emp1;
CREATE TABLE emp1(id Int8,name String,ctime DateTime
)ENGINE = Log;
INSERT INTO emp1 VALUES(1, 'AA', '2021-01-03 00:00:00'),(1, 'AA', '2021-01-02 00:00:00'),(2, 'CC', '2021-01-01 00:00:00'),(3, 'DD', '2021-01-01 00:00:00'),(4, 'EE', '2021-01-01 00:00:00');DROP TABLE IF EXISTS emp2;
CREATE TABLE emp2(id Int8,name String,ctime DateTime
)ENGINE = Log;
INSERT INTO emp2 VALUES (1, 'aa', '2021-01-02 00:00:00'),(1, 'aa', '2021-01-02 00:00:00'),(2, 'cc', '2021-01-02 00:00:00'),(3, 'dd', '2021-01-02 00:00:00');# 分析
SELECT 
*
FROM emp1
ASOF INNER JOIN emp2
ON (emp1.id = emp2.id) AND (emp1.ctime > emp2.ctime);
┌─id─┬─name─┬───────────────ctime─┬─emp2.id─┬─emp2.name─┬──────────emp2.ctime─┐
│  1 │ AA   │ 2021-01-03 00:00:00 │       1 │ aa        │ 2021-01-02 00:00:00 │
└────┴──────┴─────────────────────┴─────────┴───────────┴─────────────────────┘

七、系统函数介绍

ClickHouse主要提供两类函数-普通函数和聚合函数。普通函数由IFunction接口定义，拥有数十种函数实现，例如FunctionFormationDateTime、FunctionSubstring等。除了一些常见的函数（诸如四则运算、日期转换等之外），也不乏一些非常实用的函数，例如网址提取函数、IP地址脱敏函数等。普通函数是没有状态的，函数效果作用于每行数据之上。当然，在函数具体执行的过程中，并不会一行一行地运算，而是采用向量化的方式直接作用于一整列数据。聚合函数由IAggregateFunction接口定义，相比于无状态的普通函数，聚合函数是有状态的。以COUNT聚合函数为例，其AggregateFunctionCount的状态使用整UInt64记录。聚合函数的状态支持序列化与反序列话，所以能够在分布式节点之间进行传输，以实现增量计算。

普通函数

类型转换函数

日期函数

条件函数

数组函数

字符串函数

json解析函数

高阶函数
聚合函数
表函数

ps：详情见官网

八、JSON解析案例

-- 建表
DROP TABLE IF EXISTS tb_ods_log;
CREATE TABLE tb_ods_log (line String
) ENGINE = Log;INSERT INTO tb_ods_log VALUES('{"account":"14d9TM","deviceId":"Kcjksekjg","ip":"180.12.12.3","sessionId":"sfjkeIGj","eventId":"","properties":{"adId":"6","adCampain":"7"},"timeStamp":18992891918}'),('{"account":"14d9TM","deviceId":"Kcfafafkjg","ip":"180.12.12.3","sessionId":"sfjkeIGj","eventId":"","properties":{"adId":"6","adCampain":"7"},"timeStamp":189923891918}'),('{"account":"14faTM","deviceId":"Kcfaekjg","ip":"180.12.12.3","sessionId":"sfjkeIGj","eventId":"","properties":{"adId":"6","adCampain":"5"},"timeStamp":189924891918}');# json解析
WITH visitParamExtractString(line, 'account') as account,visitParamExtractString(line, 'deviceId') as deviceId,visitParamExtractString(line, 'sessionId') as sessionId,visitParamExtractRaw(line, 'properties') as properties,visitParamExtractInt(line, 'timeStamp') as timeStamp
SELECTaccount,deviceId,sessionId,properties,timeStamp
FROMtb_ods_log 
LIMIT 10;┌─account─┬─deviceId───┬─sessionId─┬─properties───────────────────┬────timeStamp─┐
│ 14d9TM  │ Kcjksekjg  │ sfjkeIGj  │ {"adId":"6","adCampain":"7"} │  18992891918 │
│ 14d9TM  │ Kcfafafkjg │ sfjkeIGj  │ {"adId":"6","adCampain":"7"} │ 189923891918 │
│ 14faTM  │ Kcfaekjg   │ sfjkeIGj  │ {"adId":"6","adCampain":"5"} │ 189924891918 │
└─────────┴────────────┴───────────┴──────────────────────────────┴──────────────┘

九、实用函数

在进行数据分析的时，通常会设计到计算或者类型转换；在进行此处理过程中会出现类型不兼容的情况，而此时就可以通过toTypeName(name)函数来打印某一变量的类型进行排查。

SELECT1 AS b,toTypeName(b)┌─b─┬─toTypeName(1)─┐
│ 1 │ UInt8         │
└───┴───────────────┘

十、语法注意事项

cklickhouse大小写敏感
实现需求的时候可以先查找ck是否有函数可以支持，如果不支持再去想其他方式

课件学习地址

ClickHouse基于数据分析常用函数

文章标题

一、WITH语法-定义变量

1.1 定义变量

1.2 调用函数

1.3 子查询

二、GROUP BY子句（结合WITH ROLLUP、CUBE、TOTALS）

三、FORM语法

3.1表函数

3.1.1 file

3.1.2 numbers

3.1.3 mysql

3.1.4 hdfs

四、ARRAY JOIN语法（区别于arrayJoin(arr)函数）

五、连续销售案例

六、连接函数

6.1 连接精度

6.1.1 ALL

6.1.2 ANY

6.1.3 ASOF

七、系统函数介绍

八、JSON解析案例

九、实用函数

十、语法注意事项

相关文章

当前的脑机交互更像是自动化交互，而不是智能化交互

前端开发者应该知道的TypeScript可区分联合

C#，哥伦布数（Golomb Number）的算法与源代码

Leetcode2855. 使数组成为递增数组的最少右移次数

MATLAB实现随机森林（RF）回归与自变量影响程度分析

算法练习-二叉树的节点个数【完全/普通二叉树】（思路+流程图+代码）

2024年美赛B题潜水器定位和搜救建模代码和完整论文文档

[UI5 常用控件] 05.FlexBox, VBox,HBox,HorizontalLayout,VerticalLayout

说说RDB和AOF

Web实战丨基于django+hitcount的网页计数器

DES加密原理

Linux系统漏洞一键检测与修复工具