个人可以建设哪些网站,广州建设培训网站,长春网站建设公司十佳,东莞核酸检测时间文章标题 一、WITH语法-定义变量1.1 定义变量1.2 调用函数1.3 子查询 二、GROUP BY子句#xff08;结合WITH ROLLUP、CUBE、TOTALS#xff09;三、FORM语法3.1表函数3.1.1 file3.1.2 numbers3.1.3 mysql3.1.4 hdfs 四、ARRAY JOIN语法#xff08;区别于arrayJoin(arr)函数结合WITH ROLLUP、CUBE、TOTALS三、FORM语法3.1表函数3.1.1 file3.1.2 numbers3.1.3 mysql3.1.4 hdfs 四、ARRAY JOIN语法区别于arrayJoin(arr)函数五、连续销售案例六、连接函数6.1 连接精度6.1.1 ALL6.1.2 ANY6.1.3 ASOF 七、系统函数介绍八、JSON解析案例九、实用函数十、语法注意事项 背景基于初次接触数据分析对ck函数的不熟悉此文章主要基于ck特有的sql语法来做讲解 官网https://clickhouse.tech/docs/zh 一、WITH语法-定义变量 ClickHouse支持CTECommon 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则最终 会生成小计的个数为n1CUBE像立方体模型一样基于聚合键之间所有的 组合生成小计信息。如果设聚合键的个数为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 numbers3 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到(NM-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是否有函数可以支持如果不支持再去想其他方式
课件学习地址
