目录

1导言

2外部存储类型

2.1外部存储引擎着重理解“外部”一词

2.2 HDFS

2.3 MySQL

2.4 JDBC

2.5卡夫卡

2.6文件

3记忆类型

3.1对记忆类型的理解

3.2内存

3.3设置

3.4加入

3.5缓冲器

4日志类型

4.1了解日志类型。

4.2 TinyLog

4.3条纹日志

4.4日志

5接口类型

5.1合并

5.2字典

6其他类型

6.1实时视图

6.2空

6.3网址

7参考

1导言

虽然clickhouse最重要的表格引擎是MergTree系列引擎，但是有必要了解一下其他类型的表格引擎，它们也会在具体的场景中发挥作用，这有助于我们从更全面的角度去理解clickhouse。

外存系列1个表引擎，可以直接读取其他系统的数据。ClickHouse本身只负责元数据管理，类似于外部表的形式；

2内存系列表引擎，可以作为数据分发的临时存储载体或消息通道；

日志文件系列的表格引擎，简单易用；

4接口串联表引擎，可以串联现有数据表，起到粘合剂的作用。

2外部存储类型

2.1外部存储引擎着重理解“外部”一词

1外部相对于内部clickhouse。使用外部表引擎数据不由clickhouse管理，但它直接读取HDFS文件或MySQL数据库表。这样想方便吗？

那么，clickhouse管理什么呢？它负责元数据管理和数据查询。如果数据写入或直接写入外部系统，如外部HDFS或MySQL表，clickhouse可以在此找到最新插入的数据。

2.2 HDFS

点击之家有HDFS表引擎与HDFS接口。

clickhouse HDFS表引擎的定义方法

引擎= HDFS(hdfs_uri，格式)

1 hdfs_uri表示hdfs的文件存储路径。

2格式是指文件格式(指ClickHouse支持的文件格式，如CSV、TSV、JSON等)。

施用方式

创建表格

创建表hdfs_table1(

id UInt32，

代码字符串，

名称字符串

)引擎= HDFS(& # 39；HDFS://HDP 1 . nauu . com:8020/click house/HDFS _ table 1 & # 39；, 'CSV & # 39)

读入数据

插入hdfs_table1

选择数字，串联(& # 39；代码& # 39；，toString(数字))

，concat(& # 39；n & # 39，toString(数字))

从数字(5)

查询数据

SELECT * FROM hdfs_table1

Hdfs查询

Hadoop fs-cat/click house/HDFS _ table 1

2.3 MySQL

理解语法。

ENGINE = MySQL(& # 39；主机:端口& # 39；, '数据库& # 39；, '表& # 39；, '用户& # 39；, '密码& # 39；[，replace_query，& # 39；on _ duplicate _ clause & # 39])

1: port表示MySQL的地址和端口。

2 database表示数据库的名称。

3 table表示要映射的表的名称。

4 user表示MySQL的用户名。

密码是指MySQL的密码。

6 replace_query默认为0，对应MySQL的REPLACE INTO语法。如果设置为1，INSERT INTO将被REPLACE INTO替换。

On _ duplicate _ clause默认为0，对应MySQL的ON DUPLICATE KEY语法。如果需要使用此设置，必须将replace_query设置为0。

比较简单。练出来就行了。

创建表dolphin_scheduler_table(

id UInt32，

名称字符串

)ENGINE = MySQL(& # 39；10.37.129.2:3306', 'escheduler & # 39, 't _ escheduler _ process _ definition & # 39；, '根& # 39；, '')

2.4 JDBC

提问。

Clickhouse有一个mysql表引擎，可以直接创建表与MySQL数据库接口。它能直接与其他数据库接口吗，比如PostgreSQL、SQLite和H2？答案是没有直接接口的表引擎，但是可以通过JDBC访问它们。

对JDBC的依赖

您需要依赖clickhouse-jdbc-bridge作为查询代理服务。

地址:https://github.com/ClickHouse/clickhouse-jdbc-bridge

了解数据类型。

你需要知道点击之家和JDBC数据类型之间的对应关系。

如何使用

启动代理服务clickhouse-jdbc-bridge

1包click house-JDBC-布里奇-1.0.jar

2.开始:Java-jar。/click house-JDBC-布里奇-1.0 . jar-driver-path/ch base/JDBC-布里奇-监听-主持人ch5.nauu.com

1) 1) - driver-path用于指定放置数据库驱动程序的目录。例如，如果您想通过代理查询PostgreSQL数据库，您需要将其驱动程序jar放在这个目录中。

2) 2) - listen-host用作代理服务的监听端口。通过这个地址访问代理服务，ClickHouse的jdbc_bridge配置项对应这个参数。

配置代理服务访问地址

配置config.xml

& ltjdbc _ bridge & gt

& lt主机& gtch5 . nauu . com & lt；/host & gt；

& lt端口& gt9019 & lt/port & gt；

& lt/JDBC _ bridge & gt；

创建JDBC表

创建表t_ds_process_definition(

id Int32，

名称字符串)

引擎= JDBC(& # 39；JDBC:PostgreSQL://IP:5432/dolphin scheduler？用户=测试& amp密码=测试，& # 39；', 't _ ds _ process _ definition & # 39)

数据返回到JDBC表引擎

SELECT id，name FROM t _ ds _ process _ definition

2.5卡夫卡

想

与卡夫卡对接，就是把clickhouse当成卡夫卡的消费者，也就是从卡夫卡的角度来看，clickhouse的卡夫卡引擎就是消费者的角色。我想到几个问题和你讨论。

1 clickhouse可以直接从kafka读取数据，然后存入仓库，那么是如何实现的呢？解决问题要靠源码。

2仅从功能实现来看，clickhouse实现了消费入库，但功能略显单薄。为什么这么说？因为kafka的原始数据可能没有计算过，但是有时候我们希望计算消耗的数据，比如使用的内存量。卡夫卡消耗的数据大概就是内存总量，内存剩余量，如果没有内存使用量，直接入库就没有内存使用量。要解决这个问题，可以从卡夫卡这边考虑，需要消耗的topic的部分key已经计算好了，可以直接使用clickhouse。

Kafka表引擎定义

kafka表格引擎有很多定义和参数描述，选择了表格引擎的必要内容。可选参数请参考官方文档(https://clickhouse . tech/docs/en/engines/table-engines/integrations/Kafka/)或click house原理分析及应用实践。

ENGINE = Kafka()设置

kafka _ broker _ list = & # 39主机:端口，...',

卡夫卡_ topic _ list = & # 39主题1、主题2、...',

kafka _ group _ name = & # 39group _ name & # 39,

kafka _ format = & # 39数据格式& # 39；[,]

发动机底层

了解表引擎的底层。

1底层负责与Kafka通信，基于librdkafka，地址为https://github.com/edenhill/librdkafka.

Clickhouse对librdkafka的自定义参数提供了很好的扩展支持，提供了一组kafka标签，专门用来定义librdkafka的自定义参数。

实践

创建主题

。/Kafka-topics . sh-create-zookeeper hdp1.nauu.com:2181-replication-factor 1-partitions 1-topic sales-queue created topic & # 34；销售队列& # 34；

发送测试消息

。/Kafka-console-producer . sh-broker-list hdp1.nauu.com:6667-话题销售-队列{ & # 34；id & # 34:1,"代码& # 34；:"代码1 & # 34；,"姓名& # 34；:"名称1 & # 34；}

{"id & # 34:2,"代码& # 34；:"代码2 & # 34；,"姓名& # 34；:"name2 & # 34}

{"id & # 34:3,"代码& # 34；:"代码3 & # 34；,"姓名& # 34；:"姓名3 & # 34；}

验证消息成功。

。/Kafka-console-consumer . sh-bootstrap-server hdp1.nauu.com:6667-主题销售-队列-从头开始

{"id & # 34:1,"代码& # 34；:"代码1 & # 34；,"姓名& # 34；:"名称1 & # 34；}

{"id & # 34:2,"代码& # 34；:"代码2 & # 34；,"姓名& # 34；:"name2 & # 34}

{"id & # 34:3,"代码& # 34；:"代码3 & # 34；,"姓名& # 34；:"姓名3 & # 34；}

创建新的kafka引擎表

创建表kafka_test(

id UInt32，

代码字符串，

名称字符串)

ENGINE = Kafka()设置

kafka _ broker _ list = & # 39HDP 1 . nauu . com:6667 & # 39；,

卡夫卡_ topic _ list = & # 39销售队列& # 39；,

kafka _ group _ name = & # 39chgroup & # 39,

kafka _ format = & # 39JSONEachRow & # 39,

kafka_skip_broken_messages = 100

轮询列表

select * from kafka_test

正确使用

理解拓扑图。

首先是Kafka数据表A，作为数据管道，负责拉取Kafka中的数据。然后还有一个任意引擎的数据表B，作为终端用户的查询表，通常是生产环境下的MergeTree系列。最后是物化视图C，负责将表A的数据实时同步到表B。

创建新的Kafka引擎表

创建表kafka_queue(

id UInt32，

代码字符串，

名称字符串)

ENGINE = Kafka()设置

kafka _ broker _ list = & # 39HDP 1 . nauu . com:6667 & # 39；,

卡夫卡_ topic _ list = & # 39销售队列& # 39；,

kafka _ group _ name = & # 39chgroup & # 39,

kafka _ format = & # 39JSONEachRow & # 39,

kafka_skip_broken_messages = 100

面向最终用户的查询表

创建表kafka_table(

id UInt32，

代码字符串，

名称字符串)

ENGINE = MergeTree()

按id排序

新物化视图

从kafka_queue中选择id，代码，名称，将实体化视图使用者创建到kafka _ tableAS

查询数据

SELECT * FROM kafka_table

2.6文件

文件表引擎的定位

通常用作扩张的手段。

声明

引擎=文件(格式)

格式1的数据格式需要是clickhouse支持的数据格式，比如TSV、CSV、JSONEachRow。

参数2不包含文件路径，文件表引擎的数据文件只能保存在config.xml配置中path指定的路径下。

3目录以表名命名，例如/data/default/test _ file _ table/data战斗支援车

例子

创建表格file_table(

名称字符串，

值UInt32)

引擎=文件(& # 34；CSV & # 34)

3记忆类型

3.1对记忆类型的理解

1内存类型表也支持物理存储。

2加载数据时，所有数据都会加载到内存中，有利有弊。优点是可以提高查询性能。缺点是加载到内存中的数据量过大时，会吃掉大量内存，造成严重损失，增加负担。

3.2内存

意义

1直接将数据存储在内存中，数据既不会被压缩，也不会进行格式转换。

2服务重新启动，所有数据都将丢失。

3性能好。

事件

1用于测试。

2利用内存临时表保存IN子句的查询结果

定义

创建表Memory _ 1(id uint 64)ENGINE = Memory()

3.3设置

明白几点

1对于物理存储，数据将首先写入内存，然后同步到磁盘文件。

2当服务重新启动时，全部数据将再次加载到内存中。

3重量可以去掉。

4不能直接选择查询，但需要作为in查询的右条件。

存储结构

1 )num]。bin数据文件:保存所有列和字段的数据。其中num是自增id，从1开始。随着每批数据的写入(每次插入)，一个新的。将生成bin文件，并且num将增加1。2 )tmp临时目录:数据文件会先写到这个目录，写完一批数据后会移出这个目录。

定义

创建表set_1 (id UInt8)ENGINE = Set()

使用

#插入数据

INSERT INTO TABLE set_1从数字中选择数字(10)

#查询数据

SELECT arrayJoin([1，2，3])作为a，其中a在set_1中

3.4加入

明白几点

1为join查询而生(心想:这么大口气，看怎么用JOIN连接)

2可以用作连接查询的连接表

定义

ENGINE = Join(join_strictness，join_type，key1[，key2，...])

1 JOIN_strictness:连接精度，决定了连接查询在连接数据时使用的策略。目前，它支持所有，任何和ASOF类型。

2 join_type:连接类型，支持内、外、跨三种类型。

例子

创建主表

创建表join_tb1(id UInt8，名称字符串，时间日期时间)ENGINE = Log

插入到表join_tb1值(1，& # 39；点击之家& # 39；,'2019-05-01 12:00:00'),(2,'火花& # 39；, '2019-05-01 12:30:00'),(3,'ElasticSearch & # 39,'2019-05-01 13:00:00')

创建连接表

创建表id_join_tb1(

id UInt8，

价格32元，

时间日期时间)

引擎=连接(任意，左侧，id)

将id_join_tb1值(1，100，& # 39；2019-05-01 11:55:00'),(1,105,'2019-05-01 11:10:00'),(2,90,'2019-05-01 12:01:00'),(3,80,'2019-05-01 13:10:00'),(5,70,'2019-05-01 14:00:00'),(6,60,'2019-05-01 13:50:00')

询问

SELECT * FROM id_join_tb1

#联接查询

SELECT id，name，price FROM JOIN _ tb1 LEFT JOIN id _ JOIN _ tb1使用(id)

# join函数

选择join get(& # 39；id _ join _ tb1 & # 39, '价格& # 39；，toUInt8(1))

3.5缓冲器

事件

合并表a，因为并发写次数多，合并速度比写速度慢(思考:kafka消费者写合并表一定比写速度快，你可以观察一下。需要缓冲表引擎吗？)可以引入缓冲表来缓解这类问题，先写缓冲表，当满足预设条件时，缓冲表会自动刷新数据到目标表。

示意图

?

定义

引擎=缓冲区(数据库，表，层数，最小时间，最大时间，最小行数，最大行数，最小字节数，最大字节数)

1:目标表的数据库。

Table:目标表的名称，缓冲表中的数据会自动刷新到目标表中。

3 num_layers:可以理解为线程数。缓冲表会根据num_layers的数量打开线程，并行刷新数据到目标表。官方推荐设置为16。

4个阈值条件

min_time和max_time:时间条件的最小值和最大值，以秒为单位，从数据第一次写入表中开始计算；

min_rows和max_rows:数据行条件的最小值和最大值；

Min _ bytes和max_bytes:数据量条件的最小值和最大值，以字节为单位。

根据以上条件，刷新缓冲表有三个判断依据。如果满足其中任何一个，缓冲表将刷新数据。它们是:

如果满足三组条件中的所有最小阈值，则触发刷新动作；

如果三组条件中的至少一组满足最大阈值条件，则触发刷新动作；

如果写入的批量数据的数据行大于max_rows，或者数据量大于max_bytes，则直接将数据写入目标表。

例子

创建表格

将表buffer_to_memory_1创建为memory_1 ENGINE = Buffer(缺省值，memory_1，16，10，100，10000，1000000，1000000，10000000)

插入数据

插入表buffer_to_memory_1从数字中选择数字(1000000)

查询结果

buffer_to_memory1有数据，而目标表memory1没有，因为目前无论从时间、数据行还是数据大小，都没有达到最大阈值。因此，数据从buffer_to_memory1刷新到memory1大约需要100秒。

再次插入数据。

#插入一百万行数据

插入表buffer_to_memory_1从数字中选择数字(1000001)

查询结果

#目标表立即有数据

从memory_1中选择COUNT(*)

4日志类型

4.1了解日志类型。

我们来看看日志型的表引擎，简单使用一下。

1适用于数据量小(100万以下)且查询场景简单的场景。

不支持索引和分区，这很好理解。数据量不大，全表扫描也很快。

3不支持并发读写，数据写入时读被阻塞。

4.2 TinyLog

定义和使用

创建表tinylog_1 (id UInt64，代码UInt64)ENGINE = TinyLog()

插入表格spripelog_1从数字(1000)中选择数字，数字+100

4.3条纹日志

存储结构

1.数据文件。所有列字段都保存在同一个文件中，它们的数据将被写入data.bin。

2.index.mrk:数据标记，保存data.bin文件中数据的位置信息。使用data marker可以使用多线程并行读取data.bin中的压缩数据块，从而提高数据查询的性能。

3 sizes.json:元数据文件，记录data.bin和index.mrk的大小信息

与TinyLog相比，StripeLog具有更高的查询性能(它已经。mrk标签文件并支持并行查询)(思考:是否可以理解为是否支持并行查询是由。mrk标签文件)

例子

创建表spripelog_1(

id UInt64，

价格浮动32)

ENGINE = StripeLog()

插入表格spripelog_1从数字(1000)中选择数字，数字+100

4.4日志

存储结构

日志引擎结合了TinyLog表引擎和StripeLog表引擎的优点，是日志家族中性能最高的表引擎。日志引擎的存储结构由三部分组成:

1[列]。bin:数据文件。数据文件按列独立存储，每个列字段都有相应的。bin文件。

2 __marks.mrk:数据标记，保存每个[列]中数据的位置信息。bin文件。使用数据标记可以使用多个线程来读取压缩的数据块。bin，从而提高数据查询的性能。

3 sizes.json:元数据文件，记录[column]的大小信息。bin和__marks.mrk

例子

创建表log_1(

id UInt64，

代码UInt64)

引擎=日志()

插入到表log_1中从numbers(200)中选择number，number+1

5接口类型

5.1合并

事件

数据按年份存储在表中，如test_table2018、test_table2019、test_table_2020，这些数据需要跨年度查询。

合并表引擎功能

1本身不存储任何数据，不支持数据写入。

合并多个查询的结果集，通过代理查询任意数量的数据表，

查询将异步并行执行，最后返回结果集。

4代理查询的数据表要求在同一个数据库中，具有相同的表结构，但可以使用不同的表引擎和不同的分区定义。

定义

引擎=合并(数据库，表名)

1是数据库名称。

2 table_name是数据表的名称，支持正则表达式。

例子

记录表

#数据表1

创建表test_table_2018(

id字符串，

创建时间日期时间，

代码串)

引擎=合并树

按toyyymm(create _ time)分区

按id排序

#数据表2

创建表test_table_2019(

id字符串，

创建时间日期时间，

代码串

)引擎=日志

#合并表格

创建表test_table_all为test _ TABLE _ 2018 ENGINE = Merge(current database()，& # 39；^test_table_&#39；)

询问

SELECT _table，* FROM test_table_all

#查看2018年的

SELECT _table，* FROM test _ table _ all WHERE _ table = & # 39；test _ table _ 2018 & # 39

5.2字典

什么是字典表引擎？

数据字典的封装可以代替字典功能。

2所有数据都将加载到内存中，性能不受影响。

定义

引擎=字典(字典名)

例子

创建表tb_test_flat_dict(

id UInt64，

代码字符串，

名称字符串)

引擎=字典(test _ flat _ dict)；

发展

如果词典数量较多，使用词典引擎类型数据库解决。

创建数据库测试_字典引擎=字典

6其他类型

以下类型，了解使用场景

6.1实时视图

事件

LIve View类似于事件监控机制，以SQL查询结果为监控目标。当目标数据增加时，实时视图可以及时响应。

6.2空

事件

当用户向空表中写入数据时，系统会正确返回数据，但空表会自动忽略这些数据，并且永远不会保存它们。

6.3网址

事件

HTTP客户端，可以通过HTTP/HTTPS协议直接访问远程REST服务。

7参考

朱凯点击屋原理的分析与应用实践

如果你觉得文章还可以，请点赞，评论，转发，收藏，关注！！！