ClickHouse

ClickHouse

一、clickhouse介绍

1、简介
		clickhouse是用于联机分析的列式数据库管理系统，主要用于在线分析处理数据，能使用	sql语句实时生成分析数据报告。
2、优点
	*支持海量数据
	*运算速度快，可进行实时分析
	*易扩容，高可用
	*支持sql语句
	......
3、缺点
	*不支持事物
	*不支持高并发
	*多表join性能不好
	*元数据管理需要人为干预
	......
4、应用场景
	*实时分析
	*大多是读操作
	*表很宽
	*要求延迟低
	......
5、核心概念
	数据分片、列式存储、分区、副本备份、引擎...

二、clickhouse部署

安装--配置文件--分发等操作
到 /usr/bin 下执行启动命令 --之后在任意位置启动客户端命令
启动：clickhouse-server start
重启：service clickhouse-server restart
关闭：service clickhouse-server stop
客户端：clickhouse-client -m

详细信息见另一个文档.....

三、基础操作

3.1基本数据类型

show databases;
create database if not exists mydata;
use mydata;
select currentDatabase();
drop database mydata;

--1、注意在CK中关键字严格区分大小写   ck中建表的时候 ,一定指定表引擎!
  
2、基本数据类型
   Int8、Int16、Int64
   UInt....非负整数
   Float32、Float64
   Decimal...精确小数
   String
   FixedString(5)--指定字符串的最大长度
   UUID、随机数--generateUUIDv4()
   Date...年月日
   DateTime....年月日 时分秒
   DateTime64...年月日 时分秒,可以记录亚秒，它在DateTime之上增加了精度的设置
例如：
drop table test;
	create table test(
    id Int8,
    age UInt8,
    sal Float64,
    name  FixedString(10),
    sid  UUID,
    birthday DateTime
    )
    engine=MergeTree()
    order by id
    ;
    insert into table test values(11,20,1000.345,'zss',generateUUIDv4(),now());
    insert into table test values(12,22,1030.345,'lss',generateUUIDv4(),now());

3.2复杂数据类型

--Enum 枚举
	定义：color Enum('red'=1 , 'green'=2 , 'blue'=3)
	建表：
	create table test_enum(id Int8 , color Enum('red'=1 , 'green'=2 , 'blue'=3)) engine=Memory ;
	插入数据：insert into  test_enum values(1,'red'),(1,1),(2,'green');
	查询：select * from test_enum;
--Array 数组
	定义：[1,2,3]、array('a' , 'b' , 'c')
	建表：create table test_array(id Int8 ,hobby Array(String))engine=Memory ;
	插入数据：insert into test_array values(1,['eat','drink','la']),(2,array('sleep','palyg','sql'));
	查询:select id , hobby  , toTypeName(hobby) from test_array ;
		select id , hobby[2]  , toTypeName(hobby) from test_array ;
        -- 数组的取值,hobby[1]数组的索引从1开始
--Tuple 元祖
	定义：tuple(1,'asb',12.23)
	建表：CREATE TABLE test_tuple ( c1 Tuple(UInt8, String, Float64) )ENGINE=Memory; 
	插入数据：insert into table test_tuple values((1,'a',22.33));
	查询：select * from test_tuple;
--Nested 嵌套表结构
	建表：create table test_nested(
         uid Int8 ,
         name String ,
         props Nested(
           pid Int8,
           pnames String ,
           pvalues String
         )
       )engine = Memory ;
	注意：pid和pname、pvalues都是数组
	插入数据：insert into test_nested values(1,'hadoop',[1,2,3],['p1','p2','p3'],                ['v1','v2','v3']);
	查询：select * from test_nested;
	注意：嵌套类型本质是一种多维数组的结构。
		 嵌套表中的每个字段都是一个数组，
		 并且行与行之间数组的长度无须对齐
		 但是：在同一行数据内每个数组字段的长度必须相等。
--IPv4 IP数据
	定义：ip IPv4;
	建表：
		create table test_ip(id UInt8,ip IPv4 )engine=Memory();
		insert into table test_ip values(1,'192.168.3.2');--若ip地址格式不对则会报错
		select * from test_ip;
--Boolean和Nullable
    ck中没有Boolean类型 ,使用1和0来代表true和false 
    Nullable 某种数据类型允许为null , 或者是没有给值的情况下模式是NULL

3.3建表语法

1、建表
	一定要指定引擎
	若为MergeTree引擎，则一定有主键和排序字段
2、只有MergeTree引擎的表才支持表的修改操作（alter操作）
	添加字段：
		alter table tb_test2 add column gender String after name ;
	删除字段：
		alter table tb_test2 drop column age ;

3.4 插入导出数据

1、insert into table test1 values()
2、insert into table test select ....
3、静态数据导入
  -- 将数据导入到表中--在非客户端操作
  cat user.txt  | clickhouse-client  -q 'insert into default.test_load1 format CSV' 
  或者
  clickhouse-client  -q 'insert into default.test_load1 format CSV'  <  user.txt
4、将数据导出
     clickhouse-client -h 127.0.0.1 --database="db" --query="select * from            db.test_table FORMAT CSV" > test.csv

3.5 更新删除分区操作

--注意数据的修改和删除操作是使用用MergeTree家族引擎:
 
-- 删除分区数据 
alter table test_muta drop  partition 'SH' ;
alter table test_muta delete where id=3 ;  -- 一定加条件
--条件更新数据
alter table test_muta update name='李思思'  where id=3 ;
--复制分区数据，前提是表结构（排序分区啥的）都相同
ALTER TABLE  B  REPLACE PARTITION partition_name FROM A 
--装载卸载分区
卸载：相当于这个分区失去了与总表的联系，查询的时候查询不到，但数据并未消失，而是被转移到了	  当前数据表目录的detached子目录下
装载：相当于重新建立了与总表的联系
卸载分区：alter table test_rep detach partition '202105' ;
装载分区：alter table test_rep attach partition '202105' ;

3.6视图操作

clickhouse中有两种视图：普通视图和物化视图
视图的作用：提供简单的查询代理--相当于一个查询的连接

--普通视图：
	不会存储数据，只提供查询代理
create view count_view as select count(1) from test;
select * from count_view ;

--物化视图：
	视图的结果会存储下来，最重要的是可以实时更新，只要源数据更改，视图数据也会进行更新
create materialized view count_view2 engine = Log populate as select count(1) from test;
select * from count_view2 ;
--此时向原表中添加数据，物化视图表也会进行更新

四、引擎详解

引擎的重要性
	1）数据的存储位置和方式，写到哪里以及从哪里读数据
	2)支持哪些查询以及如何支持
	3）索引的使用（如果存在索引）
	4）是否可执行多线程
	5）是否可以存储数据副本
	.....

4.1Log引擎

Log家族具有最小功能的轻量级引擎。使用并不多

4.2 MergeTree 系列引擎

核心的一种引擎：MergeTree --排序，区内合并
	MergeTree在写入一批数据时，数据总会以数据片段的形式写入磁盘，后续会进行区内合并，同一个区的合并到一起。
使用此引擎，必须指定主键和排序字段。因为此引擎会进行区合并和区内排序，所以必须指定排序字段
  建表：
      create table tb_merge_tree(
      id Int8 ,
      city String ,
      ctime Date 
      )
      engine=MergeTree()--设置引擎
      order by id --排序字段
      primary key id --主键字段
      partition by city --分区字段
	  ;
	  --当只有排序字段时，默认主键与排序字段一致

--1）MergeTree
	手动合并：optimize table test_1 final ;
	
--2）ReplacingMergeTree
	增加了去重功能：同一区内排序相同数据会被清掉（后台处理需要时间，可以手动合并）
	无版本参数：去重时则保留最新插入的数据
    	engine = ReplacingMergeTree()
	有版本参数：参数可以是时间或者版本号，去重时按照时间或者版本号来保留最新的数据
		engine = ReplacingMergeTree(ctime）
                                    
--3)CollapsingMergeTree
	折叠合并树引擎：对数据记录一个标记，1或者-1
     1为有效数据，-1为该删除的数据，当区相同，排序字段又相同时1和-1必须成对使用才有效，且	   必须是1在前，-1在后，才会进行删除。
     在建表的时候单独用一个字段来记录1或者-1这个标记  【sign Int8】                     
     问题：在并发写入的时候，并不能保证标记为1的数据先行插入
                                    
--4)VersionCollapsingMergeTree
	解决了CollapsingMergeTree的问题，新增加一个版本标记，若分区、主键排序、版本都相同，		且标记为1和-1，则就回进行删除。不需要必须是1在前-1在后。
                                    
--5)SummingMergeTree
	预聚合引擎：只做聚合函数的查询，会将区和主键排序都相同的数据中的数字的字段进行聚合
     不给参数：对表中所有的数值字段都进行聚合                               
	给 参 数：只对所给的参数进行聚合
 		当engine=SummingMergeTree(money)给了参数money的时候，则只会对money进行聚合                      

--6）AgregateingMergeTree   
     算是SummingMergeTree的升级版   
     在使用的时候有着 特殊的定义、插入数据、查询数据的方式  
 以建立一个AgregateingMergeTree引擎的物化视图为例：
  -- 建立明细表
CREATE TABLE orders
(
    uid UInt64,
    money UInt64,
    ctime Date,
    Sign Int8
)
ENGINE =MergeTree(Sign)
ORDER BY uid;

--插入数据 
insert into orders values(1,100,toDate(now()),1) ;
insert into orders values(1,100,toDate(now()),1) ;
insert into orders values(1,100,toDate(now()),1) ;
insert into orders values(2,200,toDate(now()),1) ;
insert into orders values(2,200,toDate(now()),1) ;
insert into orders values(2,200,toDate(now()),1) ;

-- 将聚合逻辑创建成物化视图,以实现同步更新预聚合表
---预聚合表只能是这种查询导入的方式插入数据，不能直接insert into values....
CREATE MATERIALIZED VIEW orders_agg_view
ENGINE = AggregatingMergeTree() --该物化视图的引擎为AggregatingMergeTree
PARTITION BY toDate(ctime)
ORDER BY uid 
populate
as select 
uid ,
ctime ,
sumState(money) as mm-- 注意别名 --注意此处用的是sumState(money)--sum为求和的聚合函数
from 
orders
group by uid , ctime;

-- 查询物化视图数据--注意查询的时候使用的是sumMerge(mm)
select uid,ctime,sumMerge(mm) from orders_agg_view group by uid, ctime ;  

4.3 外部引擎

--1)Hdfs 引擎
	可以实现直接从Hdfs文件中的·数据进行读取，以读取的数据进行建表，很是方便
	--注：
		*引擎中地址给的是Hdfs的绝对路径
		*？.txt 代表所有的以.txt结尾的文件
		*a_{1..5}.txt代表所有以a_1.txt到a_5.txt的文件
    创建文件,将文件上传到指定的目录下
    1.txt
    1,zss,21
    2,ww,22

    2.txt 
    3,lss,33
    4,qaa,32

    3.txt 
    5,as,31
    6,ghf,45
    
    --匹配单个字符 
    create table test_hdfs2(
    id Int8 ,
    name String ,
    age Int8
    )engine=HDFS('hdfs://linux01:8020/ck/test1/?.txt' ,CSV) ;
    -- 匹配数字之间的文件
    create table test_hdfs3(
    id Int8 ,
    name String ,
    age Int8
    )engine=HDFS('hdfs://linux01:8020/ck/test1/a_{1..2}.txt' ,CSV) ;

--2)MySQL 表引擎  可以将Mysql中的表的数据导入进来

-- 在mysql中建表 
create table tb_x(id int, name varchar(25), age int) ;
insert into tb_x values(1,'zss',23),(2,'lss',33) ;
-- 在clickhouse中建表 
CREATE TABLE tb_mysql
(
    `id` Int8,  --注意有  的字符
    `name` String,
    `age` Int8
)
ENGINE = MySQL('doit01:3306', 'test1', 'tb_x', 'root', 'root');
--引擎中的数据为：域名：端口，数据库，表，用户名，密码

查看数据
select * from tb_mysql;
插入数据
insert into tb_mysql values(3,'ww',44) ;

- 支持查询数据 
- 支持插入数据
- 不支持删除和更新操作 


--3)MySQL 数据库引擎 --可以将Mysql中的数据库复制一份过来
create database db_ck_mysql engine=MySQL('doit01:3306','test1','root','root') ;

--file引擎

4.4 内存引擎

--1)Memory 引擎
	常用于测试，数据存在内存中，当服务器断开的时候，数据也随之消失
--2）Buff引擎
	当某个表有个高并发的写入的时候，可以考虑使用BUff缓冲表
	*缓冲表当达到刷写时机的时候，便会向总表进行刷写
	*当服务器断开的时候会造成数据丢失
	*我们仅建议在极少数情况下使用Buffer表。
	 1) 创建一个目标表
     create table tb_user(uid Int8 , name String) engine=TinyLog ;
     2) 创建一个缓存表
     CREATE TABLE tb_user_buffer AS tb_user ENGINE = Buffer(default, tb_user, 16, 10, 100, 10000, 1000000, 10000000, 100000000) ;
     --引擎中的数据为：表所在的库，表名，线程数(默认16)，最小最大时间(秒),最小最大行数，最小最大字节数---以上三个条件达到其中之一的阈值便会刷写
     3) 向缓存表中插入数据
     insert into tb_user_buffer values(1,'Yang'),(2,'Haha') ,(3,'ADA') ;
     4) 等待以后查看目标表中的数据
     select * from tb_user ;

五 查询语法

5.1 with

--1) 定义变量
    WITH 
        1 AS start,
        10 AS end
    SELECT 
        id + start,
        *
    FROM tb_mysql
--2）调用函数
	WITH
    toDate(birthday) AS bday
    SELECT 
        id,
        name,
        bday
    FROM tb_partition
--3）子查询
    WITH 
         (
             SELECT *
             FROM tb_partition
             WHERE id = 1
         ) AS sub
     SELECT 
         *,
         sub
     FROM tb_partition

5.2 外部查询数据

1：从hdfs中读取数据
select * from hdfs ('文件路径'，文件格式，‘表的结构’)
select * from hdfs ('hdfs://linux01:8020/data/a.csv',CSV,'id Int8,name String');
2:从本地中读取数据
select * from file('/chbase/data/user_files/a.csv',CSV,'id Int8,name String');
3:从mysql中读取数据
select * from mysql('linux01:3306','mysql','test_1','root','123456');

5.3 array join

array join 似于hive中的explode炸裂函数的功能!
--案例：
求每个店铺的最大连续销售天数：
数据：
a,2017-02-05,200
a,2017-02-06,300
a,2017-02-07,200
a,2017-02-08,400
a,2017-02-08,300
a,2017-02-10,600
b,2017-02-05,200
b,2017-02-06,300
b,2017-02-08,200
b,2017-02-09,400
b,2017-02-10,600
c,2017-01-31,200
c,2017-02-01,300
c,2017-02-02,200
c,2017-02-03,400
c,2017-02-10,600
a,2017-03-01,200
a,2017-03-02,300
a,2017-03-03,200
a,2017-03-04,400
a,2017-03-05,600
建表：
create table test_11(
name String ,
cdate Date,
money UInt16
)
engine=ReplacingMergeTree()
order by (name,cdate)
;
导入数据：
clickhouse-client  -q 'insert into default.test_11 format CSV'  <  b.csv
---b.csv是linux本地的文件
┌─name─┬──────cdate─┬─money─┐
│ a    │ 2017-02-05 │   200 │
│ a    │ 2017-02-06 │   300 │
│ a    │ 2017-02-07 │   200 │
│ a    │ 2017-02-08 │   400 │
│ a    │ 2017-02-08 │   300 │
│ a    │ 2017-02-10 │   600 │
│ a    │ 2017-03-01 │   200 │
│ a    │ 2017-03-02 │   300 │
│ a    │ 2017-03-03 │   200 │
│ a    │ 2017-03-04 │   400 │
│ a    │ 2017-03-05 │   600 │
│ b    │ 2017-02-05 │   200 │
│ b    │ 2017-02-06 │   300 │
│ b    │ 2017-02-08 │   200 │
│ b    │ 2017-02-09 │   400 │
│ b    │ 2017-02-10 │   600 │
│ c    │ 2017-01-31 │   200 │
│ c    │ 2017-02-01 │   300 │
│ c    │ 2017-02-02 │   200 │
│ c    │ 2017-02-03 │   400 │
│ c    │ 2017-02-10 │   600 │
└──────┴────────────┴───────┘
第一步：做编号
with
groupArray(cdate) as dates,
arrayEnumerate(dates) as indxs
select
name,
dates,
indxs
from
test_11
group by name
;
第二步：打上编号
select
name,
ds,
ins 
from
(
with
groupArray(cdate) as dates,
arrayEnumerate(dates) as indxs
select
name,
dates,
indxs
from
test_11
group by name
)
array join dates as ds,indxs as ins
;
┌─name─┬─────────ds─┬─ins─┐
│ b    │ 2017-02-05 │   1 │
│ b    │ 2017-02-06 │   2 │
│ b    │ 2017-02-08 │   3 │
│ b    │ 2017-02-09 │   4 │
│ b    │ 2017-02-10 │   5 │
│ c    │ 2017-01-31 │   1 │
│ c    │ 2017-02-01 │   2 │
│ c    │ 2017-02-02 │   3 │
│ c    │ 2017-02-03 │   4 │
│ c    │ 2017-02-10 │   5 │
│ a    │ 2017-02-05 │   1 │
│ a    │ 2017-02-06 │   2 │
│ a    │ 2017-02-07 │   3 │
│ a    │ 2017-02-08 │   4 │
│ a    │ 2017-02-10 │   5 │
│ a    │ 2017-03-01 │   6 │
│ a    │ 2017-03-02 │   7 │
│ a    │ 2017-03-03 │   8 │
│ a    │ 2017-03-04 │   9 │
│ a    │ 2017-03-05 │  10 │
└──────┴────────────┴─────┘
第三：相减
select 
name,
date_sub(Day,ins,ds) sub
from
(
  select
  name,
  ds,
  ins 
  from
  (
    with
    groupArray(cdate) as dates,
    arrayEnumerate(dates) as indxs
    select
    name,
    dates,
    indxs
    from
    test_11
    group by name
    )
  array join dates as ds,indxs as ins
) 

;
第四：分组聚合--求最大
name,
date_sub(Day,ins,ds) sub,
count(1) counts
from
(
  select
  name,
  ds,
  ins 
  from
  (
    with
    groupArray(cdate) as dates,
    arrayEnumerate(dates) as indxs
    select
    name,
    dates,
    indxs
    from
    test_11
    group by name
    )
  array join dates as ds,indxs as ins
) 
group by name,sub
order by name,counts desc
limit 1 by name
;

5.4 关联查询

--all 全连接
	all inner 或者直接all都跟正常的join一样
        SELECT *
        FROM yg AS inser
        ALL INNER JOIN gz ON yg.id = gz.id ;
        SELECT *
        FROM yg AS inser
        ALL  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 │   2 │     2 │ 2000 │ 1233 │
│  3 │ VV   │  27 │   1 │     3 │ 2000 │ 3000 │

--any 只连接一条
	当左表的某一行数据可以关联右表的多行数据时，此时只会关联一行，而不是多行都关联
        SELECT *
        FROM yg
        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 │   2 │     2 │ 2000 │ 1233 │
│  3 │ VV   │  27 │   1 │     3 │ 2000 │ 3000 

---- ASOF inner join 
	当有多个关联条件时，要使用 ASOF inner join
	select * from A ASOF inner join B ON a.id=b.id and a.sal>b.sal

5.5 with模型–构建立方体

- With cube --全维度立方体
- With rollup--按照区主键增加，上卷
- With totals--只做总体的111和000

--数据
drop table is 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,12,'山东','济南','天桥') ;
insert into tb_with values(5,88,'山东','青岛','黄岛') ;
insert into tb_with values(6,88,'山东','青岛','黄岛') ;
insert into tb_with values(7,12,'山西','太原','小店') ;
insert into tb_with values(8,12,'山西','太原','小店') ;
insert into tb_with values(9,112,'山西','太原','尖草坪') ;
--查询：
(1)
SELECT  province,city,area,sum(vist)
FROM    tb_with
GROUP BY province,city,area
WITH CUBE ;
(2)
SELECT  province,city,area,sum(vist)
FROM    tb_with
GROUP BY province,city,area
WITH rollup ;
(3)
SELECT  province,city,area,sum(vist)
FROM    tb_with
GROUP BY province,city,area
WITH totals ;

六、函数

clickhouse中的函数很丰富，用到时可去官网搜索

6.1 类型转换函数

toInt8   toFloat32 ....
toDate   toDate32 .....
toString ...

CAST
	SELECT
    CAST(timestamp AS DateTime) AS datetime,
    CAST(timestamp AS Date) AS date;
   

6.2日期函数

date_sub   date_diff 
.....

6.3 if、multiIf 函数

if(exp1 , exp2,exp3) 相当于三目运算符
	若exp1成立，则执行exp2 ，否则执行exp3
multiIf(exp1,value1, exp2,value2,exp3value3,other)
例如：
SELECT 
    *,
    if(gender = 'M', '男', '女')
FROM tb_if

SELECT 
    *,
    multiIf(gender = 'M', '男', gender = 'F', '女', '保密') AS sex
FROM tb_if

6.4 json数据解析

1、--json数据解析
数据：
	{"movie":"2398","rate":"4","timeStamp":"978302281","uid":"1"}
    {"movie":"2918","rate":"4","timeStamp":"978302124","uid":"1"}
    {"movie":"1035","rate":"5","timeStamp":"978301753","uid":"1"}
    {"movie":"2791","rate":"4","timeStamp":"978302188","uid":"1"}
    {"movie":"2687","rate":"3","timeStamp":"978824268","uid":"1"}
    {"movie":"2018","rate":"4","timeStamp":"978301777","uid":"1"}
    {"movie":"3105","rate":"5","timeStamp":"978301713","uid":"1"}
    {"movie":"2797","rate":"4","timeStamp":"978302039","uid":"1"}
建表：
	create table test_movie (
      strs String
      )engine=Log;
导入数据：在客户端外面，movie.json所在的位置，可以不写movie.json的路径
clickhouse-client  -q 'insert into test_movie format JSONAsString' < movie.json
查询数据并解析：
	with
    visitParamExtractRaw(strs,'movie') as movie,
    visitParamExtractRaw(strs,'rate') as rate,
    visitParamExtractRaw(strs,'timeStamp') as tims,
    visitParamExtractRaw(strs,'uid') as uid
    select 
    movie,
    toInt8(replaceAll(rate,'"','')) as rat,
    tims,
    uid
    from 
    test_movie;

七、分布式

clickhouse采用的是多主架构，并且用zookeeper进行管理。而非主从架构。
节点之间可以任意的组成集群，把比如linux1、2集群；Linux1、2、3集群

7.1 配置zookeeper

—查看源文件

7.2 创建分布式表，进行分布式存储和查询

--分布式表的作用：
	分布式表起着查询代理的作用。
	一个表有多个切片，每个切片还有多个副本，当插入数据的时候，若没有分布式表，则要到每台机器上进行插入，查询的时候同样要到不同机器上进行查询数据，之后还要将数据汇总。而且还会有插入和查询热点问题。
	*有了分布式表，插入和查询的时候直接找分布式表，分布式会指向本地表，方便很多。
	*而且在插入的时候采用随机数进行分片插入，便解决了插入热点的问题
	*在查询的时候，可以将分布式表建立在不同机器上，这样便解决了查询热点的问题，不管分布式表在几个机器上，指向的都是同一个本地表。
	插入的时候向分布式表插入，便会自动将数据插入到本地表中，查询的时候也是直接查询分布式表。
--注：有几台机器，最多就有几个分片，而且最多就有几个副本
  总而言之，linux01 、02、03 在集群的配置文件中只能出现一次
  比如：三个分片，每个分片便没有副本，每个分片各占一个linux机器

步骤：
	1、在配置文件/etc/clickhouse-server/config.d/metrika.xml文件中配置分片和副本信息
		配置好后分发到linux02和linux03
	2、建本地表，指定所在的集群
	3、建分布式表，指定'查询代理'的对象
1)
<cluster2>
<!-- 集群名为cluster2 整个集群中每个表有三个分片,每个切片无副本，分别在lx01 lx02 lx03上 -->
 <shard>
  <replica>
  <host>linux01</host>
  <port>9000</port>
  </replica>
  </shard>
  
  <shard>
  <replica>
  <host>linux02</host>
  <port>9000</port>
  </replica>
  </shard>
  
  <shard>
  <replica>
  <host>linux03</host>
  <port>9000</port>
  </replica>
 </shard>
 
</cluster2>

2）
-- 创建本地表
create table tb_demo4 on cluster cluster2( --注意要指定集群
id  Int8 ,
name String 
)engine=MergeTree() 
order by  id ;
3）
-- 创建分布式表
create table demo4_all on cluster cluster2 engine=Distributed('cluster2','default','tb_demo4',id) as tb_demo4 ;

分布式表demo4_all也在集群cluster2上，
引擎采用Distributed(本地表的集群，库，表名，分片字段) 
as tb_demo4 指向本地表tb_demo4

4）插入数据 insert into table demo4_all values (2,'zaa');
   查询数据 select * from demo4_all;

八、应用案例

8.1 设置用户登录权限和使用权限

在 /etc/clickhouse-server/user.xml  而不是clickhouse的安装目录
1)设置用户登录权限
在user.xml中添加用户配置,在user中进行配置
<users>
    <default>
      <password></password>
      <networks incl="networks" replace="replace">
        <ip>::/0</ip>
      </networks>
      <profile>default</profile>
      <quota>default</quota>
    </default>
<!-- 定义一个用户 用户名为hangge 密码使用明文 root -->
<hangge>
<password_sha256_hex>f493c8a7a3c37088731336766459cc37e4b094e95b918038726660cc42013fcd</password_sha256_hex>
      <networks incl="networks" replace="replace">
        <ip>::/0</ip>
      </networks>
      <profile>default</profile>
      <quota>default</quota>
    </hangge>
  </users>

密码使用加密密码：
  密码：
	HA256加密：在使用SHA256加密算法的时候，需要通过password_sha256_hex标签定义密码
	echo -n root | openssl dgst -sha256    
	-->f493c8a7a3c37088731336766459cc37e4b094e95b918038726660cc42013fcd
<password_sha256_hex>f493c8a7a3c37088731336766459cc37e4b094e95b918038726660cc42013fcd</password_sha256_hex>

double_sha1加密:
在使用double_sha1加密算法的时候，则需要通过 password_double_sha1_hex标签定义密码，
echo -n 123456 | openssl dgst -sha1 -binary | openssl dgst -sha1 
(stdin)= 6bb4837eb74329105ee4568dda7dc67ed2ca2ad9
<password_sha256_hex>6bb4837eb74329105ee4568dda7dc67ed2ca2ad9</password_sha256_hex>

用户权限设置：--只允许查看default库
<hangge>
<password_sha256_hex>60cd41aedc4e47e8883682b416109e7b7e345e15decc63c2c98ecdab5e8e053a</password_sha256_hex>
    <networks incl="networks" />
    <profile>readonly</profile>   
    <quota>default</quota>
    <allow_databases>
        <database>default</database>
    </allow_databases>
</hangge>

8.2 工具

jdbc --java连接clickhouse
客户端工具 DBeaver  --类似Navicat 
http://ui.tabix.io/#!/login 提供的一个clickhouse页面可视化工具

8.3 用户行为分析