Clickhouse第二讲-CK数据类型

Clickhouse支持的数据类型

在 system.data_type_families 表中检查数据类型名称以及是否区分大小

写。这个表中存储了 ClickHouse 支持的所有数据类型。

select * from system.data_type_families limit 10;

┌─name────────────────────────────┬─case_insensitive─┬─alias_to────┐
│ Polygon                         │                0 │             │
│ Ring                            │                0 │             │
│ MultiPolygon                    │                0 │             │
│ IPv6                            │                0 │             │
│ IntervalSecond                  │                0 │             │
│ IPv4                            │                0 │             │
│ UInt32                          │                0 │             │
│ IntervalYear                    │                0 │             │
│ IntervalQuarter                 │                0 │             │
│ IntervalMonth                   │                0 │             │
│ Int64                           │                0 │             │
│ IntervalDay                     │                0 │             │
│ IntervalHour                    │                0 │             │
│ UInt256                         │                0 │             │
│ Int16                           │                0 │             │
│ LowCardinality                  │                0 │             │
│ AggregateFunction               │                0 │             │
│ Nothing                         │                0 │             │
│ Decimal256                      │                1 │             │
│ Tuple                           │                0 │             │
│ Array                           │                0 │             │
│ Enum16                          │                0 │             │
│ IntervalMinute                  │                0 │             │
│ FixedString                     │                0 │             │
 String                          │                0 │             │
│ DateTime                        │                1 │             │
│ UUID                            │                0 │             │
│ Decimal64                       │                1 │             │
│ Nullable                        │                0 │             │
│ Enum                            │                0 │             │
│ Int32                           │                0 │             │
│ UInt8                           │                0 │             │
│ Date                            │                1 │             │
│ Decimal32                       │                1 │             │
│ Point                           │                0 │             │
│ Float64                         │                0 │             │
│ DateTime64                      │                1 │             │
│ Int128                          │                0 │             │
│ Decimal128                      │                1 │             │
│ Int8                            │                0 │             │
│ SimpleAggregateFunction         │                0 │             │
│ Nested                          │                0 │             │
│ Decimal                         │                1 │             │
│ Int256                          │                0 │             │
│ IntervalWeek                    │                0 │             │
│ UInt64                          │                0 │             │
│ Enum8                           │                0 │             │
│ DateTime32                      │                1 │             │
│ UInt16                          │                0 │             │
│ Float32                         │                0 │             │
│ INET6                           │                1 │ IPv6        │
│ INET4                           │                1 │ IPv4        │
│ BINARY                          │                1 │ FixedString │
│ NATIONAL CHAR VARYING           │                1 │ String      │
│ BINARY VARYING                  │                1 │ String      │
│ NCHAR LARGE OBJECT              │                1 │ String      │
│ NATIONAL CHARACTER VARYING      │                1 │ String      │
│ NATIONAL CHARACTER LARGE OBJECT │                1 │ String      │
│ NATIONAL CHARACTER              │                1 │ String      │
│ NATIONAL CHAR                   │                1 │ String      │
│ CHARACTER VARYING               │                1 │ String      │
│ LONGBLOB                        │                1 │ String      │
│ MEDIUMTEXT                      │                1 │ String      │
│ TEXT                            │                1 │ String      │
│ TINYBLOB                        │                1 │ String      │
│ VARCHAR2                        │                1 │ String      │
│ CHARACTER LARGE OBJECT          │                1 │ String      │
│ DOUBLE PRECISION                │                1 │ Float64     │
│ LONGTEXT                        │                1 │ String      │
│ NVARCHAR                        │                1 │ String      │
│ INT1 UNSIGNED                   │                1 │ UInt8       │
│ VARCHAR                         │                1 │ String      │
│ CHAR VARYING                    │                1 │ String      │
│ MEDIUMBLOB                      │                1 │ String      │
│ NCHAR                           │                1 │ String      │
│ CHAR                            │                1 │ String      │
│ SMALLINT UNSIGNED               │                1 │ UInt16      │
│ TIMESTAMP                       │                1 │ DateTime    │
│ FIXED                           │                1 │ Decimal     │
│ TINYTEXT                        │                1 │ String      │
│ NUMERIC                         │                1 │ Decimal     │
│ DEC                             │                1 │ Decimal     │
│ TINYINT UNSIGNED                │                1 │ UInt8       │
│ INTEGER UNSIGNED                │                1 │ UInt32      │
│ INT UNSIGNED                    │                1 │ UInt32      │
│ CLOB                            │                1 │ String      │
│ MEDIUMINT UNSIGNED              │                1 │ UInt32      │
│ BOOL                            │                1 │ Int8        │
│ SMALLINT                        │                1 │ Int16       │
│ INTEGER SIGNED                  │                1 │ Int32       │
│ NCHAR VARYING                   │                1 │ String      │
│ INT SIGNED                      │                1 │ Int32       │
│ TINYINT SIGNED                  │                1 │ Int8        │
│ BIGINT SIGNED                   │                1 │ Int64       │
│ BINARY LARGE OBJECT             │                1 │ String      │
│ SMALLINT SIGNED                 │                1 │ Int16       │
│ MEDIUMINT                       │                1 │ Int32       │
│ INTEGER                         │                1 │ Int32       │
│ INT1 SIGNED                     │                1 │ Int8        │
│ BIGINT UNSIGNED                 │                1 │ UInt64      │
│ BYTEA                           │                1 │ String      │
│ INT                             │                1 │ Int32       │
│ SINGLE                          │                1 │ Float32     │
│ FLOAT                           │                1 │ Float32     │
│ MEDIUMINT SIGNED                │                1 │ Int32       │
│ BOOLEAN                         │                1 │ Int8        │
│ DOUBLE                          │                1 │ Float64     │
│ INT1                            │                1 │ Int8        │
│ CHAR LARGE OBJECT               │                1 │ String      │
│ TINYINT                         │                1 │ Int8        │
│ BIGINT                          │                1 │ Int64       │
│ CHARACTER                       │                1 │ String      │
│ BYTE                            │                1 │ Int8        │
│ BLOB                            │                1 │ String      │
│ REAL                            │                1 │ Float32     │
└─────────────────────────────────┴──────────────────┴─────────────┘

CK数据类型和MySQL及Hive的区别

Int说明

ClickHouse 中整形分为 Int8 、 Int16 、 Int32 、 Int64 来表示整数不同的取值范

围，其末尾数字正好代表占用字节的大小（ 8 位 =1 字节），整形又包含有符号整形和无符

号整形，他们写法上的区别为无符号整形前面加“

U ”表示

 

Float

建议使用整数方式来存储数据，因为浮点类型数据计算可能导致四舍五入的误差。

浮点类型包含单精度浮点数和双精度浮点数。Float32 从小数点后第 8 位起会发生数据溢出。

 Float64 从小数点后第 17 位起会发生数据溢出。

Float之间的类型转换

 toFloat32(...) 用来将字符串转换成 Float32 类型的函数

 toFloat64(...) 用来将字符串转换成 Float64 类型的函数

 

Decimal

有符号的定点数，可在加、减和乘法运算过程中保持精度。 ClickHouse 提供了

Decimal32 、 Decimal64 、 Decimal128 、 Decimal256 几种精度的定点数，支持几种写

法：

 Decimal(P,S)

 Decimal32(S), 数据范围： (-1*10^(9-S),1*10^(9-S))

 Decimal64(S), 数据范围： (-1*10^(18-S),1*10^(18-S))

 Decimal128(S), 数据范围： (-1*10^(38-S),1*10^(38-S))

 Decimal256(S), 数据范围： (-1*10^(76-S),1*10^(76-S))

其中， P 代表精度，决定总位数（整数部分 + 小数部分），取值范围是 1~76 。 S 代表规

模，决定小数位数，取值范围是 0~P 。

根据 P 值的范围可以有如下对等写法，这里以小数点后 2 位举例：

另外， Decimal 数据在进行四则运算时，精度（总位数）和规模（小数点位数）会发

生变化，具体规则如下：

 精度（总位数）对应规则：

 Decimal64(S1) 运算符 Decimal32(S2) -> Decimal64(S)

 Decimal128(S1) 运算符 Decimal32(S2) -> Decimal128(S ）

 Decimal128(S1) 运算符 Decimal64(S2) -> Decimal128(S)

 Decimal256(S1) 运算符 Decimal<32|64|128>(S2) -> Decimal256(S)

两个不同精度的数据进行四则运算时，结果数据的精度以最大精度为准。

 规模（小数点位数）对应规则：

 加法 | 减法： S=max(S1,S2) ，即以两个数据中小数点位数最多的为准。

 乘法： S=S1+S2( 注意： S1 精度 >=S2 精度 ) ，即以两个数据的小数位相加为准。

 除法：规模以被除数的小数位为准。两数相除， 被除数的小数位数不能小于除数的

小数位数 ， 也就是触发的规模可以理解为与两个数据中小数点位数大的为准。举例：

a/b ， a 是被除数，与 a 的规模保持一致

例子：

 toDecimal32(value,S): 将字符串 value 转换为 Decimal32 类型 , 小数点后

有 S 位。

 toTypeName( 字段 ) ：获取字段的数据类型函数。

# 测试加法 ,S 取两者最大的， P 取两者最大的

select  toDecimal64(2,3) as x, toTypeName(x) as xtype, toDecimal32(2,2) as y, toTypeName(y) as ytype, x+y as z, toTypeName(z) as ztype;

# 测试减法， S 取两者最大的， P 取两者最大的。

select  toDecimal64(2,3) as x, toTypeName(x) as xtype, toDecimal32(2,2) as y, toTypeName(y) as ytype, x-y as z, toTypeName(z) as ztype;

 #测试乘法，S 取两者最大的，P 取两者小数位之和

 select  toDecimal64(2,3) as x, toTypeName(x) as xtype, toDecimal32(2,2) as y,toTypeName(y) as ytype, x*y as z, toTypeName(z) as ztype;

 #测试除法，S 取两者最大的，P 取被除数的小数位数。

  select  toDecimal64(2,3) as x, toTypeName(x) as xtype, toDecimal32(2,2) as y,toTypeName(y) as ytype, x/y as z, toTypeName(z) as ztype;

 

 

 String

字符串可以是任意长度的。它可以包含任意的字节集，包含空字节。因此，字符串类型

可以代替其他 DBMSs 中的 VARCHAR 、 BLOB 、 CLOB 等类型。

FixedString

固定长度 N 的字符串（ N 必须是严格的正自然数） , 一般在明确字符串长度的场景下使

用，可以使用下面的语法对列声明为 FixedString 类型：

# N 表示字符串的长度。

FixedString(N)

当向 ClickHouse 中插入数据时 , 如果字符串包含的字节数少于 N , 将对字符串末尾

进行空字节填充。如果字符串包含的字节数大于 N, 将抛出 Too large value for

FixedString(N) 异常。

当做数据查询时， ClickHouse 不会删除字符串末尾的空字节。 如果使用 WHERE 子

句，则须要手动添加空字节以匹配 FixedString 的值，新版本后期不需要手动添加。

toFixedString(value,N) ：将字符串转换为 N 位长度， N 不能小于 value 字

符串实际长度

#查看字符号串长度

select toFixedString('hello',6) as a,length(a) as alength

 

 UUID

UUID 是一种数据库常见的主键类型，在 ClickHouse 中直接把它作为一种数据类型。

UUID 共有 32 位，它的格式为 8-4-4-4-12 ，如果在插入新记录时未指定 UUID 列值，则

UUID 值将用 0 来填充（ 00000000-0000-0000-0000-000000000000 ）。

UUID 类型不支持算术运算、聚合函数 sum 和 avg 。

 示例：

 generateUUIDv4() 随机生成一个 32 位的 UUID

# 创建表 t_uuid, 指定 x 列为 UUID 类型，表引擎为 TinyLog

node1 :) CREATE TABLE t_uuid (x UUID, y String) ENGINE=TinyLog

# 向表 t_uuid 中插入一条数据

node1 :) INSERT INTO t_uuid SELECT generateUUIDv4(), 'Example 1'

# 向表 t_uuid 中插入一条数据，这里不指定 UUID 的值，默认会生成 0 来填充

node1 :) INSERT INTO t_uuid (y) VALUES ('Example 2')

node1 :) select * from t_uuid;

Date

Date 只能精确到天，用两个字节存储，表示从 1970-01-01 （无符号）到当前的日期

值。日期中没有存储时区信息，不能指定时区。

now() : 获取当前天日期，返回格式： yyyy-MM-dd HH:mm:ss

 toDate(value) : 将字符串转成 Date ，只支持 yyyy-MM-dd 格式

例子：

node1 :) CREATE TABLE t_date (x date) ENGINE=TinyLog;

node1 :) INSERT INTO t_date VALUES('2021-06-01'),('2021-07-01')

node1 :) SELECT x,toTypeName(x) FROM t_date;

# 获取当前天日期时间及日期转换

node1 :) select now(),toDate(now()) as d,toTypeName(d)

DateTime

DateTime 精确到秒，可以指定时区。用四个字节（无符号的）存储 Unix 时间戳。允

许存储与日期类型相同的范围内的值。最小值为 0000-00-00 00:00:00 ，时间戳类型值

精确到秒。

时区使用启动客户端或服务器时的系统时区。默认情况下，客户端连接到服务的时候会

使用服务端时区。您可以通过启用客户端命令行选项 --use_client_time_zone 来设

置使用客户端时区

 toDateTime(DateTimeValue) ： 将 字 符 串 转 成 DateTime ， 只 支 持 yyyy-MM-dd HH:MI:SS 。

 toDateTime(DateTimeValue, 时区 ) ：同上，支持将数据转换为对应时区时 间。

node1 :) CREATE TABLE t_datetime(`timestamp` DateTime) ENGINE = TinyLog;

# 向表中插入一条数据

node1 :) INSERT INTO t_datetime Values('2021-06-01 08:00:00');

node1 :) SELECT timestamp,toTypeName(timestamp) as t FROM t_datetime

# 转换时区查询

node1 :) SELECT toDateTime(timestamp, 'Asia/Shanghai') AS column, toTypeName(column) AS x FROM t_datetime;

DateTime64

DateTime64 精确到毫秒和微秒，可以指定时区。在内部，此类型以 Int64 类型将数

据存储。时间刻度的分辨率由 precision 参数确定。此外， DateTime64 类型可以像存

储其他数据列一样存储时区信息，时区会影响 DateTime64 类型的值如何以文本格式显

示，以及如何解析以字符串形式指定的时间数据 ( ‘

2020-01-01 05:00:01.000 ’ ) 。

时区信息不存储在表的行中，而是存储在列的元数据中

# precision 精度， timezone ：时区

DateTime64(precision, [timezone])

 toDateTime64(timeStr,precision): 将字符串转成 DateTime64 ，精度为

precision 。支持 yyyy-MM-dd HH:MI:SS.SSS 时间格式。

 toDateTime64(timeStr,precision ，

timezone):同上，只是可以将时间转 换为对应时区时间。

node1 :) CREATE  TABLE  dt(`timestamp`  DateTime64(3, 'Europe/Moscow'),`event_id` UInt8) ENGINE = TinyLog

# 插入数据

node1 :) INSERT INTO dt Values (1546300800000, 1), ('2019-01-01

00:00:00', 2) ， (1546300812345, 3)

# 查询数据

node1 :) select * from dt;

# 使用 toDateTime64 转换时间

node1

:)

select   toDateTime64(timestamp,4)  as

t1,toDateTime64(timestamp,4,'Europe/London') as t2,event_id from dt;

布尔类型

ClickHouse 中没有单独的类型来存储布尔值。可以使用 UInt8 类型，取值限制为 0

或 1

枚举类型

枚举类型通常在定义常量时使用，ClickHouse 提供了 Enum8 和 Enum16 两种枚举类 型。Enum 保存 'string'=integer 的对应关系。在 ClickHouse 中，尽管用户使用的 是字符串常量，但所有含有 Enum 数据类型的操作都是按照包含整数的值来执行。这在性 能方面比使用 String 数据类型更有效。

Enum8 和 Enum16 分别对应 'String'=Int8 和 'String'=Int16，Enum8 类型的每 个值范围是 -128 ... 127 ， Enum16 类型的每个值范围是-32768 ... 32767，所有的 字符串或者数字都必须是不一样的，允许存在空字符串，Enum 类型中数字可以是任意顺序，顺序并不重要。向 Enum 字段中插入值时，可以插入枚举的字符串值也可以插入枚举对应的 Int 值，建议插入对应的字符串值，这样避免插入对应的 Int 值不在 Enum 枚举集合中再次查询表时报错。定义了枚举类型值之后，不能写入其他值的数据，写入的值不在枚举集合中就会抛出异常。

# 创建一个表，带有 Enum 类型的列

CREATE TABLE t_enum(x Enum8('hello' = 1, 'world' = 2)) ENGINE = TinyLog

node1 :) insert into t_enum values('hello'),(2);

node1 :) select * from t_enum;

# 插入不在枚举集合中的值时，抛出异常

node1 :) insert into t_enum values ('aa')

# 使用枚举类型代替 boolean 类型。建表，并插入数据

node1 :) CREATE TABLE t_enum2(bl Enum8('true' = 1, 'false' = 0)) ENGINE = TinyLog;

node1 :) insert into t_enum2 values(0),(1);

node1 :) select * from t_enum2;

#插入不在枚举集合中的值时，抛出异常

node1 :) insert into t_enum values ('aa')

# 使用枚举类型代替 boolean 类型。建表，并插入数据

node1 :) CREATE TABLE t_enum2(bl Enum8('true' = 1, 'false' = 0)) ENGINE

= TinyLog;

node1 :) insert into t_enum2 values(0),(1);

node1 :) select * from t_enum2;

# 查询时可以通过函数将对应的 Enum 底层数值获取出来

node1 :) select toInt8(bl) from t_enum2;

Nullable

Nullable 类 型 只 能 与 基 础 数 据 类 型 搭 配 使 用 ， 表 示 某 个 类 型 的 值 可 以 为

NULL,Nullable(Int8) 表示可以存储 Int8 类型的值，没有值时存 NULL 。使用Nullable 需要注意： Nullable 类型的字段不能作为索引字段，尽量避免使用 Nullable 类型，因为字段被定义为 Nullable 类型后会额外生成 [Column].null.bin 文件保存 Null 值，增加开销，比普通列消耗更多的存储空间。

#创建表，含有 Nullable 类型的列

node1 :) CREATE TABLE t_null(x Int8, y Nullable(Int8)) ENGINE TinyLog;

#向表 t_null 中插入数据

node1 :) INSERT INTO t_null VALUES (1, NULL), (2, 3);

# 查询表 t_null 中的数据

node1 :) select * from t_null;

 #查询表 t_null 做简单运算

node1 :) SELECT x + y FROM t_null;

数组类型-Array(T)

Array(T) ，由 T 类型元素组成的数组。 T 可以是任意类型，包含数组类型。但不推 荐使用多维数组， ClickHouse 对多维数组的支持有限。例如，不能在 MergeTree 表中存储多维数组。

数组的定义方式有两种： Array(T),[1,2,3... ...],数组类型里面的元素必须具 有相同的数据类型，否则会报异常。另外，需要注意的是，数组元素中如果存在 Null 值， 则元素类型将变为 Nullable 。

从数组中查询获取值使用 xx[1|2.. ...] ，直接使用中括号获取值，下标从 1 开始。

# 两种方式定义数组

node1 :) SELECT array(1, 2) AS x, toTypeName(x),['zs','ls','ww'] as  y ,toTypeName(y)

# 数组中有 Null ，则数组类型为 Nullable

 #数组类型里面的元素必须具有相同的数据类型，否则会报异常

# 创建表，含有 array(T) 类型字段，并插入数据

DC-pre-clickhost-01 :) create table t_array(id UInt32,name String,score Array(UInt32))ENGINE=TinyLog;

DC-pre-clickhost-01 :) insert into t_array values(1,'zs',array(10,20,30)),(2,'ls',[100,200,300]);

 DC-pre-clickhost-01 :) select id,name,score[1] from t_array;

 Tuple类型

元组类型有 1~n 个元素组成，每个元素允许设置不同的数据类型，且彼此之间不要求

兼容。与数组类似，元组也可以使用两种方式定义： tuple(1,'hello',12.34) 或者直

接写 (1,'hello',45.67), 元组中可以存储多种数据类型，但是要注意数据类型的顺序。

DC-pre-clickhost-01 :) select tuple(1,'a') AS x,toTypeName(x),(1,'b','hello') as y ,toTypeName(y);

 DC-pre-clickhost-01 :) create table t_tuple(id UInt8,name String,Info Tuple(String,UInt8)) engine=TinyLog

DC-pre-clickhost-01 :) create table t_tuple(id UInt8,name String,Info Tuple(String,UInt8)) engine=TinyLog

 嵌套类型

ClickHouse 支持嵌套数据类型（ Nested ）,可以为一个表定义一个或者多个嵌套数 据类型字段，但是每个嵌套字段只支持一级嵌套，即嵌套字段内不能继续使用嵌套类型。嵌 套一般用来表示简单的级联关系，嵌套本质上是一个多维数组，嵌套类型中的每个数组的长度必须相同。目前 Nested 类型支持很局限， MergeTree 引擎中不支持 Nested 类型

# 创建一个表，每个人可以属于多个部门，在不同部门有不同的编号 id

DC-pre-clickhost-01 :) create table t_nested(id UInt8,name String,dept Nested(id UInt8,name String)) engine = TinyLog;

DC-pre-clickhost-01 :) insert into t_nested values(1,'zs',[10,11,12],['dp1','dp2','dp3']),(2,'ls',[100,101],['dp4','dp5'])

DC-pre-clickhost-01 :) insert into t_nested values(1,'zs',[10,11,12],['dp1','dp2','dp3']),(2,'ls',[100,101],['dp4','dp5'])

 Domain

Domain 类型是特定实现的类型，目前支持 IPv4 和 IPv6 两类，本质上他们是对整形 和字符串的进一步封装， IPv4 类型基于 UInt32 封装， IPv6 基于 FixedString(16)封 装。出于便捷性的考量，例如： IPv4 类型支持格式检查，格式错误的 IP 无法被写入。出 于性能的考量， IPv4 和 IPv6 相对于 String 更加紧凑，占用的空间更小，查询性能更快。 在使用 Domain 时需要注意，虽然表面看起来与 String 一样，但是 Domain 类型并 不是字符串，也不支持隐式自动转换成字符串，如果需要返回 IP 的字符串形式，需要调用 函数 IPv4NumToString() 和 IPv6NumToString() 显式实现。

# 创建表 t_domain 含有 IPv4 字段

node1 :) CREATE TABLE t_domain(url String, from IPv4) ENGINE = TinyLog;

DC-pre-clickhost-01 :) insert into t_domain(url,from) values('http://www.baidu.com','100.100.0.1'),('http://www.google.com','100.10.1')

# 插入数据不符合 IP 格式会报错

node1 :) INSERT INTO t_domain(url, from) VALUES ('https://www.baidu.com', '116.253.40')

# 将表 t_domain 中 from IPv4 类型转换成 String 类型

node1 :) SELECT from,toTypeName(from) as tp1,toTypeName(s) as tp2,

IPv4NumToString(from) as s FROM t_domain;