ClickHouse基于数据分析常用函数

背景：基于初次接触数据分析，对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决定了程序从那里读取数据

1. 表中查询数据
2. 子查询中查询数据
3. 表函数中查询数据 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是否有函数可以支持，如果不支持再去想其他方式

课件学习地址