1 hadoop架构
1.1 mp：hdfs
00.介绍
Map折分、混洗Shuffle、合约reduce
HDFS解决存储、MapReduce解决计算、YARN资源管理
01.hdfs
hdfs dfs -ls / --列出HDFS根目录下的所有文件和子目录
hdfs dfs -put /tmp/ /hdfs/ --和 copyFromLocal 区别是，put 原路径可以是文件夹等
hdfs dfs -copyFromLocal /local/data /hdfs/data --将本地文件上传到 hdfs上（原路径只能是一个文件）
02.hadoop
a.查看
hadoop fs -ls / --默认是HDFS系统下的根目录
hadoop fs -ls /package/test/ --HDFS系统下某个目录
hadoop fs -cat /package/test/ --HDFS系统下某个目录
b.上传文件、目录
a.put用法
a.上传新文件
hdfs fs -put file:/root/test.txt hdfs:/ --上传本地test.txt文件到HDFS根目录，HDFS根目录须无同名文件，否则“File exists”
hdfs fs -put test.txt /test2.txt --上传并重命名文件
hdfs fs -put test1.txt test2.txt hdfs:/ --一次上传多个文件到HDFS路径
b.上传文件夹
hdfs fs -put mypkg /newpkg --上传并重命名了文件夹
hdfs fs -put -f /root/test.txt / --如果HDFS目录中有同名文件会被覆盖
b.copyFromLocal用法
a.上传文件并重命名
hadoop fs -copyFromLocal file:/test.txt hdfs:/test2.txt
c.下载文件、目录
a.get用法：
hadoop fs -get hdfs:/test.txt file:/root/ --拷贝文件到本地目录
hadoop fs -get /test.txt /root/test.txt --拷贝文件并重命名
b.copyToLocal用法
hadoop fs -copyToLocal hdfs:/test.txt file:/root/ --拷贝文件到本地目录
hadoop fs -copyToLocal /test.txt /root/test.txt --拷贝文件并重命名
d.拷贝文件、目录
hadoop fs -cp file:/test.txt hdfs:/test2.txt --从本地到HDFS，同put
hadoop fs -cp hdfs:/test.txt hdfs:/test2.txt --从HDFS到HDFS
e.移动文件
hadoop fs -mv hdfs:/test.txt hdfs:/dir/test.txt
hadoop fs -mv /test.txt /dir/test.txt
f.删除文件、目录
hadoop fs -rm /a.txt --删除指定文件
hadoop fs -rm /*.txt --删除全部txt文件
hadoop fs -rm -r /user/TroyeKK --递归删除全部文件和目录
g.读取文件
hadoop fs -cat /test.txt #以字节码的形式读取
hadoop fs -tail /test.txt
h.创建空文件
hadoop fs - touchz /newfile.txt
i.创建文件夹
hadoop fs -mkdir /newdir /newdir2 --可以同时创建多个
hadoop fs -mkdir -p /newpkg/newpkg2/newpkg3 --同时创建父级目录
k.获取逻辑空间文件、目录大小（du）
hadoop fs - du / --显示HDFS根目录中各文件和文件夹大小
hadoop fs -du -h / --以最大单位显示HDFS根目录中各文件和文件夹大小
hadoop fs -du -s / --仅显示HDFS根目录大小。即各文件和文件夹大小之和
1.2 hive1：数据仓库
00.总结
a.常用1
create databases if not exists test;
show databases;
show tables;
use test;
desc stu;
-----------------------------------------------------------------------------------------------------
create table if not exists employee (
Name String comment ‘Employee Name’,
Id int,
MobileNumber String,
Salary Float
);
-----------------------------------------------------------------------------------------------------
DESCRIBE FORMATTED student_hive;
show create table internal_student;
-----------------------------------------------------------------------------------------------------
truncate table student_hive; --外部表不支持使用TRUNCATE语句
drop table student_hive;
b.常用2
load data inpath '/user.txt' into table t_user;
load data local inpath '/home/hadoop/user.txt' into table t_user;
-----------------------------------------------------------------------------------------------------
默认不开启事务（不支持update和delete）
内部表开启事务（支持update和delete）
外部表不支持事务（不支持支持update和delete）
hive操作hbase（因HBase不支持Hive的ACID特性，因此不能通过Hive对HBase表进行事务管理）
-----------------------------------------------------------------------------------------------------
SELECT * FROM OMS_DATACENTER.SG_CON_PWRGRID_F_BALANCE_RESULT_WEEK;
INSERT INTO MW_APP.MWT_UD_ZJCNXM2222 (OBJ_ID,OBJ_DISPIDX,sfysb,sf,bwdydj,zt,rq) VALUES( MW_SYS.NEWGUID(),'0','未上报','1111','10kV','111','2023-10-01');
UPDATE MW_APP.MWT_UD_TXFXYJDGL SET LCZT='已发送' WHERE OBJ_ID = '408DE45D-D5DA-4EDE-9E22-FD35BCF2DA9D-00016';
DELETE FROM MW_APP.MWT_UD_ZYCNXM WHERE OBJ_ID = '467DBE40-B8B8-43D3-8A67-5E6764CF6D3D-00001';
-----------------------------------------------------------------------------------------------------
TRUNCATE TABLE student_hive;
DROP TABLE student_hive;
-----------------------------------------------------------------------------------------------------
HiveJoin 分三种：inner join, outer join, semi join，其中outer join 包括 left join，right join 和 full outer join
c.视图
CREATE VIEW emp_40000 AS SELECT * FROM employee WHERE salary>40000
DROP VIEW view_name
d.UDF函数
UDF 分为两大类：UDAF（用户自定义聚合函数）和 UDTF（用户自定义表生成函数）
e.复杂类型
a.复杂类型：STRUCT
CREATE TABLE users (
id INT,
info STRUCT<name: STRING, age: INT, address: STRING>
)
CLUSTERED BY (id) INTO 4 BUCKETS
STORED AS ORC
TBLPROPERTIES ('transactional'='true');
b.复杂类型：ARRAY
CREATE TABLE students (
student_id INT,
courses ARRAY<STRING>
)
CLUSTERED BY (student_id) INTO 4 BUCKETS
STORED AS ORC
TBLPROPERTIES ('transactional'='true');
c.复杂类型：MAP
CREATE TABLE employees (
emp_id INT,
contacts MAP<STRING, STRING>
)
CLUSTERED BY (emp_id) INTO 4 BUCKETS
STORED AS ORC
TBLPROPERTIES ('transactional'='true');
d.复杂类型：UINON
CREATE TABLE mixed_data (
id INT,
mixed_value UNIONTYPE<INT, STRING, DOUBLE>
)
CLUSTERED BY (id) INTO 4 BUCKETS
STORED AS ORC
TBLPROPERTIES ('transactional'='true');
f.语法：insert overwrite
a.重写表数据
用于清除并替换现有的数据。
b.重写分区数据：可以用 INSERT OVERWRITE 对特定分区进行覆盖。
-- 重写表中 department='Sales' 分区的数据
INSERT OVERWRITE TABLE employee_data PARTITION (department='Sales')
SELECT emp_id, name FROM employee_data WHERE department='Sales';
c.导出到外部文件：将查询结果直接导出到指定的 HDFS 目录中。
-- 导出查询结果到指定的 HDFS 目录
INSERT OVERWRITE DIRECTORY '/user/hive/warehouse/employee_output'
SELECT * FROM employee_data;
g.语法：merge into
a.介绍
MERGE INTO target_table AS target
USING source_table AS source
ON (condition)
WHEN MATCHED THEN
UPDATE SET target.column1 = source.column1, target.column2 = source.column2
WHEN NOT MATCHED THEN
INSERT (column1, column2) VALUES (source.column1, source.column2);
b.示例
MERGE INTO employee_target AS target
USING employee_source AS source
ON target.emp_id = source.emp_id
WHEN MATCHED THEN
UPDATE SET target.name = source.name,target.department = source.department
WHEN NOT MATCHED THEN
INSERT (emp_id, name, department) VALUES (source.emp_id, source.name, source.department);
h.SELECT语法
a.语法
SELECT [ALL | DISTINCT] select_expr, select_expr, ...
FROM table_reference
[WHERE where_condition]
[GROUP BY col_list]
[ORDER BY col_list]
[CLUSTER BY col_list | [DISTRIBUTE BY col_list] [SORT BY col_list] ]
[LIMIT number]
b.Map阶段
1.执行from加载，进行表的查找与加载
2.执行where过滤，进行条件过滤与筛选
3.执行select查询：进行输出项的筛选
4.执行group by分组：描述了分组后需要计算的函数
5.map端文件合并：map端本地溢出写文件的合并操作，每个map最终形成一个临时文件。然后按列映射到对应的Reduce阶段：
c.Reduce阶段
1.group by：对map端发送过来的数据进行分组并进行计算。
2.select：最后过滤列用于输出结果
3.limit排序后进行结果输出到HDFS文件
i.排序
a.ORDER BY 全局排序
对全局数据进行排序，通常只使用一个 reducer。
b.SORT BY 每个Reduce内部排序
对每个 reducer 的数据进行排序，不保证全局排序。
c.DISTRIBUTE BY 分区
根据指定字段将数据分配到不同的 reducers，不进行排序。
d.CLUSTER BY 分区排序
结合了 DISTRIBUTE BY 和 SORT BY，将数据分配到 reducers 中，并在每个 reducer 内部进行排序。
j.窗口函数
a.OVER 子句
SELECT
emp_id,
amount,
SUM(amount) OVER (PARTITION BY department ORDER BY amount) AS running_total
FROM sales;
b.序列函数
SELECT
emp_id,
name,
department,
ROW_NUMBER() OVER (PARTITION BY department ORDER BY amount DESC) AS row_num
FROM sales;
c.窗口函数示例
SELECT
emp_id,
amount,
SUM(amount) OVER (PARTITION BY department ORDER BY amount) AS running_total
FROM sales;
k.文件格式和压缩
a.表的压缩设置
CREATE TABLE my_table (
id INT,
name STRING
)
STORED AS TEXTFILE
TBLPROPERTIES ("compression"="gzip");
-------------------------------------------------------------------------------------------------
修改表的压缩设置：
ALTER TABLE my_table SET TBLPROPERTIES ('compression'='snappy');
b.计算过程中的压缩
计算过程中可以通过以下设置来启用压缩：
MapReduce任务压缩设置： 修改Hive配置文件（如hive-site.xml）或在Hive查询中设置：
-------------------------------------------------------------------------------------------------
SET mapreduce.output.fileoutputformat.compress=true;
SET mapreduce.output.fileoutputformat.compress.codec=org.apache.hadoop.io.compress.SnappyCodec;
c.使用Hive的表属性进行压缩
SET hive.exec.compress.output=true;
SET hive.exec.compress.intermediate=true;
SET hive.intermediate.compression.codec=org.apache.hadoop.io.compress.SnappyCodec;
SET hive.exec.dynamic.partition.mode=nonstrict;
这些设置将确保在Hive的MapReduce任务中启用压缩，从而减少中间数据和最终结果的数据量。
d.使用Hive的表属性
为了使得数据存储在表中时进行压缩，可以使用表属性：
ALTER TABLE my_table SET FILEFORMAT ORC;
ORC（Optimized Row Columnar）格式支持高效的压缩和读取性能。
l.HQL优化
列裁剪：只选择需要的列以减少数据扫描量。
分区裁剪：在查询中利用分区信息来减少扫描的数据量。
合理设置 Reduce 的数量：调整 Reducer 数量以提高资源利用率。
Job 并行运行设置：允许多个作业并行运行以提高效率。
小文件优化：合并小文件减少 NameNode 负担。
JOIN 操作优化：选择合适的 JOIN 类型和顺序以提高性能。
SMBJoin：使用桶表进行高效的 JOIN 操作。
数据倾斜优化：解决数据不均匀分布问题，提高查询性能。
01.常用1
a.数据库
create database if not exists test; --数据库创建
show databases; --数据库列表
use test; --数据库使用
desc database extended myhive; --显示数据库的详细属性信息
select current_database(); --查看正在使用哪个库
show create database mydb; --查看创建库的详细语句
b.表
a.创建
create table if not exists employee ( --创建新表
Name String comment ‘Employee Name’,
Id int,
MobileNumber String,
Salary Float
);
b.查看
show tables; --查看当前库的所有表
desc stu; --查看表名
show create table internal_student;
DESCRIBE FORMATTED student_hive;
c.语法
ALTER TABLE TableName RENAME TO new_name
ALTER TABLE TableName ADD COLUMNS (col_spec[, col_spec ...])
ALTER TABLE TableName DROP [COLUMN] column_name
ALTER TABLE TableName CHANGE column_name new_name new_type
ALTER TABLE TableName REPLACE COLUMNS (col_spec[, col_spec ...])
d.修改表名，修改列名
ALTER TABLE employee RENAME TO demo1;
e.修改表属性
alter table table_name set TBLPROPERTIES ('comment' = 'my new students table');
f.修改SerDe信息
alter table student set SERDEPROPERTIES ('field.delim' = '-'); --
g.增加/删除/改变/替换列
alter table student add columns (course string);alter table student change column id ids int;alter tsble student replace columns (id int,name string,address string);
h.增加/修改/删除分区
a.添加分区，不指定分区路径，默认路径
ALTER TABLE student ADD partition(part='a') partition(part='b');
b.添加分区，指定分区路径
ALTER TABLE student ADD IF NOT EXISTS partition(part='bb') location '/myhive_bb' partition(part='cc') location '/myhive_cc';
c.修改分区路径示例
ALTER TABLE student partition (part='bb') SET location '/myhive_bbbbb';
d.删除分区示例
ALTER TABLE student DROP if exists partition(part='aa');ALTER TABLE student DROP if exists partition(part='aa') if exists partition(part='bb');
e.注意
最后补充：
1.防止分区被删除：alter table student_p partition (part='aa') enable no_drop;
2.防止分区被查询：alter table student_p partition (part='aa') enable offline; enable 和 disable 是反向操作
c.删除
a.语法1
drop table student_hive;
-------------------------------------------------------------------------------------------------
drop database if exists 库名; --删除库
drop table if exists 表名; --删除表
-------------------------------------------------------------------------------------------------
外部表不支持使用TRUNCATE语句
truncate table 表名; --清空表
truncate table 表名 partition(city='beijing'); --清空表（某个分区）
b.语法2
默认情况下，hive 不允许删除包含表的数据库，有两种解决办法：
1.手动删除库下所有表，然后删除库
2.使用 cascade 关键字，drop database if exists dbname cascade; --默认restrict
-------------------------------------------------------------------------------------------------
drop database if exists myhive ==== drop database if exists myhive restrict --默认restrict
d.其他辅助命令
a.查看数据库列表
show databases;
show databases like 'my*';
b.查看数据表
show tables;
show tables in myhive；
c.查看数据表的建表语句
show create table student；
d.查看hive函数列表
show funcations;
e.查看hive表分区
show partitions student;
show partitions student partition(city='shanghai');
f.查看表的详细信息（元数据信息）
desc student;
desc extended student;
desc formatted student;
g.查看数据库的详细属性
desc database student；
desc database extended student;
h.清空数据表
truncate table student;
02.常用2
a.临时生效，退出hive后失效
set hive.cli.print.current.db=true; --显示数据库名，该参数默认值为false
set hive.cli.print.header=true; --显示列名，该设置会显示表名.列名，默认值为false
set hive.resultset.use.unique.column.names=false; --不显示表名，默认值为true
b.load加载数据
load data inpath '/user.txt' into table t_user; --导入HDFS数据
load data local inpath '/home/hadoop/user.txt' into table t_user; --导入本地数据
c.DQL
Select 查询数据Hive 中的 SELECT 基础语法和标准 SQL 语法基本一致，支持 WHERE、DISTINCT、GROUP BY、ORDER BY、HAVING、LIMIT、子查询等；
select * from db.table1
select count(distinct uid) from db.table1
支持 select、union all、join（left、right、full join）、like、where、having、各种聚合函数、支持 json 解析
UDF（User Defined Function）/ UDAF/UDTF
-----------------------------------------------------------------------------------------------------
hive虽然支持 in/exists（老版本是不支持的），但是 hive 推荐使用 semi join 的方式来代替实现，而且效率更高。
支持 case … when …
-----------------------------------------------------------------------------------------------------
默认不开启事务（不支持update和delete）
内部表开启事务（支持update和delete）
外部表不支持事务（不支持支持update和delete）
hive操作hbase（因HBase不支持Hive的ACID特性，因此不能通过Hive对HBase表进行事务管理）
d.DML
SELECT * FROM OMS_DATACENTER.SG_CON_PWRGRID_F_BALANCE_RESULT_WEEK;
-----------------------------------------------------------------------------------------------------
INSERT INTO MW_APP.MWT_UD_ZJCNXM2222 (OBJ_ID,OBJ_DISPIDX,sfysb,sf,bwdydj,zt,rq) VALUES( MW_SYS.NEWGUID(),'0','未上报','1111','10kV','111','2023-10-01');
INSERT INTO OMS_DATACENTER.SG_CON_PWRGRID_F_BALANCE_RESULT_WEEK (ID, DATASOURCE_ID, DATA_DATE, UPDATE_DATE) VALUES (SUBSTR(SYS_GUID(),0,18), '0021140000', TO_DATE('2022-06-01', 'yyyy-MM-dd'), NOW());
-----------------------------------------------------------------------------------------------------
UPDATE MW_APP.MWT_UD_TXJXP SET STATE='待办';
UPDATE MW_APP.MWT_UD_TXFXYJDGL SET LCZT='已发送' WHERE OBJ_ID = '408DE45D-D5DA-4EDE-9E22-FD35BCF2DA9D-00016';
UPDATE MW_APP.NR_OMS_ZPTH_JHCTB_T2 SET WKV = '1',EKV = '2',YKV = '3',SKV = '4',TKV = '5' WHERE RQ = '2024-05-13' AND DQ = '太原';
-----------------------------------------------------------------------------------------------------
DELETE FROM MW_APP.MWT_UD_ZYCNXM WHERE OBJ_ID = '467DBE40-B8B8-43D3-8A67-5E6764CF6D3D-00001';
TRUNCATE TABLE MW_APP.MWT_UD_TXJXSB;
DROP TABLE OMS_DATACENTER.DSS_JZZT_20240219;
e.Join查询
a.介绍
Hive 支持等值连接（equality join）、外连接（outer join）和（left/right join）。Hive 不支持非等值的连接，
因为非等值连接非常难转化到 map/reduce 任务。另外，Hive 支持多于 2 个表的连接。
b.只支持等值链接，支持 and，不支持 or
例如：SELECT a.* FROM a JOIN b ON (a.id = b.id)
SELECT a.* FROM a JOIN b ON (a.id = b.id AND a.department = b.department)是正确的；
然而：SELECT a.* FROM a JOIN b ON (a.id>b.id)是错误的。
c.可以 join 多于 2 个表
例如：SELECT a.val, b.val, c.val FROM a JOIN b ON (a.key = b.key1) JOIN c ON (c.key = b.key2)
如果 join 中多个表的 join key 是同一个，则 join 会被转化为单个 map/reduce 任务，
例如：SELECT a.val, b.val, c.val FROM a JOIN b ON (a.key = b.key1) JOIN c ON (c.key = b.key1)被转化为单个 map/reduce 任务，因为 join 中只使用了 b.key1 作为 join key。
例如：SELECT a.val, b.val, c.val FROM a JOIN b ON (a.key = b.key1) JOIN c ON (c.key = b.key2),而这一 join 被转化为 2 个 map/reduce 任务。因为 b.key1 用于第一次 join 条件，而b.key2 用于第二次 join。
d.Join 时，每次 map/reduce 任务的逻辑
reducer 会缓存 join 序列中除了最后一个表的所有表的记录，再通过最后一个表将结果序列化到文件系统。
这一实现有助于在 reduce 端减少内存的使用量。实践中，应该把最大的那个表写在最后（否则会因为缓存浪费大量内存）。
例如：SELECT a.val, b.val, c.val FROM a JOIN b ON (a.key = b.key1) JOIN c ON (c.key = b.key1)所有表都使用同一个 join key（使用 1 次 map/reduce 任务计算）。
-------------------------------------------------------------------------------------------------
Reduce 端会缓存 a 表和 b 表的记录，然后每次取得一个 c 表的记录就计算一次 join 结果，
类似的还有：SELECT a.val, b.val, c.val FROM a JOIN b ON (a.key = b.key1) JOIN c ON (c.key = b.key2)
这里用了 2 次 map/reduce 任务：第一次缓存 a 表，用 b 表序列化；
第二次缓存第一次 map/reduce 任务的结果，然后用 c 表序列化。
e.HiveJoin 分三种：inner join, outer join, semi join
其中：outer join 包括 left join，right join 和 full outer join，主要用来处理 join 中空记录的情况
03.视图
a.语法
CREATE VIEW [IF NOT EXISTS] view_name [(column_name [COMMENT column_comment], …) ]
[COMMENT table_comment]
AS SELECT …
b.示例
CREATE VIEW emp_40000 AS SELECT * FROM employee WHERE salary>40000
c.删除
DROP VIEW view_name
04.UDF函数
a.介绍
UDF 分为两大类：UDAF（用户自定义聚合函数）和 UDTF（用户自定义表生成函数）
b.接口
Hive 有两个不同的接口编写 UDF 程序。一个是基础的 UDF 接口，一个是复杂的 GenericUDF 接口。
-----------------------------------------------------------------------------------------------------
org.apache.hadoop.hive.ql. exec.UDF
基础 UDF 的函数读取和返回基本类型，即 Hadoop 和 Hive 的基本类型。如 Text、IntWritable、LongWritable、DoubleWritable 等。
-----------------------------------------------------------------------------------------------------
org.apache.hadoop.hive.ql.udf.generic.GenericUDF
复杂的 GenericUDF 可以处理 Map、List、Set 类型。
@Describtion 注解是可选的，用于对函数进行说明，其中的 FUNC 字符串表示函数名，当使用 DESCRIBE FUNCTION 命令时，替换成函数名。
@Describtion 包含三个属性：
name：用于指定Hive中的函数名。
value：用于描述函数的参数。
extended：额外的说明
05.复杂类型
a.复杂类型：STRUCT
a.介绍
在 Hive 中，STRUCT 是一种复杂类型，允许将多个字段组合在一起，形成一个类似于 C 语言中的结构体或 JSON 对象
的数据类型。STRUCT 可以包含不同的数据类型，如字符串、整数、浮点数等。使用 STRUCT 类型可以方便地存储和访
问多字段的数据
b.创建包含 STRUCT 的表
我们创建一个包含 STRUCT 类型的表 users，其中 info 字段使用 STRUCT 来存储用户的姓名、年龄和地址。
-------------------------------------------------------------------------------------------------
CREATE TABLE users (
id INT,
info STRUCT<name: STRING, age: INT, address: STRING>
)
CLUSTERED BY (id) INTO 4 BUCKETS
STORED AS ORC
TBLPROPERTIES ('transactional'='true');
c.插入数据
INSERT INTO users VALUES (1, named_struct('name', '张三', 'age', 25, 'address', '北京市')), (2, named_struct('name', '李四', 'age', 30, 'address', '上海市'));
d.查询数据
SELECT * FROM users;
SELECT info.name, info.address FROM users;
e.修改数据
UPDATE users SET info = named_struct('name', info.name, 'age', info.age, 'address', '广州市') WHERE id = 1;
f.删除数据
DELETE FROM users WHERE id = 1;
g.清空表
DROP TABLE users;
b.复杂类型：ARRAY
a.介绍
在 Hive 中，ARRAY 是一种复杂类型，用于存储多个同类型的元素。可以使用 ARRAY 来表示列表或集合类型的数据，
这在处理结构化且重复的数据时非常有用。以下是如何在 Hive 中使用 ARRAY 类型的详细示例，包括如何创建带
事务的表，以及插入、删除、更新和查询操作。
b.创建带事务的 ARRAY 类型表
-- 创建一个带事务支持的表，使用 ORC 格式，并分桶
CREATE TABLE students (
student_id INT,
courses ARRAY<STRING>
)
CLUSTERED BY (student_id) INTO 4 BUCKETS
STORED AS ORC
TBLPROPERTIES ('transactional'='true');
c.插入数据
使用 ARRAY 类型插入数据时，可以通过 array() 函数来构建数组。
-------------------------------------------------------------------------------------------------
-- 插入数据，使用 array() 函数构造课程列表
INSERT INTO students VALUES
(1, array('Math', 'Science', 'English')),
(2, array('History', 'Math', 'Physics')),
(3, array('Biology', 'Chemistry'));
d.查询数据
查询 ARRAY 类型的数据可以通过索引访问元素，索引从 0 开始。
-------------------------------------------------------------------------------------------------
-- 查询所有数据
SELECT * FROM students;
-------------------------------------------------------------------------------------------------
-- 查询 student_id 为 1 的学生的第一门课程
SELECT courses[0] FROM students WHERE student_id = 1;
-------------------------------------------------------------------------------------------------
-- 查询所有学生的课程列表长度
SELECT student_id, size(courses) AS course_count FROM students;
e.更新数据
更新 ARRAY 类型的字段时，可以用 array() 函数重建数组，或者使用 CONCAT、ARRAY_REMOVE 等函数进行修改。
-- 更新 student_id 为 1 的学生的课程列表，增加一门新课程
UPDATE students SET courses = array('Math', 'Science', 'English', 'Art') WHERE student_id = 1;
-------------------------------------------------------------------------------------------------
-- 另一种更新方式，使用 CONCAT 函数添加一门课程
UPDATE students SET courses = CONCAT(courses, array('Art')) WHERE student_id = 2;
f.删除数据
-- 删除 student_id 为 3 的学生
DELETE FROM students WHERE student_id = 3;
-- 查看所有数据，验证删除和更新结果
SELECT * FROM students;
c.复杂类型：MAP
a.介绍
在 Hive 中，MAP 是一种复杂类型，用于存储键值对（key-value pairs）。MAP 可以用来表示字典或哈希表等结构，
适合用于存储一组具有唯一键的值。以下是关于 MAP 类型的详细示例，包括如何创建带事务的表，以及增、删、改、
查的操作示例。
b.创建带事务的 MAP 类型表
-- 创建一个带事务支持的表，使用 ORC 格式，并分桶
CREATE TABLE employees (
emp_id INT,
contacts MAP<STRING, STRING>
)
CLUSTERED BY (emp_id) INTO 4 BUCKETS
STORED AS ORC
TBLPROPERTIES ('transactional'='true');
c.插入数据
-- 插入数据，使用 map() 函数构建联系人信息
INSERT INTO employees VALUES
(1, map('email', 'john.doe@example.com', 'phone', '123-456-7890')),
(2, map('email', 'jane.smith@example.com', 'phone', '098-765-4321', 'skype', 'janesmith')),
(3, map('phone', '555-555-5555', 'slack', '@john'));
d.查询数据
可以通过键来访问 MAP 中的值，键是大小写敏感的。
-------------------------------------------------------------------------------------------------
-- 查询所有数据
SELECT * FROM employees;
-------------------------------------------------------------------------------------------------
-- 查询 emp_id 为 1 的员工的 email
SELECT contacts['email'] FROM employees WHERE emp_id = 1;
-------------------------------------------------------------------------------------------------
-- 查询所有员工的电话号码
SELECT emp_id, contacts['phone'] AS phone_number FROM employees;
-------------------------------------------------------------------------------------------------
-- 查询所有包含 Skype 联系方式的员工
SELECT emp_id FROM employees WHERE contacts['skype'] IS NOT NULL;
e.更新数据
更新 MAP 类型的字段时，可以使用 map() 函数重新构建，或使用 MAP_KEYS 和 MAP_VALUES 函数进行操作。
-------------------------------------------------------------------------------------------------
-- 更新 emp_id 为 1 的员工，添加 Skype 联系方式
UPDATE employees SET contacts = map('email', contacts['email'], 'phone', contacts['phone'], 'skype', 'johndoe123') WHERE emp_id = 1;
-------------------------------------------------------------------------------------------------
-- 更新 emp_id 为 2 的员工，修改电话号码
UPDATE employees SET contacts = map('email', contacts['email'], 'phone', '111-222-3333', 'skype', contacts['skype']) WHERE emp_id = 2;
f.删除数据
删除记录时，可以根据条件删除某一行。
-------------------------------------------------------------------------------------------------
-- 删除 emp_id 为 3 的员工
DELETE FROM employees WHERE emp_id = 3;
-- 查看所有数据，验证删除和更新结果
SELECT * FROM employees;
d.复杂类型：UINON
a.介绍
在 Hive 中，UNION 复杂类型（也称为 UNIONTYPE）允许一个字段存储不同的数据类型。
这种类型类似于其他编程语言中的联合体（union），但在 Hive 中应用较少，且操作略显复杂。
使用 UNIONTYPE 可以存储多种不同的数据类型，并通过指定的标签（Tag）区分存储的数据类型。
b.创建带事务的 UNIONTYPE 类型表
-- 创建一个带事务支持的表，使用 ORC 格式，并分桶
CREATE TABLE mixed_data (
id INT,
mixed_value UNIONTYPE<INT, STRING, DOUBLE>
)
CLUSTERED BY (id) INTO 4 BUCKETS
STORED AS ORC
TBLPROPERTIES ('transactional'='true');
c.插入数据
在插入数据时，可以通过 create_union() 函数指定要插入的类型和对应的值。create_union(tag, value) 函数的 tag 是从 0 开始的索引，用于指示使用哪个类型。
-------------------------------------------------------------------------------------------------
-- 插入数据，使用 create_union() 函数构造 UNIONTYPE
INSERT INTO mixed_data VALUES
(1, create_union(0, 123)), -- 插入整数
(2, create_union(1, 'Hello World')), -- 插入字符串
(3, create_union(2, 45.67)); -- 插入双精度浮点数
d.查询数据
查询 UNIONTYPE 类型的数据时，可以使用 CASE 语句配合 TAG() 和 FIELD() 函数获取特定类型的值。
-------------------------------------------------------------------------------------------------
-- 查询所有数据
SELECT * FROM mixed_data;
-------------------------------------------------------------------------------------------------
-- 查询并显示 mixed_value 的具体值，根据类型判断
SELECT
id,
CASE TAG(mixed_value)
WHEN 0 THEN FIELD(mixed_value, 0) -- 返回 INT 类型
WHEN 1 THEN FIELD(mixed_value, 1) -- 返回 STRING 类型
WHEN 2 THEN FIELD(mixed_value, 2) -- 返回 DOUBLE 类型
END AS actual_value
FROM mixed_data;
e.更新数据
更新 UNIONTYPE 类型的字段时，需要使用 create_union() 重新构建数据。
-------------------------------------------------------------------------------------------------
-- 更新 id 为 1 的记录，将 mixed_value 更新为字符串
UPDATE mixed_data SET mixed_value = create_union(1, 'Updated String') WHERE id = 1;
-------------------------------------------------------------------------------------------------
-- 更新 id 为 2 的记录，将 mixed_value 更新为双精度浮点数
UPDATE mixed_data SET mixed_value = create_union(2, 99.99) WHERE id = 2;
f.删除数据
-- 删除 id 为 3 的记录
DELETE FROM mixed_data WHERE id = 3;
-------------------------------------------------------------------------------------------------
-- 查看所有数据，验证删除和更新结果
SELECT
id,
CASE TAG(mixed_value)
WHEN 0 THEN FIELD(mixed_value, 0)
WHEN 1 THEN FIELD(mixed_value, 1)
WHEN 2 THEN FIELD(mixed_value, 2)
END AS actual_value
FROM mixed_data;
06.语法：insert overwrite
a.介绍
INSERT OVERWRITE 是 Hive 中用于重写目标表或分区数据的一个常用操作。与 INSERT INTO 不同，INSERT OVERWRITE
会删除目标位置现有的数据，并用新数据替代。这个操作特别适用于重新计算或更新整个表或分区的数据。
b.示例
a.创建示例表
-- 创建一个普通的员工信息表，不需要事务支持
CREATE TABLE employee_data (
emp_id INT,
name STRING,
department STRING
)
STORED AS ORC;
b.插入初始数据
-- 插入初始数据
INSERT INTO employee_data VALUES
(1, 'John Doe', 'Sales'),
(2, 'Jane Smith', 'Marketing'),
(3, 'Sam Brown', 'Engineering');
c.使用 INSERT OVERWRITE 操作
使用 INSERT OVERWRITE 语句重写表中的数据。假设我们要更新员工信息，可能由于业务变更，重新调整了部门信息或其他数据。
-------------------------------------------------------------------------------------------------
-- 使用 INSERT OVERWRITE 重写整个表的数据
INSERT OVERWRITE TABLE employee_data
SELECT
emp_id,
name,
CASE
WHEN department = 'Sales' THEN 'Business Development'
WHEN department = 'Marketing' THEN 'Public Relations'
ELSE department
END AS department
FROM employee_data;
-------------------------------------------------------------------------------------------------
这个操作将：将原有数据中的部门信息更新，例如将 Sales 更新为 Business Development。替换掉原表中的数据。
d.查询结果
-- 查询表数据，验证 INSERT OVERWRITE 的结果
SELECT * FROM employee_data;
-------------------------------------------------------------------------------------------------
+--------+-----------+-----------------------+
| emp_id | name | department |
+--------+-----------+-----------------------+
| 1 | John Doe | Business Development |
| 2 | Jane Smith| Public Relations |
| 3 | Sam Brown | Engineering |
+--------+-----------+-----------------------+
c.场景
a.重写表数据
用于清除并替换现有的数据。
b.重写分区数据：可以用 INSERT OVERWRITE 对特定分区进行覆盖。
-- 重写表中 department='Sales' 分区的数据
INSERT OVERWRITE TABLE employee_data PARTITION (department='Sales')
SELECT emp_id, name FROM employee_data WHERE department='Sales';
c.导出到外部文件：将查询结果直接导出到指定的 HDFS 目录中。
-- 导出查询结果到指定的 HDFS 目录
INSERT OVERWRITE DIRECTORY '/user/hive/warehouse/employee_output'
SELECT * FROM employee_data;
07.语法：merge into
a.介绍
Hive在2.2版本之后开始支持Merge操作，并且Merge只能在支持ACID的表上执行
-----------------------------------------------------------------------------------------------------
MERGE INTO target_table AS target
USING source_table AS source
ON (condition)
WHEN MATCHED THEN
UPDATE SET target.column1 = source.column1, target.column2 = source.column2
WHEN NOT MATCHED THEN
INSERT (column1, column2) VALUES (source.column1, source.column2);
b.创建事务表
-- 创建目标表，启用事务
CREATE TABLE employee_target (
emp_id INT,
name STRING,
department STRING
)
CLUSTERED BY (emp_id) INTO 4 BUCKETS
STORED AS ORC
TBLPROPERTIES ('transactional'='true');
-----------------------------------------------------------------------------------------------------
-- 创建源表，源表通常不需要事务支持
CREATE TABLE employee_source (
emp_id INT,
name STRING,
department STRING
)
STORED AS ORC;
c.插入初始数据
-- 插入数据到目标表
INSERT INTO employee_target VALUES
(1, 'John Doe', 'Sales'),
(2, 'Jane Smith', 'Marketing');
-----------------------------------------------------------------------------------------------------
-- 插入数据到源表
INSERT INTO employee_source VALUES
(1, 'John Doe', 'Business Development'), -- 更新部门信息
(3, 'Sam Brown', 'Engineering'); -- 新员工
d.使用 MERGE INTO 语法
MERGE INTO employee_target AS target
USING employee_source AS source
ON target.emp_id = source.emp_id
WHEN MATCHED THEN
UPDATE SET target.name = source.name,target.department = source.department
WHEN NOT MATCHED THEN
INSERT (emp_id, name, department) VALUES (source.emp_id, source.name, source.department);
e.查询结果
-- 查询目标表
SELECT * FROM employee_target;
-----------------------------------------------------------------------------------------------------
+--------+-----------+------------------------+
| emp_id | name | department |
+--------+-----------+------------------------+
| 1 | John Doe | Business Development |
| 2 | Jane Smith| Marketing |
| 3 | Sam Brown | Engineering |
+--------+-----------+------------------------+
08.SELECT语法
a.语法
SELECT [ALL | DISTINCT] select_expr, select_expr, ...
FROM table_reference
[WHERE where_condition]
[GROUP BY col_list]
[ORDER BY col_list]
[CLUSTER BY col_list | [DISTRIBUTE BY col_list] [SORT BY col_list] ]
[LIMIT number]
b.Map阶段
1.执行from加载，进行表的查找与加载
2.执行where过滤，进行条件过滤与筛选
3.执行select查询：进行输出项的筛选
4.执行group by分组：描述了分组后需要计算的函数
5.map端文件合并：map端本地溢出写文件的合并操作，每个map最终形成一个临时文件。然后按列映射到对应的Reduce阶段：
c.Reduce阶段
1.group by：对map端发送过来的数据进行分组并进行计算。
2.select：最后过滤列用于输出结果
3.limit排序后进行结果输出到HDFS文件
09.排序
a.ORDER BY
a.介绍
ORDER BY 用于对全局数据进行排序。这意味着所有数据在被输出之前都必须在一个 reducer 中进行排序，
因此通常会导致只有一个 reducer 被使用。此操作通常是资源密集型的，因为它需要将所有数据聚集到一
个节点上进行排序。
b.示例
-- 全局排序，所有数据都将被汇总到一个 reducer 中
SELECT * FROM sales
ORDER BY amount;
-------------------------------------------------------------------------------------------------
注意：在 Hive 的 hive.mapred.mode 设置为 strict 时，ORDER BY 语句必须与 LIMIT 一起使用，否则会报错。
-- 在 strict 模式下，必须使用 LIMIT
SELECT * FROM sales
ORDER BY amount
LIMIT 10;
b.SORT BY
a.介绍
SORT BY 用于对每个 reducer 的数据进行排序，而不是对全局数据排序。每个 reducer 将对它自己的数据进行排序，
因此如果使用多个 reducers，排序只会在每个 reducer 的输出中进行，而不是全局排序。
b.示例
-- 每个 reducer 中的数据会被排序，但不会保证全局排序
SELECT * FROM sales
SORT BY amount;
c.DISTRIBUTE BY
a.介绍
DISTRIBUTE BY 用于将数据分配到不同的 reducers 中。
与 CLUSTER BY 类似，它将数据根据指定的列分配到不同的 reducers，
但是 DISTRIBUTE BY 不会对数据进行排序，只会将数据分配到不同的 reducers。
b.示例
-- 根据指定的字段将数据分配到不同的 reducers 中
SELECT * FROM sales
DISTRIBUTE BY department;
在这个示例中，所有拥有相同 department 值的记录将会被分配到同一个 reducer 中。
d.CLUSTER BY
a.介绍
CLUSTER BY 结合了 DISTRIBUTE BY 和 SORT BY。首先，它根据指定的列将数据分配到不同的 reducers 中，
然后在每个 reducer 内对数据进行排序。请注意，CLUSTER BY 不能指定排序顺序（ASC 或 DESC），默认是升序（ASC）。
b.示例
-- 根据指定的字段将数据分配到不同的 reducers，并在每个 reducer 中排序
SELECT * FROM sales
CLUSTER BY department;
在这个示例中，所有具有相同 department 值的记录会被分配到同一个 reducer 中，并且在 reducer 内部数据会按升序排序。
e.总结
ORDER BY 全局排序：对全局数据进行排序，通常只使用一个 reducer。
SORT BY 每个Reduce内部排序：对每个 reducer 的数据进行排序，不保证全局排序。
DISTRIBUTE BY 分区：根据指定字段将数据分配到不同的 reducers，不进行排序。
CLUSTER BY 分区排序：结合了 DISTRIBUTE BY 和 SORT BY，将数据分配到 reducers 中，并在每个 reducer 内部进行排序。
10.窗口函数
a.OVER 子句
a.介绍
OVER 子句是窗口函数的核心部分，它定义了窗口函数的操作范围（即“窗口”）。
你可以在 OVER 子句中指定窗口的分区和排序规则。
b.示例
SELECT
emp_id,
amount,
SUM(amount) OVER (PARTITION BY department ORDER BY amount) AS running_total
FROM sales;
在这个示例中，SUM(amount) 是一个窗口函数，PARTITION BY department 指定了分区，ORDER BY amount 指定了排序。
b.序列函数
a.介绍
序列函数是窗口函数的一类，用于生成序列或排名。最常用的序列函数包括 ROW_NUMBER()、RANK() 和 DENSE_RANK()。
b.ROW_NUMBER()
ROW_NUMBER() 函数为每一行分配一个唯一的序列号，基于窗口函数中的排序规则。每个分区内的行号从 1 开始递增。
-------------------------------------------------------------------------------------------------
SELECT
emp_id,
name,
department,
ROW_NUMBER() OVER (PARTITION BY department ORDER BY amount DESC) AS row_num
FROM sales;
在这个示例中，ROW_NUMBER() 为每个部门的员工按 amount 降序排列，并为每个部门内的员工分配一个唯一的行号。
c.比较 ROW_NUMBER()、RANK() 和 DENSE_RANK()
ROW_NUMBER()：为每行分配一个唯一的顺序号。
RANK()：为每行分配排名，存在并列时排名相同，但排名之后的排名会跳过。
DENSE_RANK()：为每行分配排名，存在并列时排名相同，但排名之后的排名不会跳过。
-------------------------------------------------------------------------------------------------
SELECT
emp_id,
name,
department,
amount,
ROW_NUMBER() OVER (PARTITION BY department ORDER BY amount DESC) AS row_num,
RANK() OVER (PARTITION BY department ORDER BY amount DESC) AS rank,
DENSE_RANK() OVER (PARTITION BY department ORDER BY amount DESC) AS dense_rank
FROM sales;
在这个示例中，ROW_NUMBER()、RANK() 和 DENSE_RANK() 对于每个部门的员工按 amount 降序排序进行排名。
c.窗口函数示例
a.计算运行总和
SELECT
emp_id,
amount,
SUM(amount) OVER (PARTITION BY department ORDER BY amount) AS running_total
FROM sales;
在这个示例中，SUM(amount) OVER (PARTITION BY department ORDER BY amount) 计算了在每个部门内，按 amount 排序后的累计总和。
b.计算移动平均
SELECT
emp_id,
amount,
AVG(amount) OVER (PARTITION BY department ORDER BY amount ROWS BETWEEN 2 PRECEDING AND CURRENT ROW) AS moving_avg
FROM sales;
在这个示例中，AVG(amount) OVER (PARTITION BY department ORDER BY amount ROWS BETWEEN 2 PRECEDING AND CURRENT ROW) 计算了当前行及前两行的平均值，即移动平均。
c.计算累积百分比
SELECT
emp_id,
amount,
PERCENT_RANK() OVER (PARTITION BY department ORDER BY amount) AS pct_rank
FROM sales;
在这个示例中，PERCENT_RANK() 计算了每个员工在其部门中的相对排名百分比。
11.文件格式和压缩
a.文件格式
a.Text File
文本文件是Hive默认使用的文件格式，文本文件中的一行内容，就对应Hive表中的一行记录。
create table textfile_table
(column_specs)
stored as textfile;
b.ORC
ORC（Optimized Row Columnar）file format是Hive 0.11版里引入的一种列式存储的文件格式。
ORC文件能够提高Hive读写数据和处理数据的性能。
（1）行存储的特点
查询满足条件的一整行数据的时候，列存储则需要去每个聚集的字段找到对应的每个列的值，行存储只需要找到其中一个值，其余的值都在相邻地方，所以此时行存储查询的速度更快。
（2）列存储的特点
因为每个字段的数据聚集存储，在查询只需要少数几个字段的时候，能大大减少读取的数据量；每个字段的数据类型一定是相同的，列式存储可以针对性的设计更好的设计压缩算法。
前文提到的text file和sequence file都是基于行存储的，orc和parquet是基于列式存储的。
c.Parquet
Parquet文件是Hadoop生态中的一个通用的文件格式，它也是一个列式存储的文件格式。
每个Row Group包含多个Column Chunk，每个Column Chunk包含多个Page。以下是Row Group、Column Chunk和Page三个概念的说明：
行组（Row Group）：一个行组对应逻辑表中的若干行。
列块（Column Chunk）：一个行组中的一列保存在一个列块中。
页（Page）：一个列块的数据会划分为若干个页。
Footer（File Meta Data）中存储了每个行组（Row Group）中的每个列快（Column Chunk）的元数据信息，元数据信息包含了该列的数据类型、该列的编码方式、该类的Data Page位置等信息。
b.压缩
a.介绍
压缩格式 算法 文件扩展名 是否可切分
DEFLATE DEFLATE .deflate 否
Gzip DEFLATE .gz 否
bzip2 bzip2 .bz2 是
LZO LZO .lzo 是
Snappy Snappy .snappy 否
b.Hadoop在driver端设置压缩
压缩格式 对应的编码/解码器
DEFLATE org.apache.hadoop.io.compress.DefaultCodec
gzip org.apache.hadoop.io.compress.GzipCodec
bzip2 org.apache.hadoop.io.compress.BZip2Codec
LZO com.hadoop.compression.lzo.LzopCodec
Snappy org.apache.hadoop.io.compress.SnappyCodec
c.压缩性能的比较
压缩算法 原始文件大小 压缩文件大小 压缩速度 解压速度
gzip 8.3GB 1.8GB 17.5MB/s 58MB/s
bzip2 8.3GB 1.1GB 2.4MB/s 9.5MB/s
LZO 8.3GB 2.9GB 49.3MB/s 74.6MB/s
c.示例
a.表的压缩设置
CREATE TABLE my_table (
id INT,
name STRING
)
STORED AS TEXTFILE
TBLPROPERTIES ("compression"="gzip");
-------------------------------------------------------------------------------------------------
修改表的压缩设置：
ALTER TABLE my_table SET TBLPROPERTIES ('compression'='snappy');
b.计算过程中的压缩
计算过程中可以通过以下设置来启用压缩：
MapReduce任务压缩设置： 修改Hive配置文件（如hive-site.xml）或在Hive查询中设置：
-------------------------------------------------------------------------------------------------
SET mapreduce.output.fileoutputformat.compress=true;
SET mapreduce.output.fileoutputformat.compress.codec=org.apache.hadoop.io.compress.SnappyCodec;
c.使用Hive的表属性进行压缩
SET hive.exec.compress.output=true;
SET hive.exec.compress.intermediate=true;
SET hive.intermediate.compression.codec=org.apache.hadoop.io.compress.SnappyCodec;
SET hive.exec.dynamic.partition.mode=nonstrict;
这些设置将确保在Hive的MapReduce任务中启用压缩，从而减少中间数据和最终结果的数据量。
d.使用Hive的表属性
为了使得数据存储在表中时进行压缩，可以使用表属性：
ALTER TABLE my_table SET FILEFORMAT ORC;
ORC（Optimized Row Columnar）格式支持高效的压缩和读取性能。
12.HQL优化
a.列裁剪
a.介绍
列裁剪（Column Pruning）是指只选择需要的列来减少数据扫描量。
Hive 在查询时会自动进行列裁剪，但你在编写查询时也应尽量只选择需要的列，以提高查询效率。
b.示例
-- 只选择需要的列，减少数据扫描量
SELECT emp_id, amount
FROM sales;
b.分区裁剪
a.介绍
分区裁剪（Partition Pruning）是指在查询中利用表的分区信息来减少扫描的分区，从而提高查询效率。
在 WHERE 子句中使用分区列可以使 Hive 只扫描相关的分区。
b.示例
-- 只扫描指定的分区
SELECT *
FROM sales
WHERE year = 2023 AND month = 9;
c.合理设置 Reduce 的数量
a.介绍
合理设置 Reduce 的数量（Number of Reducers）是通过调整 Reducer 的数量来优化作业的性能。
Reducer 的数量通常与集群的资源和数据的规模有关。设置过少的 Reducers 可能导致负载不均衡，
而设置过多的 Reducers 可能导致资源浪费。
b.示例
-- 设置 Reduce 的数量
SET mapreduce.job.reduces=10;
d.Job 并行运行设置
a.介绍
Job 并行运行设置（Parallel Execution）允许 Hive 同时执行多个作业，以提高作业的执行速度。
合理设置可以提高资源利用率。
b.示例
-- 设置最大并行作业数
SET hive.exec.parallel=true;
SET hive.exec.parallel.thread.number=8;
e.小文件的问题优化
a.介绍
小文件的问题优化（Small Files Problem）指的是减少小文件的数量，因为小文件会增加 NameNode 的负担，
影响性能。可以通过合并小文件来优化。
b.使用 INSERT OVERWRITE 合并文件
INSERT OVERWRITE DIRECTORY '/path/to/directory'
SELECT * FROM sales;
c.配置 Hive 合并小文件
SET hive.merge.smallfiles.avgsize=128000000; -- 设置合并小文件的平均大小
SET hive.merge.size.per.table=256000000; -- 设置表文件的合并大小
f.JOIN 操作优化
a.介绍
JOIN 操作优化（JOIN Optimization）通过选择合适的 JOIN 类型和优化 JOIN 的执行策略来提高性能。
常见的优化技术包括：
使用适当的 JOIN 类型（例如 MAPJOIN 或 SMBJOIN）：
避免大表与小表的笛卡尔积。
选择合适的 JOIN 顺序（使用 USE 或 JOIN 的优化提示）。
b.示例
-- 使用 MAPJOIN 提高小表 JOIN 性能
SELECT /*+ MAPJOIN(small_table) */ *
FROM large_table
JOIN small_table ON large_table.key = small_table.key;
g.SMBJoin
a.介绍
SMBJoin（Sorted Map Join）是一种优化 JOIN 操作的方法，适用于两个桶表（bucketed tables），
能够高效地处理大数据量的 JOIN 操作。
b.SMBJoin 成立的前提条件
两个表都必须是桶表。
两个表的桶数应相等。
两个表的桶列应相同。
c.两个桶表数量相等的 JOIN
在 JOIN 两个桶表时，桶数相等可以提高 JOIN 的效率，因为数据已经根据桶列进行了预排序和分区。
-- 创建桶表
CREATE TABLE table1 (key INT, value STRING)
CLUSTERED BY (key) INTO 4 BUCKETS;
CREATE TABLE table2 (key INT, value STRING)
CLUSTERED BY (key) INTO 4 BUCKETS;
-- 执行 SMBJoin
SELECT *
FROM table1 t1
JOIN table2 t2 ON t1.key = t2.key;
d.执行 SQL 看对比情况
执行 SQL 语句并查看执行计划可以帮助确认是否使用了 SMBJoin。
-- 查看执行计划
EXPLAIN SELECT * FROM table1 t1 JOIN table2 t2 ON t1.key = t2.key;
h.Hive 数据倾斜优化
a.介绍
数据倾斜优化（Data Skew Optimization）是解决数据不均匀分布问题的关键，
数据倾斜会导致部分 reducer 处理过多的数据，从而影响作业的整体性能。
b.数据倾斜的原因
数据分布不均：某些 key 的数据量过大。
大表和小表的 JOIN 导致数据集中。
c.数据倾斜的表现
某些 reducer 处理的数据量远大于其他 reducer。
作业执行时间长，某些任务的执行时间远超其他任务。
d.通用解决方案参数调节
调整 reduce 的个数：SET mapreduce.job.reduces=50;
启用 skew join：SET hive.optimize.skewjoin=true;
e.SQL 语句调节
a.使用随机采样技术
SELECT *
FROM large_table
WHERE key IN (SELECT key FROM small_table);
b.引入虚拟列减少数据倾斜
SELECT *
FROM large_table l
JOIN small_table s
ON l.key = s.key
AND (l.hash_key % 10) = (s.hash_key % 10);
g.总结
列裁剪：只选择需要的列以减少数据扫描量。
分区裁剪：在查询中利用分区信息来减少扫描的数据量。
合理设置 Reduce 的数量：调整 Reducer 数量以提高资源利用率。
Job 并行运行设置：允许多个作业并行运行以提高效率。
小文件优化：合并小文件减少 NameNode 负担。
JOIN 操作优化：选择合适的 JOIN 类型和顺序以提高性能。
SMBJoin：使用桶表进行高效的 JOIN 操作。
数据倾斜优化：解决数据不均匀分布问题，提高查询性能。
1.3 hive2：数据仓库
00.总结
a.hive创建表
a.student_internal表
CREATE TABLE student_internal (
id INT,
name STRING,
age INT
);
-------------------------------------------------------------------------------------------------
load data inpath '/user.txt' into table student_internal; --导入HDFS数据
load data local inpath '/home/hadoop/user.txt' into table student_internal; --导入本地数据
b.student_external表
CREATE EXTERNAL TABLE student_external (
id INT,
name STRING,
age INT
)
ROW FORMAT DELIMITED
FIELDS TERMINATED BY ','
STORED AS TEXTFILE
LOCATION '/user/hive/external/student_external';
c.mydb.dept 表
CREATE TABLE `mydb.dept`(
`dept_no` INT,
`addr` STRING,
`tel` STRING
)
PARTITIONED BY (date STRING)
ROW FORMAT DELIMITED FIELDS TERMINATED BY ',';
d.temp_salary_hive 表
CREATE EXTERNAL TABLE temp_salary_hive (
salary_id STRING,
id INT,
salary INT
)
ROW FORMAT DELIMITED
FIELDS TERMINATED BY '\t';
e.默认分隔符
表名称 表类型 默认分隔符
internal_student 内部表 ASCII 1 (\u0001 或 ^A)
student_external 外部表 逗号（,）
mydb.dept 内部分区表 逗号（,）
temp_salary_hive 外部表 制表符（\t）
f.查看表结构
方式1：DESCRIBE FORMATTED student_hive; --查看col_name下的Table Type
方式2：SELECT TBL_NAME, TBL_TYPE FROM TBLS WHERE TBL_NAME = 'student_hive';
方式3：show create table internal_student;
g.创建表方式
a.使用create命令创建一个新表，带分区
CREATE TABLE `mydb.dept`(
`dept_no` int,
`addr` string,
`tel` string)
partitioned by(date string)
ROW FORMAT DELIMITED FIELDS TERMINATED BY ',';
b.把一张表的某些字段抽取出来，创建成一张新表，使用as
create table mytest_tmp1 as select * from FDM_SOR.mytest_deptaddr where statis_date='20180229';
---------------------------------------------------------------------------------------------
1.as只会复制属性以及属性值到新的表中
2.使用as创建的表，并不会带原表的分区（分区丢失），包括一些字段的约束等（可以通过describe formatted查看）
3.新表中会将原表的分区当做字段出现在新表中
c.复制表结构，使用like创建表
create table mytest_tmp like FDM_SOR.mytest_deptaddr;
---------------------------------------------------------------------------------------------
注意：不会复制表中属性值，只会复制表结构（包括表的分区以及存储格式之类的，区别as）
d.迁移数据
INSERT INTO TABLE internal_student SELECT * FROM temp_student;
b.hive创建表到hbase
a.内部表
hive创建逻辑表后，自动会在hbase创建物理表
-------------------------------------------------------------------------------------------------
create table student_hive(id int,name string,age int)
STORED BY 'org.apache.hadoop.hive.hbase.HBaseStorageHandler'
WITH SERDEPROPERTIES ("hbase.columns.mapping" = ":key,info:name,info:age")
TBLPROPERTIES ("hbase.table.name" = "student");
b.外部表
hbase创建物理表后，然后在hive创建逻辑表映射过去
-------------------------------------------------------------------------------------------------
create 'salary','info'
create external table salary_hive(salary_id string,id int,salary int)
STORED BY 'org.apache.hadoop.hive.hbase.HBaseStorageHandler'
WITH SERDEPROPERTIES ("hbase.columns.mapping" = ":key,info:id,info:salary")
TBLPROPERTIES ("hbase.table.name" = "salary");
c.hive创建表到hdfs
a.内部表
CREATE TABLE managed_table (dummy STRING);
-------------------------------------------------------------------------------------------------
LOAD DATA INPATH '/workspace/hive/managed_table.txt' INTO table managed_table;
执行后，/workspace/hive/managed_table.txt 移动到 /user/hive/warehouse/managed_table/managed_table.txt，源文件删除
-------------------------------------------------------------------------------------------------
DROP TABLE managed_table;
经测试，hive内部表结构全部删除，user/hive/warehouse/managed_table删除
b.外部表
CREATE EXTERNAL TABLE external_table (dummy STRING);
-------------------------------------------------------------------------------------------------
LOAD DATA INPATH '/workspace/hive/external_table2.txt' INTO TABLE external_table;
执行后，/workspace/hive/external_table.txt 移动到 /user/hive/warehouse/external_table/external_table.txt，源文件删除
-------------------------------------------------------------------------------------------------
DROP TABLE external_table;
经测试，hive内部表结构全部删除，user/hive/warehouse/external_table不会删除
-------------------------------------------------------------------------------------------------
hadoop fs -ls /user/hive/warehouse
hadoop fs -rm -r /user/hive/warehouse/external_table
手动删除
d.事务
a.示例
CREATE TABLE internal_student (
id INT,
name STRING,
age INT
)
STORED AS ORC
TBLPROPERTIES ('transactional'='true');
b.内部表
新增数据后，/user/hive/warehouse/internal_student文件有如下变化
从
空文件夹
新增到
delta_0000001_0000001_0000文件夹
c.外部表
新增数据后，/user/hive/warehouse/external_student文件有如下变化
从
external_student1.txt
external_student2.txt
新增到
000000_0 -> 存10,zhangsan,20
external_student1.txt
external_student2.txt
d.说明
默认不开启事务（不支持update和delete）
内部表开启事务（支持update和delete）
外部表不支持事务（不支持支持update和delete）
hive操作hbase（因HBase不支持Hive的ACID特性，因此不能通过Hive对HBase表进行事务管理）
e.将数据写入文件系统
a.将数据写入一个文件
a.使用 INSERT OVERWRITE DIRECTORY
-- 将查询结果写入到 HDFS 目录
INSERT OVERWRITE DIRECTORY '/user/hive/warehouse/sales_export'
ROW FORMAT DELIMITED
FIELDS TERMINATED BY ','
SELECT * FROM sales;
b.将结果复制到本地文件系统
# 从 HDFS 复制结果到本地文件系统
hadoop fs -get /user/hive/warehouse/sales_export /local/path/sales_export
b.将数据写入多个文件
a.使用 INSERT OVERWRITE DIRECTORY 导出到多个文件
-- 将查询结果写入到 HDFS 目录中的多个文件
INSERT OVERWRITE DIRECTORY '/user/hive/warehouse/sales_export_multiple'
ROW FORMAT DELIMITED
FIELDS TERMINATED BY ','
SELECT * FROM sales;
b.列出目录中的所有文件
hadoop fs -ls /user/hive/warehouse/sales_export_multiple
c.使用 hive -e 执行命令导出
# 执行查询并将结果输出到文件
hive -e 'SELECT * FROM sales;' > /local/path/sales_result.txt
d.使用 hive -f 执行 SQL 文件导出
a.创建 export_sales.sql 文件，内容如下：
SELECT * FROM sales;
b.使用 hive -f 执行 SQL 文件并导出
hive -f export_sales.sql > /local/path/sales_result_from_sql.txt
f.创建分区表
-- 创建一个分区事务表
CREATE TABLE sales (
order_id INT,
customer_name STRING,
amount DECIMAL(10,2)
)
PARTITIONED BY (year INT, month INT) -- 分区列
CLUSTERED BY (order_id) INTO 4 BUCKETS -- 可选的分桶
STORED AS ORC
TBLPROPERTIES ('transactional'='true');
g.创建分桶表
-- 创建一个分桶事务表
CREATE TABLE employee_data (
emp_id INT,
name STRING,
department STRING
)
CLUSTERED BY (emp_id) INTO 4 BUCKETS -- 按 emp_id 分桶，分成 4 个桶
STORED AS ORC
TBLPROPERTIES ('transactional'='true');
01.hive创建表
a.创建
a.语法
create [external] table [if not exists] table_name (
col_name data_type [comment '字段描述信息']
col_name data_type [comment '字段描述信息'])
[comment '表的描述信息']
[partitioned by (col_name data_type,...)]
[clustered by (col_name,col_name,...)]
[sorted by (col_name [asc|desc],...) into num_buckets buckets]
[row format row_format]
[storted as ....]
[location '指定表的路径']
-------------------------------------------------------------------------------------------------
-- EXTERNAL 代表外部表
CREATE [EXTERNAL] TABLE [IF NOT EXISTS] table_name
[(col_name data_type [COMMENT col_comment], ...)]
[COMMENT table_comment]
-- 分区表设置 分区的字段和类型
[PARTITIONED BY (col_name data_type [COMMENT col_comment], ...)]
-- 桶表设置 按照什么字段进行分桶
[CLUSTERED BY (col_name, col_name, ...)
-- 桶内的文件 是按照 什么字段排序 分多少个桶
[SORTED BY (col_name [ASC|DESC], ...)] INTO num_buckets BUCKETS]
-- 分隔符 + 序列化反序列化
[ROW FORMAT row_format]
-- 输入输出格式
[STORED AS file_format]
-- 表所对应的hdfs目录
[LOCATION hdfs_path]
b.说明
1、CREATE TABLE
创建一个指定名字的表。如果相同名字的表已经存在，则抛出异常；
用户可以用 IF NOT EXISTS 选项来忽略这个异常。
2、EXTERNAL
可以让用户创建一个外部表，在建表的同时指定一个指向实际数据的路径（LOCATION）.Hive 创建内部表时，
会将数据移动到数据仓库指向的路径；若创建外部表，仅记录数据所在的路径，不对数据的位置做任何改变。
在删除表的时候，内部表的元数据和数据会被一起删除,而外部表只删除元数据,不删除数据.
3、LIKE
允许用户复制现有的表结构，但是不复制数据。
4、ROW FORMAT DELIMITED
是用来设置创建的表在加载数据的时候，支持的列分隔符。
Hive默认的分隔符是\001，属于不可见字符，这个字符在vi里是^A
-- 分隔符设置
-- 字段间分隔符
DELIMITED [FIELDS TERMINATED BY char]
-- 集合间分隔符
[COLLECTION ITEMS TERMINATED BY char]
-- map k v 间分隔符
[MAP KEYS TERMINATED BY char]
-- 行分隔符
[LINES TERMINATED BY char]
--序列化和反序列化设置
SERDE serde_name [WITH SERDEPROPERTIES (property_name=property_value, property_name=property_value, ...)]
5、STORED AS
SEQUENCEFILE|TEXTFILE|RCFILE
如果文件数据是纯文本，使用 STORED AS TEXTFILE
如果数据需要压缩，使用 STORED AS SEQUENCEFILE、RCFile、ORC
SEQUENCEFILE --包含键值对的二进制的文件存储格式，支持压缩，可以节省存储空间
TEXTFILE --最普通的文件存储格式，内容是可以直接查看（默认的）
AVRO --带有schema文件格式的， 一行的数据是个map，添加字段方便
RCFile --是列式存储文件格式，适合压缩处理。对于有成百上千字段的表而言，RCFile更合适。
ORC --是列式存储文件格式,带有压缩和轻量级索引, 一行数据是个数组，查询快，不适合添加字段
parquet --是列式存储文件格式,带有压缩和轻量级索引, 和orc比较类似
ORC File，它的全名是Optimized Row Columnar (ORC) file。（有索引有压缩的列式存储格式）
ORC File包含一组组的行数据，称为stripes，除此之外，ORC File的file footer还包含一些额外的辅助信息。
在ORC File文件的最后，有一个被称为postscript的区，它主要是用来存储压缩参数及压缩的大小。
在默认情况下，一个stripe的大小为256MB。大尺寸的stripes使得从HDFS读数据更高效。
6、CLUSTERED BY
对于每一个表（table）或者分区， Hive可以进一步组织成桶，也就是说桶是更为细粒度的数据范围划分。
Hive也是 针对某一列进行桶的组织。Hive采用对列值哈希，然后除以桶的个数求余的方式决定该条记录存放在哪个桶当中。
7、LOCATION
指定加载数据路径(指定在hdfs上的位置).针对的extetnal外部表，要指定存储路径，不指定也没事，默认路径。
内部表不用指定，默认路径/user/hive/warehouse，CREATE TABLE创建一个具有给定名称的表。
如果已存在具有相同名称的表或视图，则会引发错误。您可以使用IF NOT EXISTS跳过错误。
c.查看内部表还是外部表
方式1：DESCRIBE FORMATTED student_hive; --查看col_name下的Table Type
方式2：SELECT TBL_NAME, TBL_TYPE FROM TBLS WHERE TBL_NAME = 'student_hive';
方式3：show create table internal_student;
d.查看表结构
DESC salary_hive
e.load加载数据
load data inpath '/user.txt' into table t_user; --导入HDFS数据
load data local inpath '/home/hadoop/user.txt' into table t_user; --导入本地数据
b.创建表的三种方法
a.使用create命令创建一个新表，带分区
CREATE TABLE `mydb.dept`(
`dept_no` int,
`addr` string,
`tel` string)
partitioned by(date string)
ROW FORMAT DELIMITED FIELDS TERMINATED BY ',';
b.把一张表的某些字段抽取出来，创建成一张新表，使用as
create table mytest_tmp1 as select * from FDM_SOR.mytest_deptaddr where statis_date='20180229';
-------------------------------------------------------------------------------------------------
1.as只会复制属性以及属性值到新的表中
2.使用as创建的表，并不会带原表的分区（分区丢失），包括一些字段的约束等（可以通过describe formatted查看）
3.新表中会将原表的分区当做字段出现在新表中
c.复制表结构，使用like创建表
create table mytest_tmp like FDM_SOR.mytest_deptaddr;
-------------------------------------------------------------------------------------------------
注意：不会复制表中属性值，只会复制表结构（包括表的分区以及存储格式之类的，区别as）
d.迁移数据
INSERT INTO TABLE internal_student SELECT * FROM temp_student;
c.ORC格式和TXT格式
a.ORC格式
CREATE TABLE employee_orc (
emp_id INT,
name STRING,
department STRING
)
STORED AS ORC;
b.TXT格式
CREATE TABLE employee_txt (
emp_id INT,
name STRING,
department STRING
)
ROW FORMAT DELIMITED
FIELDS TERMINATED BY ','
STORED AS TEXTFILE;
c.总结
创建 ORC 表：
使用 STORED AS ORC 来创建表。
可以通过 INSERT INTO 从其他表导入数据，也可以从临时表中导入。
-------------------------------------------------------------------------------------------------
创建 TXT 格式的表：
使用 ROW FORMAT DELIMITED 和 FIELDS TERMINATED BY 指定分隔符来创建表。
使用 LOAD DATA 命令将外部 TXT 文件的数据导入到表中。
d.创建表的各种语法
a.student_internal表
CREATE TABLE student_internal (
id INT,
name STRING,
age INT
);
-------------------------------------------------------------------------------------------------
load data inpath '/user.txt' into table student_internal; --导入HDFS数据
load data local inpath '/home/hadoop/user.txt' into table student_internal; --导入本地数据
-------------------------------------------------------------------------------------------------
默认分隔符：
默认字段分隔符：Hive 默认使用控制字符 ASCII 1 (^A 或 \u0001) 作为字段分隔符。
行分隔符：默认是换行符（\n）。
-------------------------------------------------------------------------------------------------
表名称 表类型 默认分隔符
internal_student 内部表 ASCII 1 (\u0001 或 ^A)
student_external 外部表 逗号（,）
mydb.dept 内部分区表 逗号（,）
temp_salary_hive 外部表 制表符（\t）
-------------------------------------------------------------------------------------------------
默认分隔符 \u0001 是 Hive 设计的初衷，适用于大数据处理场景，避免了常见字符的冲突。
如果未指定 ROW FORMAT DELIMITED，如 internal_student，则默认采用 Hive 内部的标准分隔符。
指定分隔符时，请确保与数据格式一致，否则可能导致数据解析错误
b.student_external表
CREATE EXTERNAL TABLE student_external (
id INT,
name STRING,
age INT
)
ROW FORMAT DELIMITED
FIELDS TERMINATED BY ','
STORED AS TEXTFILE
LOCATION '/user/hive/external/student_external';
-------------------------------------------------------------------------------------------------
外部表：通过 CREATE EXTERNAL TABLE 创建，数据存储在指定的外部位置，不受 Hive 控制。
存储格式：STORED AS TEXTFILE，指定数据以文本文件格式存储。
数据位置：使用 LOCATION 指定 HDFS 中的数据存储位置 /user/hive/external/student_external。
数据生命周期：删除表时，数据不会被删除，只有表的元数据会被移除。
数据格式：行格式为分隔符格式，列通过逗号分隔。
c.mydb.dept 表
CREATE TABLE `mydb.dept`(
`dept_no` INT,
`addr` STRING,
`tel` STRING
)
PARTITIONED BY (date STRING)
ROW FORMAT DELIMITED FIELDS TERMINATED BY ',';
-------------------------------------------------------------------------------------------------
内部表：通过 CREATE TABLE 创建，由 Hive 完全管理，数据默认存储在 Hive 的仓库目录中。
分区表：PARTITIONED BY (date STRING) 指定表按日期分区，分区有助于优化查询性能。
数据格式：行格式为分隔符格式，列通过逗号分隔。
数据生命周期：删除表时，数据会被一起删除，除非手动保留数据。
分区管理：分区表可以通过增加或删除分区来管理数据，适用于大规模数据集按时间、地区等维度分区的场景。
d.temp_salary_hive 表
CREATE EXTERNAL TABLE temp_salary_hive (
salary_id STRING,
id INT,
salary INT
)
ROW FORMAT DELIMITED
FIELDS TERMINATED BY '\t';
-------------------------------------------------------------------------------------------------
外部表：也是一个外部表，数据的位置没有明确指定，这意味着数据的位置需要在加载时确定或者已经预先存在。
数据格式：行数据以制表符（\t）分隔，与前面两个表的逗号分隔不同。
数据生命周期：同样删除表时不会删除数据，Hive 只管理表的元数据。
数据存储：虽然没有指定 LOCATION，但作为外部表，它不会将数据存储在 Hive 的默认数据仓库中。
02.hive创建表到hbase
a.语法说明
a.语法
create table student_hive(id int,name string,age int)
STORED BY 'org.apache.hadoop.hive.hbase.HBaseStorageHandler'
WITH SERDEPROPERTIES ("hbase.columns.mapping" = ":key,info:name,info:age")
TBLPROPERTIES ("hbase.table.name" = "student_hbase");
b.说明1
在 Hive 中创建了一张逻辑表 student_hive，让用户可以通过 Hive SQL 操作与 HBase 表 student_hbase 中的数据进行交互。
Hive 表的字段与 HBase 表中的行键和列族进行了一一映射，使数据可以被透明地查询和操作。
c.说明2
create table student_hive(id int, name string, age int)：
这行语句定义了一个名为 student_hive 的 Hive 表，其中包含三个字段：id（整数类型）、name（字符串类型）和 age（整数类型）。这些字段的定义与常规的 Hive 表没有区别。
-------------------------------------------------------------------------------------------------
STORED BY 'org.apache.hadoop.hive.hbase.HBaseStorageHandler'：
这部分指定了表的存储方式为 HBase，通过使用 Hive 的 HBase 存储处理器（HBaseStorageHandler），让 Hive 表与 HBase 表关联起来。这样可以使 Hive 直接读写 HBase 中的数据。
-------------------------------------------------------------------------------------------------
WITH SERDEPROPERTIES ("hbase.columns.mapping" = ":key,info:name,info:age")：
这行配置了 Hive 与 HBase 之间的字段映射关系，解释如下：
:key：表示 id 字段映射到 HBase 的行键（Row Key），它是 HBase 中用于标识每行数据的唯一标识符。
info:name：表示 name 字段映射到 HBase 中的列族 info 下的列 name。
info:age：表示 age 字段映射到 HBase 中的列族 info 下的列 age。
-------------------------------------------------------------------------------------------------
TBLPROPERTIES ("hbase.table.name" = "student_hbase")：
这行指定了在 HBase 中实际存储数据的表名为 student_hbase。如果这个表在 HBase 中不存在，Hive 不会自动创建，需要事先在 HBase 中创建好这个表。
b.内部表
a.创建
a.操作1
# 创建hbase表
create 'student','info'
b.操作2
# 创建hive的表映射（内部表）
create table student_hive(id int,name string,age int)
STORED BY 'org.apache.hadoop.hive.hbase.HBaseStorageHandler'
WITH SERDEPROPERTIES ("hbase.columns.mapping" = ":key,info:name,info:age")
TBLPROPERTIES ("hbase.table.name" = "student");
c.只有1种创建方式：
正确 第1种：第1步（操作2） hive创建逻辑表后，自动会在hbase创建物理表
错误 第2种：第1步（操作1）、第2步（操作2） 报错：Table student already exists within HBase
b.删除
a.操作1
drop table student_hive;
b.操作2
disable 'student'
drop 'student'
c.存在2种删除方式
正确 第1种：第1步（操作1） hive删除逻辑表后，自动会在hbase删除物理表
user/hive/warehouse/student_hive会删除
正确 第2种：第1步（操作2）、第2步（操作1） hbase删除物理表后，然后在hive删除逻辑表映射过去
user/hive/warehouse/student_hive会删除
c.外部表
a.创建
a.操作1
# 创建hbase表
create 'salary','info'
b.操作2
# 创建hive的表映射（外部表）
create external table salary_hive(salary_id string,id int,salary int)
STORED BY 'org.apache.hadoop.hive.hbase.HBaseStorageHandler'
WITH SERDEPROPERTIES ("hbase.columns.mapping" = ":key,info:id,info:salary")
TBLPROPERTIES ("hbase.table.name" = "salary");
c.只有1种创建方式：
错误 第1种：第1步（操作2） 报错：HBase table salary doesn't exist while the table is declared as an external table
正确 第2种：第1步（操作1）、第2步（操作2） hbase创建物理表后，然后在hive创建逻辑表映射过去
b.删除
a.操作1
drop table salary_hive;
b.操作2
disable 'salary'
drop 'salary'
c.存在2种删除方式
正确 第1种：第1步（操作1） hive删除逻辑表后，不会在hbase删除物理表
user/hive/warehouse/salary_hive不会删除，hadoop fs -rm -r /user/hive/warehouse/salary_hive
正确 第2种：第1步（操作2）、第2步（操作1） hbase删除物理表后，然后在hive删除逻辑表映射过去
user/hive/warehouse/salary_hive不会删除，hadoop fs -rm -r /user/hive/warehouse/salary_hive
03.hive创建表到hdfs
a.内部表
a.语法
a.第1步：只创建内部表，hbase不创建
CREATE TABLE managed_table (dummy STRING);
b.第2步：挂载数据，可挂载多个文件
LOAD DATA INPATH '/workspace/hive/managed_table.txt' INTO table managed_table;
---------------------------------------------------------------------------------------------
执行后，/workspace/hive/managed_table.txt 移动到 /user/hive/warehouse/managed_table/managed_table.txt，源文件删除
c.第3步：查看数据
SELECT * FROM managed_table;
b.说明
DROP TABLE managed_table;
经测试，hive内部表结构全部删除，user/hive/warehouse/managed_table删除
b.外部表
a.语法
a.第1步：只创建外部表，hbase不创建
CREATE EXTERNAL TABLE external_table (dummy STRING);
b.第2步：挂载数据，可挂载多个文件
LOAD DATA INPATH '/workspace/hive/external_table.txt' INTO TABLE external_table;
LOAD DATA INPATH '/workspace/hive/external_table2.txt' INTO TABLE external_table;
---------------------------------------------------------------------------------------------
执行后，/workspace/hive/external_table.txt 移动到 /user/hive/warehouse/external_table/external_table.txt，源文件删除
c.第3步：查看数据
SELECT * FROM external_table;
b.说明
DROP TABLE external_table;
经测试，hive内部表结构全部删除，user/hive/warehouse/external_table不会删除
-------------------------------------------------------------------------------------------------
hadoop fs -ls /user/hive/warehouse
hadoop fs -rm -r /user/hive/warehouse/external_table
手动删除
04.事务
a.内部表和外部表默认情况下都支持INSERT操作
a.内部表（Managed Table）
默认支持 INSERT 操作：内部表是由 Hive 完全管理的表，数据存储在 Hive 的默认仓库目录（通常是 HDFS 上的 /user/hive/warehouse）。
支持的插入方式：INSERT INTO：向表中追加数据。
INSERT OVERWRITE：覆盖表中的现有数据。
INSERT INTO ... SELECT ...：从其他表中插入数据。
数据生命周期：删除内部表时，表数据也会被一起删除。
b.外部表（External Table）
默认支持 INSERT 操作：外部表的数据存储在 Hive 仓库目录之外，Hive 只管理表的元数据，而不控制数据的存储位置。
支持的插入方式：INSERT INTO：向表中追加数据。
INSERT OVERWRITE：覆盖表中的现有数据。
数据生命周期：删除外部表时，数据不会被删除，只有表的元数据被移除。
c.限制和注意事项
插入语句对外部表和内部表都适用，但一些特定的存储格式（如 CSV、Parquet、ORC）和存储引擎（如 HBase、Kafka）可能对 INSERT 语句有不同的支持程度。
分区表的插入：如果表是分区表，则插入时需要指定分区值或者使用动态分区插入。
文件格式限制：某些表文件格式和存储配置可能会限制 INSERT 的使用，如需要事务支持的表必须使用 ORC 等支持 ACID 的格式。
b.hive开启事务支持行级insert、update、delete、insert overwrite、mergee into
a.启用ACID特性
/usr/local/hive/hive-3.1.3/conf/hive-site.xml
-------------------------------------------------------------------------------------------------
<property>
<name>hive.txn.manager</name>
<value>org.apache.hadoop.hive.ql.lockmgr.DbTxnManager</value>
</property>
<property>
<name>hive.support.concurrency</name>
<value>true</value>
</property>
<property>
<name>hive.compactor.initiator.on</name>
<value>true</value>
</property>
<property>
<name>hive.compactor.worker.threads</name>
<value>1</value>
</property>
b.添加Hive元数据（使用mysql存储）
use hive_metadata;
INSERT INTO NEXT_LOCK_ID VALUES(1);
INSERT INTO NEXT_COMPACTION_QUEUE_ID VALUES(1);
INSERT INTO NEXT_TXN_ID VALUES(1);
COMMIT;
quit;
-------------------------------------------------------------------------------------------------
说明：初始时这三个表没有数据，如果不添加数据，会报以下错误：
org.apache.hadoop.hive.ql.lockmgr.DbTxnManager FAILED: Error in acquiring locks: Error communicating with the metastore
c.创建事务表：创建支持事务的表时，需要使用TBLPROPERTIES设置为事务表
CREATE TABLE student (
id INT,
name STRING,
age INT
)
STORED AS ORC
TBLPROPERTIES ('transactional'='true');
d.支持ORC格式
在 Hive 中，要使表支持 ACID 特性（事务管理），并支持增删改操作，表必须使用支持事务的文件格式。
目前，Hive 主要支持以下文件格式来实现 ACID 特性：
ORC（Optimized Row Columnar）
Parquet
Avro
-------------------------------------------------------------------------------------------------
然而，TEXTFILE 格式不支持 ACID 特性，因此不能直接用于事务性表。
这是因为 TEXTFILE 格式缺乏必要的索引和压缩机制，无法有效支持事务所需的功能如行级别的插入、更新和删除。
-------------------------------------------------------------------------------------------------
必须使用支持 ACID 的文件格式：
ORC 是最常用的格式，特别适合大数据处理场景，支持压缩、快速读写和事务操作。
TEXTFILE 格式是纯文本格式，不具备行级更新和删除的能力，因此不支持事务。
-------------------------------------------------------------------------------------------------
表的创建要求：
要启用 ACID 特性，必须在表创建时使用 STORED AS ORC 或其他 ACID 支持的格式。
同时设置 TBLPROPERTIES ('transactional'='true')，以确保表启用了事务支持
-------------------------------------------------------------------------------------------------
如果想启用事务，需要创建表的正确示例如下：
CREATE TABLE internal_student (
id INT,
name STRING,
age INT
)
STORED AS ORC -- 必须使用支持ACID的格式，如ORC
TBLPROPERTIES ('transactional'='true');
c.hive操作hbase，不能开启事务
a.HBase不支持事务
HBase 是一个分布式列存储数据库，设计时不支持事务性操作如行级更新、删除和事务一致性。
HBase 主要用于大规模数据的存储和读取，事务支持不是其核心功能。
b.Hive ACID 特性要求
Hive 的 ACID 特性要求表使用支持事务的文件格式（如 ORC 或 Parquet）。
ACID 表支持行级插入、更新和删除操作，并要求底层存储格式能处理这些操作。
c.总结
HBase 和 Hive ACID 不兼容：HBase 不支持 Hive 的 ACID 特性，因此不能通过 Hive 对 HBase 表进行事务管理。
数据操作：在 Hive 中可以对 HBase 表进行简单的插入和查询操作，但不支持行级的事务操作（如更新和删除）。这些操作需要通过 HBase 的 API 进行。
c.示例：基本表 -> 迁移到 带有事务的表
a.原有表
CREATE TABLE internal_student_temp (
id INT,
name STRING,
age INT
);
b.创建一个带事务管理的新表
-- 创建一个临时表，支持事务管理
CREATE TABLE internal_student_temp (
id INT,
name STRING,
age INT
)
STORED AS ORC
TBLPROPERTIES ('transactional'='true');
c.将数据从原表插入到新的事务表中
INSERT INTO TABLE internal_student_temp SELECT * FROM internal_student;
d.删除原表并重命名事务表
-- 删除原来的非事务表
DROP TABLE internal_student;
-- 重命名事务表为原来的表名
ALTER TABLE internal_student_temp RENAME TO internal_student;
d.示例：内部表
a.语法
a.第1步（开启事务）：只创建内部表，hbase不创建
CREATE TABLE internal_student (
id INT,
name STRING,
age INT
)
STORED AS ORC
TBLPROPERTIES ('transactional'='true');
b.第2步：挂载数据，由于开启事务，必须是ORC格式，不支持TEXTFILE，故使用临时表
a.报错
SemanticException Unable to load data to destination table. Error:
The file that you are trying to load does not match the file format
of the destination table.
b.问题分析
表 internal_student 使用的是 ORC 格式，并且启用了事务性（transactional='true'），
这意味着表的所有数据操作都必须符合 ORC 格式和事务管理的要求。
-----------------------------------------------------------------------------------------
您尝试使用 LOAD DATA INPATH 命令加载一个文本文件（CSV 格式），
但这个文件并不符合表的 ORC 格式要求，因此导致格式不匹配错误 (SemanticException)。
c.方法一：可以通过临时表将数据加载为 ORC 格式，然后再将数据插入到目标事务表中
a.创建一个临时表，使用 TEXTFILE 格式
CREATE TABLE temp_student (
id INT,
name STRING,
age INT
)
ROW FORMAT DELIMITED
FIELDS TERMINATED BY ','
STORED AS TEXTFILE;
b.将数据加载到临时表中
1,zhangsan,20
2,lisi,21
3,wangwu,22
------------------------------------------------------------------------------------
LOAD DATA INPATH '/workspace/hive/internal_student.txt' INTO TABLE temp_student;
c.将临时表的数据插入到事务表 internal_student 中，Hive 会在插入过程中将数据转换为 ORC 格式。
INSERT INTO TABLE internal_student SELECT * FROM temp_student;
d.完成后，可以删除临时表
DROP TABLE temp_student;
d.如果数据量较小，可以直接使用 INSERT 语句来插入数据：
INSERT INTO internal_student VALUES (1, 'zhangsan', 20);
INSERT INTO internal_student VALUES (2, 'lisi', 21);
INSERT INTO internal_student VALUES (3, 'wangwu', 22);.
c.第3步：查看数据
SELECT * FROM internal_student;
b.增删改
a.INSERT（支持）
INSERT INTO TABLE internal_student VALUES (5, 'zhangsan', 20);
INSERT INTO internal_student (id, name, age) VALUES (6, 'zhangsan', 20);
---------------------------------------------------------------------------------------------
新增数据后，/user/hive/warehouse/internal_student文件有如下变化
从
空文件夹
新增到
delta_0000001_0000001_0000文件夹
b.UPDATE（支持）
UPDATE internal_student SET age = 25 WHERE id = 1;
c.DELETE（支持）
DELETE FROM internal_student WHERE id = 1;
TRUNCATE TABLE internal_student;
c.ALTER
a.添加新列
ALTER TABLE internal_student ADD COLUMNS (new_name STRING);
b.修改列数据类型或名称
ALTER TABLE internal_student CHANGE COLUMN name new_name2 STRING;
c.删除列
# ALTER TABLE internal_student REPLACE COLUMNS (id INT, name STRING);
# 必须大于当前的2个字段，才能操作
# 报错Replacing columns cannot drop columns for table default.internal_student.
d.关闭事务
# ALTER TABLE internal_student SET TBLPROPERTIES ('transactional'='false');
# 报错Cannot change 'transactional' without 'transactional_properties'
e.示例：外部表
a.语法
a.第1步（开启事务）：只创建外部表，hbase不创建
CREATE EXTERNAL TABLE internal_student (
id INT,
name STRING,
age INT
)
STORED AS ORC
TBLPROPERTIES ('transactional'='true');
---------------------------------------------------------------------------------------------
default.internal_student 不能声明为事务性，因为它是一个外部表
default.internal_student cannot be declared transactional because it's an external table)
a.第1步（不开启事务）：只创建外部表，hbase不创建
CREATE EXTERNAL TABLE external_student (
id INT,
name STRING,
age INT
)
ROW FORMAT DELIMITED
FIELDS TERMINATED BY ','
STORED AS TEXTFILE;
b.第2步：挂载数据，可挂载多个文件
1,zhangsan,20
2,lisi,21
3,wangwu,22
---------------------------------------------------------------------------------------------
LOAD DATA INPATH '/workspace/hive/external_student1.txt' INTO TABLE external_student;
LOAD DATA INPATH '/workspace/hive/external_student2.txt' INTO TABLE external_student;
---------------------------------------------------------------------------------------------
执行后，/workspace/hive/external_student.txt 移动到 /user/hive/warehouse/external_student/external_student.txt，源文件删除
d.第3步：查看数据
SELECT * FROM external_student;
b.增删改
a.INSERT（支持）
INSERT INTO TABLE external_student VALUES (10, 'zhangsan', 20);
INSERT INTO external_student (id, name, age) VALUES (10, 'zhangsan', 20);
---------------------------------------------------------------------------------------------
新增数据后，/user/hive/warehouse/external_student文件有如下变化
从
external_student1.txt
external_student2.txt
新增到
000000_0 -> 存10,zhangsan,20
external_student1.txt
external_student2.txt
b.UPDATE（外部表不支持事务）
UPDATE external_student SET age = 25 WHERE id = 1;
c.DELETE（外部表不支持事务）
DELETE FROM external_student WHERE id = 1;
TRUNCATE TABLE external_student;
c.ALTER
a.添加新列
ALTER TABLE external_student ADD COLUMNS (new_name STRING);
b.修改列数据类型或名称
ALTER TABLE external_student CHANGE COLUMN name new_name2 STRING;
c.删除列
ALTER TABLE external_student REPLACE COLUMNS (id INT, name STRING);
# 必须大于当前的2个字段，才能操作
# 报错Replacing columns cannot drop columns for table default.external_student.
d.关闭事务
# ALTER TABLE external_student SET TBLPROPERTIES ('transactional'='false');
# 报错Cannot change 'transactional' without 'transactional_properties'
05.将数据写入文件系统
a.将数据写入一个文件
a.使用 INSERT OVERWRITE DIRECTORY
-- 将查询结果写入到 HDFS 目录
INSERT OVERWRITE DIRECTORY '/user/hive/warehouse/sales_export'
ROW FORMAT DELIMITED
FIELDS TERMINATED BY ','
SELECT * FROM sales;
b.将结果复制到本地文件系统
# 从 HDFS 复制结果到本地文件系统
hadoop fs -get /user/hive/warehouse/sales_export /local/path/sales_export
b.将数据写入多个文件
a.使用 INSERT OVERWRITE DIRECTORY 导出到多个文件
-- 将查询结果写入到 HDFS 目录中的多个文件
INSERT OVERWRITE DIRECTORY '/user/hive/warehouse/sales_export_multiple'
ROW FORMAT DELIMITED
FIELDS TERMINATED BY ','
SELECT * FROM sales;
b.列出目录中的所有文件
hadoop fs -ls /user/hive/warehouse/sales_export_multiple
c.使用 hive -e 执行命令导出
# 执行查询并将结果输出到文件
hive -e 'SELECT * FROM sales;' > /local/path/sales_result.txt
d.使用 hive -f 执行 SQL 文件导出
a.创建 export_sales.sql 文件，内容如下：
SELECT * FROM sales;
b.使用 hive -f 执行 SQL 文件并导出
hive -f export_sales.sql > /local/path/sales_result_from_sql.txt
06.创建分区表
a.介绍
在 Hive 中，分区表用于将数据分成多个分区，以便在查询时可以更高效地扫描和处理数据。
事务表则允许进行 ACID 事务操作，如 INSERT, UPDATE, DELETE 等。在 Hive 中结合分区和事务表，
可以管理大规模的数据，并对数据进行高效的操作。
-----------------------------------------------------------------------------------------------------
创建分区表：使用 PARTITIONED BY 语法定义分区列，设置 TBLPROPERTIES 为 'transactional'='true'。
插入数据：在插入数据时指定分区列的值。
查询数据：可以根据分区列进行查询，以提高效率。
更新数据：通常需要使用 INSERT OVERWRITE 或先删除再插入。
删除数据：可以选择删除整个分区或特定记录。
b.创建带事务和分区的表
创建一个支持事务的分区表。在这个示例中，我们将创建一个 sales 表，其中数据按 year 和 month 进行分区。
-----------------------------------------------------------------------------------------------------
-- 创建一个分区事务表
CREATE TABLE sales (
order_id INT,
customer_name STRING,
amount DECIMAL(10,2)
)
PARTITIONED BY (year INT, month INT) -- 分区列
CLUSTERED BY (order_id) INTO 4 BUCKETS -- 可选的分桶
STORED AS ORC
TBLPROPERTIES ('transactional'='true');
c.插入数据
插入数据到分区表中时，需要指定分区的值。
-----------------------------------------------------------------------------------------------------
-- 插入数据到指定分区
INSERT INTO sales PARTITION (year=2023, month=9) VALUES
(1, 'Alice', 100.00),
(2, 'Bob', 150.00);
INSERT INTO sales PARTITION (year=2023, month=10) VALUES
(3, 'Charlie', 200.00),
(4, 'David', 250.00);
d.查询数据
查询分区表时，可以选择特定的分区来提高查询效率。
-----------------------------------------------------------------------------------------------------
-- 查询特定分区的数据
SELECT * FROM sales WHERE year = 2023 AND month = 9;
-----------------------------------------------------------------------------------------------------
-- 查询所有数据
SELECT * FROM sales;
-----------------------------------------------------------------------------------------------------
-- 聚合查询（例如，计算每月的总销售额）
SELECT year, month, SUM(amount) AS total_sales
FROM sales
GROUP BY year, month;
e.更新数据
更新分区表的数据。请注意，更新操作在 Hive 中通常较为复杂，并且可能涉及到重新写入数据。
-----------------------------------------------------------------------------------------------------
-- 更新特定分区的数据（实际操作可能需要先查询，再删除旧数据，再插入新数据）
-- 由于 Hive 更新操作的复杂性，通常推荐使用 INSERT OVERWRITE 进行更新
-- 例如，使用 INSERT OVERWRITE 更新 2023 年 9 月的所有记录
INSERT OVERWRITE TABLE sales PARTITION (year=2023, month=9)
SELECT order_id, customer_name, amount
FROM sales
WHERE year = 2023 AND month = 9;
-----------------------------------------------------------------------------------------------------
-- 如果需要更新特定记录，可以先删除再插入
-- 假设我们要更新 order_id = 1 的记录的 amount
-- 先删除旧记录
DELETE FROM sales WHERE year = 2023 AND month = 9 AND order_id = 1;
-- 再插入新记录
INSERT INTO sales PARTITION (year=2023, month=9) VALUES (1, 'Alice', 110.00);
f.删除数据
删除分区表中的数据时，可以选择删除整个分区，或删除特定的记录。
-----------------------------------------------------------------------------------------------------
-- 删除特定分区的数据
ALTER TABLE sales DROP PARTITION (year=2023, month=10);
-----------------------------------------------------------------------------------------------------
-- 删除特定记录（可以先查询，删除，再插入新数据）
-- 例如，删除 2023 年 9 月分区中 order_id = 2 的记录
DELETE FROM sales WHERE year = 2023 AND month = 9 AND order_id = 2;
g.增加表分区
a.创建示例表（包含分区）
-- 创建一个分区表
CREATE TABLE sales (
order_id INT,
customer_name STRING,
amount DECIMAL(10,2)
)
PARTITIONED BY (year INT, month INT) -- 分区列
STORED AS ORC;
b.插入数据到新分区
-- 向指定的分区插入数据
INSERT INTO sales PARTITION (year=2023, month=11) VALUES
(101, 'Alice', 300.00),
(102, 'Bob', 450.00);
h.删除分区
ALTER TABLE sales DROP PARTITION (year=2023, month=11);
i.修改表或分区的路径
a.修改表的存储路径
ALTER TABLE sales SET LOCATION '/new/path/to/sales_table';
b.修改分区的存储路径
-- 假设旧路径已经在 HDFS 上迁移，使用新的路径进行操作
-- 重新创建分区并指定新路径
ALTER TABLE sales ADD PARTITION (year=2023, month=12) LOCATION '/new/path/to/sales/2023/12';
-- 删除旧的分区
ALTER TABLE sales DROP PARTITION (year=2023, month=11);
j.分区重命名
a.创建新分区
ALTER TABLE sales ADD PARTITION (year=2023, month=10) LOCATION '/path/to/sales/2023/10';
b.移动数据
手动将数据从旧的路径迁移到新的路径。可以使用 HDFS 命令行工具（如 hadoop fs -mv）完成此操作，或者使用 Hive SQL 查询数据并插入到新分区。
c.删除旧分区
ALTER TABLE sales DROP PARTITION (year=2023, month=11);
k.动态分区
a.默认静态分区
-- 学生表
CREATE TABLE student(
id int,
name string,
age int
)
ROW FORMAT DELIMITED FIELDS TERMINATED BY '\t';
-- 学生表数据
1 name1 12
2 name2 12
3 name3 13
4 name4 13
5 name5 14
6 name6 14
7 name7 15
8 name8 15
-- 学生分区表
CREATE TABLE student_dyna(
id int,
name string
)
partitioned by (age int)
ROW FORMAT DELIMITED FIELDS TERMINATED BY '\t';
-- 需求：把学生表的数据导入的学生分区表中
-- 静态分区导入 适合增量数据的处理
-- 添加12岁的分区，导入12岁数据
alter table student_dyna add IF NOT EXISTS partition(age=12) location '12';
insert overwrite table student_dyna partition(age=12)
select id,name from student where age=12;
-- 添加13岁的分区，导入13岁数据
alter table student_dyna add IF NOT EXISTS partition(age=13) location '13';
insert overwrite table student_dyna partition(age=13)
select id,name from student where age=13;
-- 添加14岁的分区，导入14岁数据
alter table student_dyna add IF NOT EXISTS partition(age=14) location '14';
insert overwrite table student_dyna partition(age=14)
select id,name from student where age=14;
-- 添加15岁的分区，导入15岁数据
alter table student_dyna add IF NOT EXISTS partition(age=15) location '15';
insert overwrite table student_dyna partition(age=15)
select id,name from student where age=15;
b.开启动态分区
--设置参数动态分区
--开启动态分区
set hive.exec.dynamic.partition=true;
set hive.exec.dynamic.partition.mode=nonstrict;
-------------------------------------------------------------------------------------------------
--表示每个节点生成动态分区的最大个数，默认是100
set hive.exec.max.dynamic.partitions.pernode=10000;
--表示一个DML操作可以创建的最大动态分区数，默认是1000
set hive.exec.max.dynamic.partitions=100000;
--表示一个DML操作可以创建的最大文件数，默认是100000
set hive.exec.max.created.files=150000
-------------------------------------------------------------------------------------------------
--将select数据，覆盖到表的动态分区
insert overwrite table table1 partition (ds, hr) select key, value, ds, hr FROM table2 WHERE ds is not null;
07.创建分桶表
a.介绍
在 Hive 中，分桶（Bucketing）是一种将表数据分成不同的桶（文件）的技术，以便于更高效地查询和管理数据。
结合事务支持，可以创建一个带有分桶的事务表，并进行增、删、改、查操作。
-----------------------------------------------------------------------------------------------------
创建分桶表：使用 CLUSTERED BY 语法定义分桶列，并设置 TBLPROPERTIES 为 'transactional'='true'。
插入数据：数据会自动根据分桶列分配到桶中。
查询数据：与普通表的查询类似，分桶影响数据存储和处理性能。
更新数据：使用 INSERT OVERWRITE 替换数据。
删除数据：使用 DELETE 或 TRUNCATE TABLE 清除数据。
b.创建带事务和分桶的表
创建一个支持事务的分桶表。分桶表通常使用 CLUSTERED BY 语法定义分桶列，并指定分桶数量。
-----------------------------------------------------------------------------------------------------
-- 创建一个分桶事务表
CREATE TABLE employee_data (
emp_id INT,
name STRING,
department STRING
)
CLUSTERED BY (emp_id) INTO 4 BUCKETS -- 按 emp_id 分桶，分成 4 个桶
STORED AS ORC
TBLPROPERTIES ('transactional'='true');
c.插入数据
向分桶表中插入数据。插入数据时，数据会自动分配到指定的桶中。
-----------------------------------------------------------------------------------------------------
-- 插入数据到表中
INSERT INTO employee_data VALUES
(1, 'John Doe', 'Sales'),
(2, 'Jane Smith', 'Marketing'),
(3, 'Alice Johnson', 'Engineering'),
(4, 'Bob Brown', 'HR');
d.查询数据
查询数据时，可以进行普通的 SQL 查询操作。分桶主要影响数据存储和处理的方式，查询语句与其他表类似。
-----------------------------------------------------------------------------------------------------
-- 查询表中的所有数据
SELECT * FROM employee_data;
-----------------------------------------------------------------------------------------------------
-- 查询特定部门的数据
SELECT * FROM employee_data WHERE department = 'Sales';
-----------------------------------------------------------------------------------------------------
-- 查询并统计每个部门的员工数量
SELECT department, COUNT(*) AS employee_count
FROM employee_data
GROUP BY department;
e.更新数据
在 Hive 中，更新分桶表的数据通常需要使用 INSERT OVERWRITE 操作，因为 Hive 更新操作较复杂。
可以先进行查询，然后用 INSERT OVERWRITE 替换旧数据。
-----------------------------------------------------------------------------------------------------
-- 更新表中的数据（例如，更新 emp_id 为 1 的记录的部门）
INSERT OVERWRITE TABLE employee_data
SELECT
emp_id,
CASE
WHEN emp_id = 1 THEN 'Business Development'
ELSE department
END AS department,
name
FROM employee_data;
f.删除数据
删除数据时可以使用 DELETE 语句进行操作（在 Hive 的较新版本中支持），也可以通过删除整个表或分区来完成。
-----------------------------------------------------------------------------------------------------
-- 删除特定记录（假设我们要删除 emp_id 为 2 的记录）
DELETE FROM employee_data WHERE emp_id = 2;
-----------------------------------------------------------------------------------------------------
-- 删除整个表的数据（清空表）
TRUNCATE TABLE employee_data;
1.4 hbase1：列式存储
01.habse
a.打开
hbase shell
list
-----------------------------------------------------------------------------------------------------
exit
!quit
-----------------------------------------------------------------------------------------------------
whoami
status
version
-----------------------------------------------------------------------------------------------------
基于列式存储的NoSQL数据库
基于Googlebigtable论文
本质：只有插入操作（修改、删除是通过“时间戳”来模拟操作）
基于HDFS的分布式存储
Hbase只有字符串类型（无其他数据类型，更容易会提高整体效率）
Hbase容易水平扩展（只需简单的通过增加硬件，就可以达到扩展目的）
b.权限
grant <user> <permissions> [<table> [<column family> [<column; qualifier>]] --grant授予权限
grant 'hadoopdoc', 'RWXCA'
-----------------------------------------------------------------------------------------------------
revoke <user> --revoke撤销权限
revoke 'hadoopdoc'
-----------------------------------------------------------------------------------------------------
user_permission 'tablename' --列出特定表的所有权限
user_permission 'emp'
c.命名空间
list_namespace --查看命名空间
list_namespace_tables --查看命名空间中的表有什么
list_namespace_tables '命名空间' --查看命名空间中的表有什么
-----------------------------------------------------------------------------------------------------
create_namespace 'bigdata' --创建命名空间
create 'bigdata:student','info' --在新的命名空间中创建表
-----------------------------------------------------------------------------------------------------
drop_namespace 'bigdata' --只能删除空的命名空间，如果不为空，需要先删除该命名空间下的所有表
d.创建表
create '命名空间:表名称', '列族名称1','列族名称2','列族名称N'
create 'hainiu:student','cf1','cf2','cf3'
-----------------------------------------------------------------------------------------------------
create 表名,列1,列2
create 'scores','grade','course'
e.查看所有表
list
f.查看表结构
desc 'scores'
describe 'scores'
-----------------------------------------------------------------------------------------------------
exists 'scores'
g.插入数据
put 表,行键,列键，值
put '<table name>','<row>','<colfamily:colname>','<value>'
-----------------------------------------------------------------------------------------------------
put 'scores', 'zs', 'grade:', "1"
put 'scores', 'zs', 'course:Chinese', "100"
put 'scores', 'zs', 'course:Math', "95"
put 'scores', 'ls', 'grade:', "1"
put 'scores', 'ls', 'course:Chinese', "80"
put 'scores', 'ls', 'course:Math', "75"
h.更新数据
put 表,行键,列键，值
put '<table name>','<row>','<colfamily:colname>','<value>'
-----------------------------------------------------------------------------------------------------
put 'emp','row1','personal:city','Delhi'
i.查询数据（扫描表）
scan 表名
scan 'scores'
scan 'scores', {COLUMN=>'course:Math', LIMIT=>1}
j.查询数据（某一行）
get '表名', 行键
get 'scores', 'zs' --查询行键为zs的所有数据
get 'scores', 'zs', {COLUMN=>'course:Math'} --查询行键为zs，列键为course:Math的数据
k.删除数据
delete '<table name>', '<row>', '<column name>', '<time stamp>'
delete 'scores', 'zs', 'course:Math' --delete 表名，行键，列键
deleteall 'scores', 'zs' --deleteall 表名，行键
l.启用表
enable 'scores' --启用表
is_enabled 'scores' --是否启用了表
m.删除表
disable 'scores' --删除表以前，必须将表disabled
drop 'scores' --drop 表名
-----------------------------------------------------------------------------------------------------
disable_all 'raj.*' --禁用表
drop_all 'raj.*' --删除表
-----------------------------------------------------------------------------------------------------
disable 'scores'
truncate 'scores'
n.计数
count '<table name>'
o.导入数据:
importtsv -Dimporttsv.columns=HBASE_ROW_KEY,f1,f2 ...
p.导出数据
snapshot 'table_name', 'snapshot_name'
02.java Admin API
a.HBaseAdmin
HBaseAdmin 是代表Admin的类。此类属于org.apache.hadoop.hbase.client软件包。
使用此类，您可以执行管理员的任务。您可以使用Connection.getAdmin() 方法获取Admin实例。
-----------------------------------------------------------------------------------------------------
方法 说明
void createTable(HTableDescriptor desc) 创建一个新表
void createTable(HTableDescriptor desc, byte[][] splitKeys) 用指定的分割键定义的初始空区域集创建一个新表
void deleteColumn(byte[] tableName, String columnName) 从表中删除列
void deleteColumn(String tableName, String columnName) 从表中删除列
void deleteTable(String tableName) 删除表格
b.Descriptor
此类包含有关HBase表的详细信息，例如：
所有列族的描述符，
如果该表是目录表，
如果表是只读的，
记忆库的最大大小，
当应该发生区域分裂时，
与之相关的协处理器，等等。
-----------------------------------------------------------------------------------------------------
构造函数
方法 说明
HTableDescriptor(TableName name) 构造一个表描述符，指定一个TableName对象。
-----------------------------------------------------------------------------------------------------
方法与说明
方法 说明
HTableDescriptor addFamily(HColumnDescriptor family) 将列族添加到给定的描述符
1.5 hbase2：列式存储
00.总结
a.hive创建表到hbase
a.student_hive（hive）->student表（hbase）
内部表
b.salary_hive（hive）->salary表（hbase）
外部表，先建hbase，再hive外部表。删除hive逻辑表，hbase数据仍存在
c.利用临时表向salary表（外部表）插入数据
INSERT INTO TABLE salary_hive SELECT salary_id, id, salary FROM temp_salary_hive;
d.hive查询
# 现在实现关联查询，每个用户的平均工资是多少，以及人名
select a.name,avg(b.salary) as avg
from student_hive a join salary_hive b
on a.id = b.id
group by a.name
b.hive创建表到hdfs
a.内部表
CREATE TABLE managed_table (dummy STRING);
-------------------------------------------------------------------------------------------------
LOAD DATA INPATH '/workspace/hive/managed_table.txt' INTO table managed_table;
执行后，/workspace/hive/managed_table.txt 移动到 /user/hive/warehouse/managed_table/managed_table.txt，源文件删除
-------------------------------------------------------------------------------------------------
DROP TABLE managed_table;
经测试，hive内部表结构全部删除，user/hive/warehouse/managed_table删除
b.外部表
CREATE EXTERNAL TABLE external_table (dummy STRING);
-------------------------------------------------------------------------------------------------
LOAD DATA INPATH '/workspace/hive/external_table.txt' INTO TABLE external_table;
LOAD DATA INPATH '/workspace/hive/external_table2.txt' INTO TABLE external_table;
执行后，/workspace/hive/external_table.txt 移动到 /user/hive/warehouse/external_table/external_table.txt，源文件删除
-------------------------------------------------------------------------------------------------
DROP TABLE external_table;
经测试，hive内部表结构全部删除，user/hive/warehouse/external_table不会删除
-------------------------------------------------------------------------------------------------
hadoop fs -ls /user/hive/warehouse
hadoop fs -rm -r /user/hive/warehouse/external_table
手动删除
c.hbase的导入导出
a.导入
# 不能会用hive的load方式直接将数据导入到hbase中，但是可以通过中间表的形式导入进行
# 首先在本地创建teacher.txt 输入以下内容
1,yeniu,20
2,xinniu,30
3,qingniu,35
-----------------------------------------------------------------------------------------------------
# 在hive中创建临时表
create table teacher_tmp(id int,name string,age int) row format delimited fields terminated by ',';
-----------------------------------------------------------------------------------------------------
# 将数据加载到临时表中
load data inpath '/workspace/hive/teacher.txt' into table teacher_tmp;
-----------------------------------------------------------------------------------------------------
# 创建和hbase的外部映射表
create table teacher_hive(id int,name string,age int)
STORED BY 'org.apache.hadoop.hive.hbase.HBaseStorageHandler'
WITH SERDEPROPERTIES ("hbase.columns.mapping" = ":key,info:name,info:age")
TBLPROPERTIES ("hbase.table.name" = "teacher_hbase");
-----------------------------------------------------------------------------------------------------
#从临时表使用insert将数据导入到hbase中
insert into teacher_hive select * from teacher_tmp;
b.导出
不指定行列格式（ROW FORMAT DELIMITED FIELDS TERMINATED BY ','），默认行格式：文本格式 (TextFile)、默认字段分隔符：CTRL-A (\u0001)
-----------------------------------------------------------------------------------------------------
# 导出到hdfs
INSERT OVERWRITE DIRECTORY '/workspace/hive/teacher_hive' ROW FORMAT DELIMITED FIELDS TERMINATED BY ',' SELECT * FROM teacher_hive;
# 导出到linux
INSERT OVERWRITE LOCAL DIRECTORY '/workspace/hive/teacher_hive' ROW FORMAT DELIMITED FIELDS TERMINATED BY ',' SELECT * FROM teacher_hive;
-----------------------------------------------------------------------------------------------------
从本地上传到HDFS
hdfs fs -put /workspace/hive/teacher_hive/teacher_hive.txt /workspace/hive/teacher_hive/teacher_hive.txt
d.hbase的bulkload
a.准备
# 首先在本地创建文件 bulkload_test.txt 输入以下内容
1,zhangsan,20
2,lisi,30
3,wangwu,40
5 zhaosi,50
-------------------------------------------------------------------------------------------------
# 然后将数据上传到hdfs中
hdfs dfs -put bulkload_test.txt /workspace/hive
-----------------------------------------------------------------------------------------------------
# 在hbase中创建表
create 'bulkload_test','info'
b.导入
# 删除已经存在文件夹
# Output directory hdfs://master:9000/workspace/hive/bulkload_output already exists
hadoop fs -rm -r /workspace/hive/bulkload_output
-------------------------------------------------------------------------------------------------
# 退出hbase shell环境，去linux执行
# （hdfs文件系统）
hbase org.apache.hadoop.hbase.mapreduce.ImportTsv \
-Dimporttsv.separator=',' \
-Dimporttsv.columns=HBASE_ROW_KEY,info:name,info:age \
-Dimporttsv.skip.bad.lines=false \
-Dimporttsv.bulk.output=/workspace/hive/bulkload_output \
bulkload_test hdfs://master:9000/workspace/hive/bulkload_test.txt
e.MR操作Hbase
a.MR 读取 HBase 数据
设置 HBase Configuration： 初始化 HBase 配置，加载 HBase 的相关配置文件。
定义 HBase Input Format： 使用 TableInputFormat 设置 MR 作业的输入格式。需要指定输入表名和扫描器（Scan）等参数。
配置 Scan： Scan 对象用于定义从 HBase 读取数据的范围和过滤条件，比如要扫描的列族、列等。
设置 Job： 将 TableInputFormat 配置为作业的输入格式，Mapper 处理的输入是 HBase 表的行键和值。
实现 Mapper： 在 Mapper 中处理读取到的数据，如 ImmutableBytesWritable 和 Result，并提取需要的字段。
b.MR 写出数据到 HBase
设置 HBase Configuration： 同样需要初始化 HBase 配置并加载相关配置文件。
定义 HBase Output Format： 使用 TableOutputFormat 设置 MR 作业的输出格式，指定输出表的名称。
设置 Job： 将 TableOutputFormat 配置为作业的输出格式，并实现 Mapper 或 Reducer 输出到 HBase 表的逻辑。
实现 Reducer 或 Mapper： 在 Reducer 或 Mapper 中，将处理结果写出到 HBase 表。需要创建 Put 对象，并指定要写入的列族、列和值。
01.hive创建表到hbase
a.student_hive（hive）->student表（hbase）
# 创建hive的表映射（内部表），自动会在hbase创建物理表
create table student_hive(id int,name string,age int)
STORED BY 'org.apache.hadoop.hive.hbase.HBaseStorageHandler'
WITH SERDEPROPERTIES ("hbase.columns.mapping" = ":key,info:name,info:age")
TBLPROPERTIES ("hbase.table.name" = "student");
-----------------------------------------------------------------------------------------------------
# 插入数据（hive）
INSERT INTO TABLE student_hive VALUES(1,'zhangsan',20),(2,'lisi',21),(3,'wangwu',22);
-----------------------------------------------------------------------------------------------------
# 插入数据（hbase）
put 'student','4','info:name','troyekk'
put 'student','4','info:age','20'
put 'student','5','info:name','troyett'
put 'student','5','info:age','30'
-----------------------------------------------------------------------------------------------------
# 查看表（hive）
SELECT * FROM student_hive;
-----------------------------------------------------------------------------------------------------
# 查看表（hbase）
scan 'student'
b.salary_hive（hive）->salary表（hbase） --推荐，先建hbase，再hive外部表。删除hive逻辑表，hbase数据仍存在
# 创建hbase表
create 'salary','info'
-----------------------------------------------------------------------------------------------------
# 创建hive的表映射（外部表），需要先创建hbase物理表
create external table salary_hive(salary_id string,id int,salary int)
STORED BY 'org.apache.hadoop.hive.hbase.HBaseStorageHandler'
WITH SERDEPROPERTIES ("hbase.columns.mapping" = ":key,info:id,info:salary")
TBLPROPERTIES ("hbase.table.name" = "salary");
-----------------------------------------------------------------------------------------------------
# 插入数据（hive）
INSERT INTO TABLE salary_hive VALUES('s008','200','20');
-----------------------------------------------------------------------------------------------------
# 插入数据（hbase）
put 'salary','001','info:id','1'
put 'salary','002','info:id','1'
put 'salary','003','info:id','1'
put 'salary','004','info:id','2'
put 'salary','005','info:id','2'
put 'salary','006','info:id','2'
put 'salary','001','info:salary','1000'
put 'salary','002','info:salary','2000'
put 'salary','003','info:salary','3000'
put 'salary','004','info:salary','4000'
put 'salary','005','info:salary','5000'
put 'salary','006','info:salary','6000'
scan 'salary'
-----------------------------------------------------------------------------------------------------
# 查看表（hive）
SELECT * FROM salary_hive;
-----------------------------------------------------------------------------------------------------
# 查看表（hbase）
scan 'salary'
c.利用临时表向salary表（外部表）插入数据
# 准备数据文件
salary_hive.txt
s001 1 5000
s002 2 6000
s003 3 7000
s004 4 8000
s005 5 9000
-----------------------------------------------------------------------------------------------------
# 创建一个临时Hive表来加载数据（外部表）
CREATE EXTERNAL TABLE temp_salary_hive (
salary_id STRING,
id INT,
salary INT
)
ROW FORMAT DELIMITED FIELDS TERMINATED BY '\t';
-----------------------------------------------------------------------------------------------------
# 将数据加载到临时表
LOAD DATA INPATH '/workspace/hive/salary_hive.txt' INTO TABLE temp_salary_hive;
-----------------------------------------------------------------------------------------------------
# 将临时表中的数据插入到HBase映射的表中
INSERT INTO TABLE salary_hive SELECT salary_id, id, salary FROM temp_salary_hive;
-----------------------------------------------------------------------------------------------------
# INSERT INTO TABLE temp_salary_hive VALUES('s008','200','20');
# 插入，默认支持
-----------------------------------------------------------------------------------------------------
# UPDATE temp_salary_hive SET salary = '199' WHERE id = '1';
# 更新，需开启ACID特性，Attempt to do update or delete using transaction manager that does not support these operations.
-----------------------------------------------------------------------------------------------------
# DELETE FROM temp_salary_hive WHERE id = '1';
# 删除，需开启ACID特性，Attempt to do update or delete using transaction manager that does not support these operations.
-----------------------------------------------------------------------------------------------------
# TRUNCATE TABLE TEMP_SALARY_HIVE;
# 截断，需开启ACID特性，Cannot truncate non-managed table temp_salary_hive.
-----------------------------------------------------------------------------------------------------
DROP TABLE temp_salary_hive;
# 丢弃，可执行，由于创建外部表，发现 /user/hive/warehouse/temp_salary_hive 文件没有删除，若需删除，请手动
d.hive查询
# 现在实现关联查询，每个用户的平均工资是多少，以及人名
select a.name,avg(b.salary) as avg
from student_hive a join salary_hive b
on a.id = b.id
group by a.name
e.删除表，hive表结构+hbase结构全部删除
# hive，相当于hbase中的disable+drop
drop table student_hive; 内部表，user/hive/warehouse/student_hive会删除
drop table salary_hive; 外部表，user/hive/warehouse/salary_hive不会删除，hive删除逻辑表后，不会在hbase删除物理表
-----------------------------------------------------------------------------------------------------
# hbase
disable 'student' 内部表，drop table student_hive; 执行后，hbase中的student自动删除
drop 'student' 内部表，drop table student_hive; 执行后，hbase中的student自动删除
disable 'salary' 外部表，drop table salary_hive; 执行后，hive删除逻辑表后，不会在hbase删除物理表
drop 'salary' 外部表，drop table salary_hive; 执行后，hive删除逻辑表后，不会在hbase删除物理表
-----------------------------------------------------------------------------------------------------
# hive
show tables;
# hbase
list
02.hive创建表到hdfs
a.内部表
a.语法
a.第1步：只创建内部表，hbase不创建
CREATE TABLE managed_table (dummy STRING);
b.第2步：挂载数据，可挂载多个文件
LOAD DATA INPATH '/workspace/hive/managed_table.txt' INTO table managed_table;
---------------------------------------------------------------------------------------------
执行后，/workspace/hive/managed_table.txt 移动到 /user/hive/warehouse/managed_table/managed_table.txt，源文件删除
c.第3步：查看数据
SELECT * FROM managed_table;
b.说明
DROP TABLE managed_table;
经测试，hive内部表结构全部删除，user/hive/warehouse/managed_table删除
b.外部表
a.语法
a.第1步：只创建外部表，hbase不创建
CREATE EXTERNAL TABLE external_table (dummy STRING);
b.第2步：挂载数据，可挂载多个文件
LOAD DATA INPATH '/workspace/hive/external_table.txt' INTO TABLE external_table;
LOAD DATA INPATH '/workspace/hive/external_table2.txt' INTO TABLE external_table;
---------------------------------------------------------------------------------------------
执行后，/workspace/hive/external_table.txt 移动到 /user/hive/warehouse/external_table/external_table.txt，源文件删除
c.第3步：查看数据
SELECT * FROM external_table;
b.说明
DROP TABLE external_table;
经测试，hive内部表结构全部删除，user/hive/warehouse/external_table不会删除
-------------------------------------------------------------------------------------------------
hadoop fs -ls /user/hive/warehouse
hadoop fs -rm -r /user/hive/warehouse/external_table
手动删除
03.hbase的导入导出
a.导入
# 不能会用hive的load方式直接将数据导入到hbase中，但是可以通过中间表的形式导入进行
# 首先在本地创建teacher.txt 输入以下内容
1,yeniu,20
2,xinniu,30
3,qingniu,35
-----------------------------------------------------------------------------------------------------
# 在hive中创建临时表
create table teacher_tmp(id int,name string,age int) row format delimited fields terminated by ',';
-----------------------------------------------------------------------------------------------------
# 将数据加载到临时表中
load data inpath '/workspace/hive/teacher.txt' into table teacher_tmp;
-----------------------------------------------------------------------------------------------------
# 创建和hbase的外部映射表
create table teacher_hive(id int,name string,age int)
STORED BY 'org.apache.hadoop.hive.hbase.HBaseStorageHandler'
WITH SERDEPROPERTIES ("hbase.columns.mapping" = ":key,info:name,info:age")
TBLPROPERTIES ("hbase.table.name" = "teacher_hbase");
-----------------------------------------------------------------------------------------------------
#从临时表使用insert将数据导入到hbase中
insert into teacher_hive select * from teacher_tmp;
b.导出
不指定行列格式（ROW FORMAT DELIMITED FIELDS TERMINATED BY ','），默认行格式：文本格式 (TextFile)、默认字段分隔符：CTRL-A (\u0001)
-----------------------------------------------------------------------------------------------------
# 导出到hdfs
INSERT OVERWRITE DIRECTORY '/workspace/hive/teacher_hive' ROW FORMAT DELIMITED FIELDS TERMINATED BY ',' SELECT * FROM teacher_hive;
# 导出到linux
INSERT OVERWRITE LOCAL DIRECTORY '/workspace/hive/teacher_hive' ROW FORMAT DELIMITED FIELDS TERMINATED BY ',' SELECT * FROM teacher_hive;
-----------------------------------------------------------------------------------------------------
从本地上传到HDFS
hdfs fs -put /workspace/hive/teacher_hive/teacher_hive.txt /workspace/hive/teacher_hive/teacher_hive.txt
04.hbase的bulkload
a.介绍
在大数据的场景计算中，有时候我们会遇见将大量数据一次性导入到hbase的情况，但是这个时候hbase是不能够容纳的，
因为插入的数据首先会进入到memstore中如果大量插入数据会造成memstore的内存压力急剧增大，这个时候机器的其他
进程是没有办法执行的，并且还会出现非常严重的问题，比如hbase在大量插入数据的时候首先这个region会急剧增加，
后续region会按照拆分策略进行region拆分，当前region下线，插入程序会直接卡死造成hbase宕机等严重问题，
为了解决这个问题，hbase给用户提供了一种新的插入数据的方式bulkload方式，这个方式中会跳过hbase本身的过程，
首先在使用hbase的提供的mapreduce程序按照插入数据的格式和hbase的表格式生成hfile文件，然后我们将hfile文件
一次性插入到hbase对应的hdfs的文件夹中，这种方式是最快捷并且对于hbase的压力最小的方式
b.准备
# 首先在本地创建文件 bulkload_test.txt 输入以下内容
1,zhangsan,20
2,lisi,30
3,wangwu,40
5 zhaosi,50
-----------------------------------------------------------------------------------------------------
# 然后将数据上传到hdfs中
hdfs dfs -put bulkload_test.txt /wrokspace/hive
-----------------------------------------------------------------------------------------------------
# 在hbase中创建表
create 'bulkload_test','info'
-----------------------------------------------------------------------------------------------------
# 测试（插入数据）
put 'bulkload_test', '1', 'info:name', 'zhangsan'
put 'bulkload_test', '1', 'info:age', '20'
put 'bulkload_test', '2', 'info:name', 'lisi'
put 'bulkload_test', '2', 'info:age', '30'
put 'bulkload_test', '3', 'info:name', 'wangwu'
put 'bulkload_test', '3', 'info:age', '40'
put 'bulkload_test', '5', 'info:name', 'zhaosi'
put 'bulkload_test', '5', 'info:age', '50'
-----------------------------------------------------------------------------------------------------
# 查看数据
scan 'bulkload_test'
c.导入
# 删除已经存在文件夹
# Output directory hdfs://master:9000/workspace/hive/bulkload_output already exists
hadoop fs -rm -r /workspace/hive/bulkload_output
-----------------------------------------------------------------------------------------------------
# 退出hbase shell环境，去linux执行
# （hdfs文件系统）
hbase org.apache.hadoop.hbase.mapreduce.ImportTsv \
-Dimporttsv.separator=',' \
-Dimporttsv.columns=HBASE_ROW_KEY,info:name,info:age \
-Dimporttsv.skip.bad.lines=false \
-Dimporttsv.bulk.output=/workspace/hive/bulkload_output \
bulkload_test hdfs://master:9000/workspace/hive/bulkload_test.txt
# （linux文件系统）
hbase org.apache.hadoop.hbase.mapreduce.ImportTsv \
-Dimporttsv.separator=',' \
-Dimporttsv.columns=HBASE_ROW_KEY,info:name,info:age \
-Dimporttsv.skip.bad.lines=false \
-Dimporttsv.bulk.output=/workspace/hive/bulkload_output \
bulkload_test file:///workspace/hive/bulkload_test.txt
-----------------------------------------------------------------------------------------------------
# 调整 MapReduce 任务的内存和 Java 虚拟机（JVM）设置
hbase org.apache.hadoop.hbase.mapreduce.ImportTsv \
-Dimporttsv.separator=',' \
-Dimporttsv.columns=HBASE_ROW_KEY,info:name,info:age \
-Dimporttsv.skip.bad.lines=false \
-Dimporttsv.bulk.output=/workspace/hive/bulkload_output \
-Dmapreduce.map.memory.mb=2048 \
-Dmapreduce.reduce.memory.mb=2048 \
-Dmapreduce.map.java.opts=-Xmx1536m \
-Dmapreduce.reduce.java.opts=-Xmx1536m \
bulkload_test hdfs://master:9000/workspace/hive/bulkload_test.txt
05.MR操作Hbase
a.MR 读取 HBase 数据
a.流程
设置 HBase Configuration： 初始化 HBase 配置，加载 HBase 的相关配置文件。
定义 HBase Input Format： 使用 TableInputFormat 设置 MR 作业的输入格式。需要指定输入表名和扫描器（Scan）等参数。
配置 Scan： Scan 对象用于定义从 HBase 读取数据的范围和过滤条件，比如要扫描的列族、列等。
设置 Job： 将 TableInputFormat 配置为作业的输入格式，Mapper 处理的输入是 HBase 表的行键和值。
实现 Mapper： 在 Mapper 中处理读取到的数据，如 ImmutableBytesWritable 和 Result，并提取需要的字段。
b.代码
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.client.Scan;
import org.apache.hadoop.hbase.io.ImmutableBytesWritable;
import org.apache.hadoop.hbase.mapreduce.TableInputFormat;
import org.apache.hadoop.hbase.mapreduce.TableMapReduceUtil;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import java.io.IOException;
public class HBaseReadMR {
public static class HBaseReadMapper extends Mapper<ImmutableBytesWritable, Result, Text, IntWritable> {
@Override
protected void map(ImmutableBytesWritable key, Result value, Context context) throws IOException, InterruptedException {
// 从 Result 对象中获取数据，例如读取某个列的数据
String rowKey = new String(key.get());
String columnValue = new String(value.getValue("column_family".getBytes(), "column".getBytes()));
context.write(new Text(rowKey), new IntWritable(Integer.parseInt(columnValue)));
}
}
public static void main(String[] args) throws Exception {
// 创建 HBase 配置
Configuration config = HBaseConfiguration.create();
config.set(TableInputFormat.INPUT_TABLE, "your_table_name");
// 创建 MapReduce Job
Job job = Job.getInstance(config, "HBase Read Job");
job.setJarByClass(HBaseReadMR.class);
// 设置 Mapper
job.setMapperClass(HBaseReadMapper.class);
job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(IntWritable.class);
// 配置 HBase 表输入格式
Scan scan = new Scan();
scan.addColumn("column_family".getBytes(), "column".getBytes());
TableMapReduceUtil.initTableMapperJob("your_table_name", scan, HBaseReadMapper.class, Text.class, IntWritable.class, job);
// 提交作业
System.exit(job.waitForCompletion(true) ? 0 : 1);
}
}
b.MR 写出数据到 HBase
a.流程
设置 HBase Configuration： 同样需要初始化 HBase 配置并加载相关配置文件。
定义 HBase Output Format： 使用 TableOutputFormat 设置 MR 作业的输出格式，指定输出表的名称。
设置 Job： 将 TableOutputFormat 配置为作业的输出格式，并实现 Mapper 或 Reducer 输出到 HBase 表的逻辑。
实现 Reducer 或 Mapper： 在 Reducer 或 Mapper 中，将处理结果写出到 HBase 表。需要创建 Put 对象，并指定要写入的列族、列和值。
b.代码
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.io.ImmutableBytesWritable;
import org.apache.hadoop.hbase.mapreduce.TableOutputFormat;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import java.io.IOException;
public class HBaseWriteMR {
public static class HBaseWriteMapper extends Mapper<Object, Text, Text, IntWritable> {
@Override
protected void map(Object key, Text value, Context context) throws IOException, InterruptedException {
// 假设输入数据为 "rowKey,columnValue"
String[] parts = value.toString().split(",");
String rowKey = parts[0];
int columnValue = Integer.parseInt(parts[1]);
context.write(new Text(rowKey), new IntWritable(columnValue));
}
}
public static class HBaseWriteReducer extends Reducer<Text, IntWritable, ImmutableBytesWritable, Put> {
@Override
protected void reduce(Text key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException {
int sum = 0;
for (IntWritable value : values) {
sum += value.get();
}
// 创建 Put 对象，指定行键
Put put = new Put(key.toString().getBytes());
// 添加列族、列和值
put.addColumn("column_family".getBytes(), "column".getBytes(), String.valueOf(sum).getBytes());
// 写出 Put 对象
context.write(null, put);
}
}
public static void main(String[] args) throws Exception {
// 创建 HBase 配置
Configuration config = HBaseConfiguration.create();
config.set(TableOutputFormat.OUTPUT_TABLE, "your_table_name");
// 创建 MapReduce Job
Job job = Job.getInstance(config, "HBase Write Job");
job.setJarByClass(HBaseWriteMR.class);
// 设置 Mapper 和 Reducer
job.setMapperClass(HBaseWriteMapper.class);
job.setReducerClass(HBaseWriteReducer.class);
job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(IntWritable.class);
job.setOutputKeyClass(ImmutableBytesWritable.class);
job.setOutputValueClass(Put.class);
// 配置 HBase 表输出格式
job.setOutputFormatClass(TableOutputFormat.class);
// 设置一个临时的输出路径，尽管 HBase 作业本身不会使用它
FileOutputFormat.setOutputPath(job, new org.apache.hadoop.fs.Path("/tmp/hbase-output"));
// 提交作业
System.exit(job.waitForCompletion(true) ? 0 : 1);
}
}
1.6 phoenix：SQL引擎
00.总结
a.建议
对于我们公司来说，虽然HBase用得多，但用Phoenix的比较少。
b.踩坑
从自己测试来看，Phoenix确实还存在各种不稳定，如下面描述的几点问题：
最新版本对HBase、Hadoop等有严格版本控制，对于已经用上HBase的业务来说要升级HBase版本适配Phoenix代价太大
与HBase强相关，作为HBase中的一个组件启动，HBase元数据容易遭到破坏
官方提供的创建索引方法，容易导致插入失败，查询失败，程序崩溃等问题
c.phoneix映射hbase中hbase乱码解决方案处理及nifi中部分细节问题
由于hbase 是 nosql ，其底层字段存储只由字节数组实现，不区分字段类型，因此在将数据存在hbase中时，为了防止乱码，所有字段均应为varchar类型
考虑到varchar类型的插入，phoneix中所有插入语句中字段值必须为单引号覆盖
phoneix正常创建表，列族会被序列化，hbase中会乱码，需要加上 COLUMN_ENCODED_BYTES=0;
主键加上了3中操作依然会显示为INFO：_0 （INFO列族下），因此尽量使用单独的rowkey字段作为主键，保持rowkey 与 真实 主键值相同即可
中文部分在hbase中会被存储为/uxxxx的utf8格式，具体使用时改变编码即可，不影响什么
在phoneix中创建的表会被默认采取大写形式存储到phoenix中，使用双引号括起来即可解决大小写问题，
d.示例
"stu"最好使用双引号创建
-----------------------------------------------------------------------------------------------------
CREATE TABLE IF NOT EXISTS "stu" (
"id" VARCHAR PRIMARY KEY,
"name" VARCHAR,
"age" VARCHAR
) COLUMN_ENCODED_BYTES=0;
-----------------------------------------------------------------------------------------------------
UPSERT INTO "stu" ("id", "name", "age") VALUES ('1', '张三', '20');
UPSERT INTO "stu" ("id", "name", "age") VALUES ('2', '李四', '22');
-----------------------------------------------------------------------------------------------------
SELECT * FROM "stu";
scan 'stu'
-----------------------------------------------------------------------------------------------------
CREATE INDEX "idx_name" ON "stu" ("name");
CREATE INDEX "idx_age" ON "stu" ("age");
CREATE INDEX "idx_name_age" ON "stu" ("name", "age");
!indexes
-----------------------------------------------------------------------------------------------------
DROP TABLE "stu";
01.常用1
a.打开
sqlline.py master:2181
sqlline.py master,slave1,slave2:2181
b.表操作命令
a.创建表
CREATE TABLE testtable (
id INTEGER NOT NULL PRIMARY KEY,
name VARCHAR,
age INTEGER
);
-------------------------------------------------------------------------------------------------
可以指定列族，例如：
CREATE TABLE testtable (
id INTEGER NOT NULL PRIMARY KEY,
info.name VARCHAR,
info.age INTEGER
);
b.查看表结构
!desc testtable
!describe testtable
c.查看所有表
!tables
d.修改表
ALTER TABLE testtable ADD address VARCHAR;
e.删除表
DROP TABLE testtable; --创建表是testtable
DROP TABLE 'testtable'; --创建表是’testtable‘
DROP TABLE "testtable"; --如果表名使用了双引号（"）在创建时定义，则删除表时也需要使用双引号，而不是单引号（'）
c.数据操作命令
a.插入数据
UPSERT INTO testtable (id, name, age) VALUES (1, 'John', 30);
b.批量插入数据
UPSERT INTO testtable (id, name, age) VALUES (2, 'Jane', 25);
UPSERT INTO testtable (id, name, age) VALUES (3, 'Mike', 40);
c.查询数据
SELECT * FROM testtable;
d.查询特定条件的数据
SELECT * FROM testtable WHERE age > 30;
e.更新数据
UPSERT INTO testtable (id, name, age) VALUES (1, 'John', 35);
f.删除数据
DELETE FROM testtable WHERE id = 1;
d.索引操作
a.创建索引
create local index myindex1 on "hainiu"."testindex" (COL1);
b.查看执行计划，发现不全表扫描
explain select * from "hainiu"."testindex" where COL1 = '200';
select * from "hainiu"."testindex" where COL1 = '200';
c.查看索引
!indexes
d.删除索引
drop index myindex on "hainiu"."testindex";
e.视图操作
a.创建视图
CREATE VIEW testview AS SELECT * FROM testtable WHERE age > 20;
b.查看视图
!tables
c.删除视图
DROP VIEW testview;
f.统计和分析
a.查看表的统计信息
UPDATE STATISTICS testtable;
b.可以使用HINTS来优化查询
SELECT /*+ INDEX(testtable idx_name) */ * FROM testtable WHERE name = 'John';
g.系统命令
a.查看当前连接的Phoenix版本和JDBC驱动版本
!dbinfo
b.检查当前的数据库连接状态
!scan
c.获取当前运行的所有属性和设置
!set
d.退出
!quit
h.统计查询
a.示例1
select count(1) from PHTEST1;
select count(distinct col1) from PHTEST1;
select sum(num) from (select col1, count(*) as num from PHTEST1 group by col1) t1;
b.示例2
select col1, count(*) as num from PHTEST1 group by col1 order by num desc;
i.查询导入
a.临时表
create table PHTEST2(
pk varchar not null primary key,
col1 varchar,
col2 varchar,
col3 varchar
);
b.插入数据
upsert into PHTEST2 values ('x0001','newvalue','newvalue','newvalue');
upsert into PHTEST2 values ('x0002','newvalue','newvalue','newvalue');
upsert into PHTEST2 values ('x0003','3','4','5');
upsert into PHTEST2 values ('x0004','4','5','6');
upsert into PHTEST2 values ('x0005','newvalue','newvalue','newvalue');
upsert into PHTEST2 values ('x0006','newvalue','newvalue','newvalue');
c.执行批量更新, 将PHTEST2表的数据覆盖到PHTEST1表
upsert into PHTEST1 select * from PHTEST2;
j.数据导入
a.phoenix数据导入只支持csv文件格式
# 在客户端外
# 执行SQL文件
# 对标hive的-f test.sql ${hiveconf:batch_date}
# 创建sql文件 select * from PHTEST1
sqlline.py master:2181 /root/sql
b.操作
# 创建表
create table user(id varchar primary key,name varchar,age varchar);
-------------------------------------------------------------------------------------------------
# 创建csv文件 /root/user.csv
# 输入文件内容
# 1，zhangsan,20
# 2,lisi,30
-------------------------------------------------------------------------------------------------
psql.py -t USER master:2181 /root/user.csv
# 注意：
# 1）phoenix数据导入只支持后缀为.csv的文件, csv文件名称不需要和表名称一致，文件名可以小写
# 2）指定的表必须是大写，小写就报错
02.常用2
a.在phoenix建表时指定列族
CREATE TABLE my_table (
row_id VARCHAR PRIMARY KEY,
cf1.col1 INTEGER,
cf1.col2 VARCHAR,
cf2.col3 DATE
);
b.在phoenix建表时指定压缩格式
CREATE TABLE my_table (
row_id VARCHAR PRIMARY KEY,
cf1.col1 INTEGER,
cf1.col2 VARCHAR
)
COMPRESSION='SNAPPY';
-----------------------------------------------------------------------------------------------------
针对特定列族指定压缩格式：
CREATE TABLE my_table (
row_id VARCHAR PRIMARY KEY,
cf1.col1 INTEGER,
cf1.col2 VARCHAR
)
COLUMN_ENCODED_BYTES=0, COMPRESSION='SNAPPY';
c.在phoenix建表时预分region
在创建表时，将表预分成多个 Region，分界点分别为 '1000', '2000', '3000'
-----------------------------------------------------------------------------------------------------
CREATE TABLE my_table (
row_id VARCHAR PRIMARY KEY,
cf1.col1 INTEGER
)
SPLIT ON ('1000', '2000', '3000');
d.phoenix建表时指定组合rowkey
create table "hainiu"."combinationkey_table1" (
prefix varchar not null,
id varchar not null,
col1 varchar,
col2 varchar
CONSTRAINT pk primary key ( prefix,id )
)
column_encoded_bytes=0,
compression='snappy'
split on ('1','2','|');
-----------------------------------------------------------------------------------------------------
-- 插入数据
upsert into "hainiu"."combinationkey_table1" (prefix,id,col1,col2) values ('1','001','user1','20');
upsert into "hainiu"."combinationkey_table1" (prefix,id,col1,col2) values ('1','002','user2','21');
-----------------------------------------------------------------------------------------------------
-- 查看表结构
!describe "hainiu"."combinationkey_table"
e.phoenix实现动态列
-- 创建表
create table "hainiu"."dynamic_table1"(
pk varchar not null primary key,
col1 varchar,
col2 varchar
)column_encoded_bytes=0;
-----------------------------------------------------------------------------------------------------
-- 插入数据
upsert into "hainiu"."dynamic_table1" (pk,col1,col2) values ('x0001','user1','20');
upsert into "hainiu"."dynamic_table1" (pk,col1,col2) values ('x0002','user1','21');
upsert into "hainiu"."dynamic_table1" (pk,col1,col2) values ('x0003','user1','22');
upsert into "hainiu"."dynamic_table1" (pk,col1,col2) values ('x0004','user1','23');
-----------------------------------------------------------------------------------------------------
-- 动态插入列
-- 动态插入 col3 和 col4 列
upsert into "hainiu"."dynamic_table1" (pk,col1,col2,col3 varchar,col4 varchar) values ('x0005','user1','23','beijing','hainiu');
-- 动态插入 col4 和 col5 列
upsert into "hainiu"."dynamic_table1" (pk,col1,col2,col4 varchar,col5 varchar) values ('x0006','user2','32','huawei','30K');
-- 动态插入 col3、col4、col5 列
upsert into "hainiu"."dynamic_table1" (pk,col1,col2,col3 varchar,col4 varchar,col5 varchar) values ('x0007','user3','33','shanghai','ali','22K');
-- 动态插入 col3、col4、col5、col6 列
upsert into "hainiu"."dynamic_table1" (pk,col1,col2,col3 varchar,col4 varchar,col5 varchar,col6 varchar) values ('x0008','user4','35','shanghai','baidu','12K','false');
-----------------------------------------------------------------------------------------------------
-- phoenix中查询动态列
select * from "hainiu"."dynamic_table1"(col3 varchar,col4 varchar);
select * from "hainiu"."dynamic_table1"(col3 varchar,col4 varchar,col5 varchar) ;
select * from "hainiu"."dynamic_table1"(col3 varchar,col4 varchar,col5 varchar,col6 varchar) ;
f.phoenix与hbase表关联1
a.创建phoenix视图映射hbase表（Hbase有表数据）
a.介绍
映射hbase中已有的表为phoenix的视图，在这个模式下，通过phoenix可以以SQL的形式只读hbase的表。删除视图后，hbase的表仍存在。视图名称需要和hbase表名称一致。
phoenix的DDL中建议为所有表名和列名加上双引号，否则phoenix会全部转为大写进行识别，同样的在执行phoenix的查询命令时要给字符串用单引号，因为双引号里的会被识别为列或表或列族。。
其中ROW是主键，对应hbase表的rowkey，其他字段使用"列族"."列名"作为字段名。
若hbase表中的列名包含小数点，如如列族为'cf',列名为"root.a.b" 则在Phoenix的DDL中对应为"cf"."root.a.b" varchar,
b.使用
create view "phoenix_test"(
"ROW" varchar primary key,
"cf1"."name" varchar,
"cf1"."age" varchar
);
b.创建phoenix表映射hbase已有的表（Hbase无表数据）
a.介绍
映射hbase中已有的表为phoenix的表，在这个模式下，通过phoenix可以以SQL的形式对hbase表进行DDL和DML的操作，删除phoenix表后，hbase里对应的表也会被删除。
在Phoenix中映射hbase中已有的表，若hbase表未使用namespace命名空间则可以使用create table "hbase表名"()...;创建phoenix表，
若hbase表在namespace中即表名中带有冒号，则需要参考下面的第6点里的配置开启phoenix的映射hbase表空间，
此时可以使用命令create table "hbase表命名空间"."hbase表名"()...创建phoenix的表.
b.使用
create table "phoenix"."phoenix_test"(
"ROW" varchar primary key,
"cf1"."name" varchar,
"cf1"."age" varchar
)
column_encoded_bytes=0;
---------------------------------------------------------------------------------------------
创建的phoenix表看不到hbase中已有的数据，但若hbase表有新增数据或对phoenix表进行增删改查则可以看到hbase里的增量数据，
这个是因为phoenix4.10版本之后对列映射编码规则做了修改，我们可以通过在DDL最后加上一句
column_encoded_bytes=0即可关闭该配置，然后该phoenxi表创建之后就可以看到hbase钟的已有数据
g.phoenix与hbase表关联2
a.Hbase有表数据
a.只需要查找，不需要对数据进行操作
a.示例
create view if not exists "stu"(
"id" varchar primary key,
"info1"."name" varchar ,
"info1"."age" varchar
)column_encoded_bytes=0;
b.说明
这时需要建立视图，因为视图删除时不会影响到原数据
建映射视图和映射表需要遵循以下几点：
Phoneix的表名必须和 hbase的 库名.表名一致
Phoneix的表的主键的列名一般对应rowkey列，名称可以随意，但是类型得匹配！
Phoneix的表的普通的列名，必须和hbase的列族.列名一致！
表映射的结尾，必须添加column_encoded_bytes=0，不然无法从hbase中查询到数据的！
b.需要对数据进行操作
a.示例
create table if not exists "stu"(
"id" varchar primary key,
"info1"."name" varchar ,
"info1"."age" varchar
)column_encoded_bytes=0;
b.说明
此时就只能用映射表来操作
c.映射带命名空间的表
a.示例
create table "myns"."t1"(
"id" varchar(20) primary key,
"info1"."name" varchar (20)
)column_encoded_bytes=0;
b.说明
带命名空间的表在进行映射时，必须参照这个博文里的方法进行配置
https://blog.csdn.net/xdsxhdyy/article/details/96461576
除了hbase的hbase-site.xml 要配置，phoenix 的bin/hbase-site.xml也要配置，否则会报错
Ensure that config phoenix.schema.isNamespaceMappingEnabled is consitent on client and server
然后再创建与hbase同名的schema
create schema "myns";
b.Hbase无表数据
a.只有1种
a.示例
CREATE TABLE IF NOT EXISTS us_population (
state CHAR(2) NOT NULL,
city VARCHAR NOT NULL,
population BIGINT
CONSTRAINT my_pk PRIMARY KEY (state, city)
);
b.说明
此处用的联合主键，当然也支持单个主键
注意：在Phoenix中创建的映射表删除时也会将Hbase中的表删除
在建表时，小写的表名或列名，都会自动在sqlline.py中转为大写！这样在查询时，只能使用大写进行查询！
如果必须使用小写，需要在表名等字段上添加双引号，建议不要使用小写的表名或字段！
03.索引分类
a.全局索引（Global Index）
a.介绍
全局索引是在单独的索引表中维护数据，这种索引适用于全表范围内的查询，能够加速跨 Region 的查询操作。
b.示例
-- 创建一个基础表
CREATE TABLE my_table (
id INTEGER NOT NULL PRIMARY KEY,
name VARCHAR,
age INTEGER
);
-------------------------------------------------------------------------------------------------
-- 创建全局索引
CREATE INDEX idx_name ON my_table (name);
c.说明
idx_name 是一个全局索引，针对 my_table 表中的 name 列创建。
索引表存储在独立的 Region 中，因此对大数据量的全表查询能提供显著性能提升。
b.本地索引（Local Index）
a.介绍
本地索引与主表数据存储在相同的 Region 上，是一种轻量级索引方式，不会增加过多存储开销。它适用于热点数据或 Region 内的查询优化。
b.示例
-- 创建本地索引
CREATE LOCAL INDEX idx_age ON my_table (age);
c.说明
idx_age 是一个本地索引，针对 my_table 表中的 age 列创建。
本地索引表与主表在同一个 Region 中，可以减少网络传输和延迟。
c.覆盖索引（Covering Index）
a.介绍
覆盖索引是指索引中包含查询需要的所有列，可以完全从索引表中获取数据而无需访问主表，从而极大提高查询性能。
b.示例
-- 创建一个包含多个列的全局索引（覆盖索引）
CREATE INDEX idx_name_age ON my_table (name) INCLUDE (age);
c.说明
idx_name_age 是一个覆盖索引，索引 name 列，并同时包含了 age 列的数据。
查询涉及 name 和 age 的时候，可以直接从索引表获取数据，无需访问主表。
d.函数索引（Function-based Index）
a.介绍
函数索引是基于列的函数结果创建的索引，用于加速对函数结果的查询，例如对转换、计算后的数据进行索引优化。
b.示例
-- 创建一个带函数的索引，例如针对 UPPER 函数
CREATE INDEX idx_upper_name ON my_table (UPPER(name));
c.说明
idx_upper_name 是一个函数索引，针对 name 列的 UPPER 函数结果创建索引。
当查询中使用 UPPER(name) 时，Phoenix 可以利用该索引来加速查询。
e.示例总结
全局索引：适用于全表查询，索引数据存储在独立的 Region，适合大规模数据。
本地索引：与主表共用 Region，适合小规模、频繁查询的场景，降低索引管理开销。
覆盖索引：索引表包含所有查询所需的数据，可以完全避免访问主表，非常高效。
函数索引：针对函数计算结果创建索引，优化函数调用时的查询性能。
1.7 sqoop：数据迁移
00.介绍
对数据库的支持。支持DB2、达梦、GreenPlum、HBase、HBase Phoenix、MySQL、PostgreSQL、MPP、Oracle、SQL Server、TeraData、Generic JDBC、HANA等数据源
Sqoop任务共支持5种任务类型，分别为：数据库到HDFS、数据库到HBase、数据库到Hive、HDFS到数据库、Hive到数据库。每种任务类型都可以进行整表导出，同时支持通过参数配置选择部分字段导出
操作数据库时需要将被操作的数据库驱动手动放入Sqoop安装路径下。若使用DataEngine平台，则放置驱动的目录为/usr/hdp/3.0.1.0-187/sqoop/lib/
从大数据集群（HDFS/Hive/HBase等）导出数据到Oracle数据库时，不支持表名小写的情况
01.Sqoop基本命令
a.查看所有命令
sqoop help
b.查看某条命令的具体使用方法
sqoop help <命令名>
02.Sqoop 与 HDFS
a.查询MySQL
a.查询 MySQL 所有数据库
sqoop list-databases \
--connect jdbc:mysql://master:3306/ \
--username hive \
--password hive
-------------------------------------------------------------------------------------------------
sqoop list-databases \
--connect jdbc:mysql://master:3306/ \
--username root
b.查询指定数据库中所有数据表
sqoop list-tables \
--connect jdbc:mysql://master:3306/mysql \
--username hive \
--password hive
-------------------------------------------------------------------------------------------------
sqoop list-tables \
--connect jdbc:mysql://master:3306/ \
--username root
b.MySQL 数据导入到 HDFS
导入命令 将 MySQL 数据库中的 help_keyword 表导入到 HDFS 的 /sqoop 目录下。
使用 3 个 map tasks 并行导入。如果目标目录存在，则先删除再导入。
-----------------------------------------------------------------------------------------------------
sqoop import \
--connect jdbc:mysql://master:3306/mysql \
--username root \
--password root \
--table help_keyword \
--delete-target-dir \
--target-dir /sqoop \
--fields-terminated-by '\t' \
-m 3
-----------------------------------------------------------------------------------------------------
sqoop import \
--connect jdbc:mysql://master:3306/test \
--username root \
--table demo \
--delete-target-dir \
--target-dir /sqoop \
--fields-terminated-by '\t' \
-m 3
-----------------------------------------------------------------------------------------------------
--delete-target-dir：目标目录存在则先删除。
--target-dir：导入的目标目录。
-m：指定并行执行的 map tasks 数量。
-----------------------------------------------------------------------------------------------------
注意：
默认使用表的主键列作为拆分依据。如果表没有主键，可以使用 --autoreset-to-one-mapper 启动一个 map task，
或使用 --split-by <column-name> 指定拆分数据的参考列。
-----------------------------------------------------------------------------------------------------
查看导入后的目录：
hadoop fs -ls -R /sqoop
-----------------------------------------------------------------------------------------------------
查看导入内容：
hadoop fs -text /sqoop/part-m-00000
c.HDFS 数据导出到 MySQL
sqoop export \
--connect jdbc:mysql://master:3306/mysql \
--username root \
--password root \
--table help_keyword_from_hdfs \
--export-dir /sqoop \
--input-fields-terminated-by '\t' \
-m 3
-----------------------------------------------------------------------------------------------------
--export-dir：HDFS 上的目录。
--input-fields-terminated-by：指定数据的分隔符。
-----------------------------------------------------------------------------------------------------
注意：MySQL 中的表 help_keyword_from_hdfs 需要预先创建，建表语句如下：
CREATE TABLE help_keyword_from_hdfs LIKE help_keyword;
d.MySQL 数据导入到 HBase
sqoop import \
--connect jdbc:mysql://master:3306/mysql \
--username root \
--password root \
--table help_keyword \
--hbase-table help_keyword_hbase \
--column-family keywordInfo \
--hbase-row-key help_keyword_id
-----------------------------------------------------------------------------------------------------
--hbase-table：目标 HBase 表名。
--column-family：列族名。
--hbase-row-key：HBase 的 RowKey 列名。
-----------------------------------------------------------------------------------------------------
注意：HBase 中的表 help_keyword_hbase 需要预先创建：
hbase> create 'help_keyword_hbase', 'keywordInfo'
-----------------------------------------------------------------------------------------------------
导入验证 使用 HBase shell 查看表数据：
hbase> scan 'help_keyword_hbase'
03.Sqoop 与 Hive
a.MySQL 数据导入到 Hive
a.导入命令
sqoop import \
--connect jdbc:mysql://master:3306/mysql \
--username root \
--password root \
--table help_keyword \
--delete-target-dir \
--target-dir /sqoop_hive \
--hive-database sqoop_test \
--hive-import \
--hive-overwrite \
-m 3
-------------------------------------------------------------------------------------------------
--hive-database：导入到 Hive 的数据库，需预先创建。
--hive-import：将数据导入到 Hive。
--hive-overwrite：覆盖 Hive 表中已有的数据。
b.导入验证
查看 Hive 中的数据库和表：
hive> SHOW DATABASES;
hive> SHOW TABLES IN sqoop_test;
-------------------------------------------------------------------------------------------------
查看表中数据：
hive> SELECT * FROM sqoop_test.help_keyword;
-------------------------------------------------------------------------------------------------
问题排查：
如果遇到 java.io.IOException: java.lang.ClassNotFoundException: org.apache.hadoop.hive.conf.HiveConf 错误，
请将 Hive 的 hive-exec-*.jar 文件复制到 Sqoop 的 lib 目录下：
cp /path/to/hive-exec-*.jar ${SQOOP_HOME}/lib
b.Hive 数据导出到 MySQL
a.查看 Hive 表在 HDFS 的存储位置
hive> use sqoop_test;
hive> desc formatted help_keyword;
b.执行导出命令
sqoop export \
--connect jdbc:mysql://master:3306/mysql \
--username root \
--password root \
--table help_keyword_from_hive \
--export-dir /user/hive/warehouse/sqoop_test.db/help_keyword \
--input-fields-terminated-by '\001' \
-m 3
-------------------------------------------------------------------------------------------------
--export-dir：Hive 表在 HDFS 上的存储路径。
--input-fields-terminated-by：Hive 中默认的分隔符为 \001。
-------------------------------------------------------------------------------------------------
注意：MySQL 中的表 help_keyword_from_hive 需要预先创建，建表语句如下：
CREATE TABLE help_keyword_from_hive LIKE help_keyword;
04.全库导出
a.介绍
Sqoop 支持通过 import-all-tables 命令进行全库导出到 HDFS 或 Hive，但需要注意以下限制：
所有表必须有主键；或者使用 --autoreset-to-one-mapper，只启动一个 map task。
不能使用非默认的分割列，也不能通过 WHERE 子句添加限制。
b.全库导出到 HDFS
sqoop import-all-tables \
--connect jdbc:mysql://master:3306/数据库名 \
--username root \
--password root \
--warehouse-dir /sqoop_all \
--fields-terminated-by '\t' \
-m 3
c.全库导出到 Hive
sqoop import-all-tables -Dorg.apache.sqoop.splitter.allow_text_splitter=true \
--connect jdbc:mysql://master:3306/数据库名 \
--username root \
--password root \
--hive-database sqoop_test \
--hive-import \
--hive-overwrite \
-m 3
05.Sqoop 与 Dameng
a.配置 JDBC 驱动
首先，你需要确保 Sqoop 可以通过 JDBC 连接到达梦数据库。这通常涉及到将达梦数据库的 JDBC 驱动添加到 Sqoop 的类路径中。
下载达梦数据库的 JDBC 驱动（通常是 .jar 文件）。
将驱动文件复制到 Sqoop 的 lib 目录。例如：
cp /path/to/dmdb.jar ${SQOOP_HOME}/lib
b.使用 Sqoop 导入数据
示例：将达梦数据库中的表导入到 HDFS
sqoop import \
--connect jdbc:dm://<达梦数据库地址>:<端口>/<数据库名> \
--username <用户名> \
--password <密码> \
--table <表名> \
--target-dir /path/to/hdfs/dir \
--fields-terminated-by '\t' \
-m 1
-----------------------------------------------------------------------------------------------------
--connect: JDBC 连接字符串，替换 <达梦数据库地址>, <端口>, 和 <数据库名> 为实际值。
--username: 达梦数据库的用户名。
--password: 达梦数据库的密码。
--table: 需要导入的达梦数据库中的表名。
--target-dir: 导入数据存储到 HDFS 上的目录。
--fields-terminated-by: 指定字段分隔符。
-m: 指定并行执行的 map tasks 数量。
c.使用 Sqoop 导出数据
示例：将 HDFS 中的数据导出到达梦数据库
sqoop export \
--connect jdbc:dm://<达梦数据库地址>:<端口>/<数据库名> \
--username <用户名> \
--password <密码> \
--table <表名> \
--export-dir /path/to/hdfs/dir \
--input-fields-terminated-by '\t' \
-m 1
-----------------------------------------------------------------------------------------------------
--connect: JDBC 连接字符串，替换 <达梦数据库地址>, <端口>, 和 <数据库名> 为实际值。
--username: 达梦数据库的用户名。
--password: 达梦数据库的密码。
--table: 需要导入的达梦数据库中的表名。
--export-dir: HDFS 上的数据目录。
--input-fields-terminated-by: 指定输入数据的分隔符。
-m: 指定并行执行的 map tasks 数量。
06.Sqoop 与 Dameng
a.查看 SYSDBA 用户下所有表
sqoop list-tables --driver dm.jdbc.driver.DmDriver --connect jdbc:dm://192.168.142.235:5247 --username SYSDBA --password SYSDBA
b.数据导入（DM 导出到 HDFS）
sqoop import --driver dm.jdbc.driver.DmDriver --connect jdbc:dm://192.168.142.235:5247 --username SYSDBA --password SYSDBA --table BAK_DMINI_210714 -m 1
sqoop import --driver dm.jdbc.driver.DmDriver --connect jdbc:dm://192.168.142.235:5247 --username SYSDBA --password SYSDBA --table BAK_DMINI_210715 -m 1
-----------------------------------------------------------------------------------------------------
--driver dm.jdbc.driver.DmDriver：指定达梦数据库的 JDBC 驱动。
--connect jdbc:dm://192.168.142.235:5247：达梦数据库的 JDBC 连接字符串。
--username SYSDBA 和 --password SYSDBA：用于连接达梦数据库的用户名和密码。
--table BAK_DMINI_210714：需要导入的表名。
-m 1：使用 1 个 map task 进行数据导入。
-----------------------------------------------------------------------------------------------------
查看 HDFS 上的文件：
hadoop fs -ls /user/hadoop01/BAK_DMINI_210714
-----------------------------------------------------------------------------------------------------
查看文件内容：
hadoop fs -cat /user/hadoop01/BAK_DMINI_210714/part-m-00000
c.数据导出（HDFS 导出到 DM）
sqoop export --driver dm.jdbc.driver.DmDriver --connect jdbc:dm://192.168.142.235:5247 --username SYSDBA --password SYSDBA --table BAK_DMINI_210714 --export-dir /user/hadoop01/BAK_DMINI_210714/part-m-00000 --columns EMPLOYEE_ID,START_DATE,END_DATE,JOB_ID,DEPARTMENT_ID --input-fields-terminated-by ',' --input-lines-terminated-by '\n'
-----------------------------------------------------------------------------------------------------
--export-dir /user/hadoop01/BAK_DMINI_210714/part-m-00000：HDFS 上的文件目录。
--columns EMPLOYEE_ID,START_DATE,END_DATE,JOB_ID,DEPARTMENT_ID：需要导出的列。
--input-fields-terminated-by ','：指定输入数据的字段分隔符。
--input-lines-terminated-by '\n'：指定输入数据的行结束符。
1.8 releases：发展史
00.需求
a.分类1
近几年，“大数据要凉了”的声音似乎越来越多。
有人说大数据热潮退却了，也有人感慨岗位越来越少、平台越来越重、业务越来越复杂。但这真的是大数据“凉”了吗？
b.分类2
我并不这么看。在我看来，真正“凉”的不是大数据本身，而是原来的“屠龙之术”已经无“龙”可杀，
因为“龙”已经进化，而我们的武器却还停留在过去。技术需要进化，架构需要重构，能力也需要更新
01.阶段1：传统 Hadoop ——第一代“烟囱式”大数据平台
a.分类1
最早的大数据平台基本是围绕 Hadoop[1] 构建的，Lambda 架构（离线 + 实时）几乎是当时的行业标准。
但在实际工作中，我深刻体会到这个阶段的大数据平台仍然极不易用，需要大量的人力和资源投入，
所构建的系统难以真正商业化，只是一个个离线的组件。
b.分类2
当时，技术团队拿着各种 Hadoop + Hive + Spark 的架构图给老板讲未来、画愿景
靠着数据中台的“故事”扩张团队，组建起来五十人的大数据团队，雄心壮志地把平台堆了起来。
c.分类3
然而现实很快打脸：
数据总不一致，只能安慰老板说“海量数据差 1-2 条不影响使用， 这个系统和核心业务无关”；
发现数据写错了， 居然不能更新，只能把一个分区干掉重写；
成本居高不下， 因为数据往往要存储两份；
号称大数据平台多么牛， 老板想查个数直接把平台弄挂了， 只因查数据时没带分区键；
初期平台 1 个月 10 亿数据，分区还算合理；后期每天都到 20 亿数据，系统开始严重卡顿；等量级上到万亿，前面那些人已经跑了，平台只能推倒重建；
平台组件多（至少 30 个以上），任一组件升级都足以导致平台整体崩溃；
架构“烟囱”林立，每“树”一个烟囱都会引入新的安全问题，都会把平台干翻；
SQL 执行计划需要几分钟才能出来， 基本无法执行（因分区过多， 元数据顶不住）；
老板说“把数据去个重吧”，大家都想辞职。（某大平台当年只有 ODS 活着）；
... 类似的糟心例子数不胜数。
d.分类4
可以说，这个阶段的大数据平台让老板彻夜难眠。
实践证明，该架构不仅无法支撑业务需求，反而可能将公司的大数据战略带入死胡同。
大数据工程师大多数时间都在用 Spark 将数据加载到 Hadoop，完成清洗和治理，做好数据准备工作，
为上层的数据开发利用人员使用。关键这个阶段数据开发利用的人员还不敢多说一句话，常常处于弱势地位。
02.阶段2：数据湖+湖仓一体—— 组件“瘦身”，但架构复杂性仍高
a.分类1
第一代大数据平台的“惨痛经验”倒逼架构进行重塑。
以 Apache Iceberg、Delta Lake 为代表的 数据湖[2] 架构兴起，
用于替代封闭的 Hadoop 体系，实现事务支持、统一元数据、统一存储的“湖仓一体”方案。
b.分类2
在这个阶段，技术团队开始尝试简化组件，减少部署复杂性。
我们开始引入数据湖，把数据持久化为 Iceberg[3] 格式 （ODS），支持 Spark、Flink 的统计读写，
将原来复杂的30 + 组件缩减至 10个左右。大数据团队规模也从 50+ 人压缩到 10 人左右。
c.分类3
此时，大数据团队的工作主要包括：
学习 Spark 调度任务清理 Iceberg 的历史版本；
学习 Spark 调度任务实现 Iceberg 的 compact 操作；
学习 Spark 调度任务完成 Iceberg 的 Z-order 任务处理；
学习使用 Shuffle 服务调用；
各种开源组件拼合后的权限整理；
制作 SQL Gateway，根据 SQL 情况路由到后面的三个计算引擎；
给老板呈现一个“架构美观、功能强大”的平台。
d.分类4
这个阶段可以给老板画饼：
支持 ACID 事务；
实现统一元数据管理；
支持统一存储。
e.分类5
然而，老板常常提出疑问：“不对啊，这个平台至少还要投入 10 个人，这 10 个人拉去做业务不香吗？”
现实中，大部分公司都以此为底座构建大数据平台。
虽然平台瘦身了，人员规模从 50 人缩到 10 人，组件数量从 30 个缩到 10 个，
但实质复杂度依然太高，大多数企业难以真正落地使用。
如果这个平台的数据量上到万亿级别还能顶住， 那实属幸运。
否则，就只能让大数据开发人员“祭天”了。作为这类平台下的大数据工程师，
需要特别注意它的定位：单表数据最好不要超过百亿，全库控制在 1 万个表以内。
否则，Spark 任务再多就不好搞了，加班现象会非常严重。
03.阶段3：云原生新范式，颠覆“大数据工程师”（当前形态）
a.分类1
进入第三阶段，尤其是在游戏行业中，一些大的游戏公司每周都会上线新业务，
上线后各种数据分析就来了。这种时候，如果用阶段二的方案，你会发现每次都要搭建一个新平台，
一旦出问题就要通宵加班。游戏行业每时每刻都意味着钱，每一个环节都关系到兄弟们的年终奖。
b.分类2
传统大数据方案已经无法解决业务需求：
数据需要秒级接入；
系统需要支持上万级的流式计算；
海量的数据挖掘需求。
c.分类3
此时，像Snowflake和Databend这类按需付费、支持流批一体、全 SQL 表达的云原生平台应运而生。
它们为大数据平台带来了巨大变化：基于标准 SQL 可以直接读取 S3 中 CSV、NDJson、Parquet、ORC... 等文件类型；
无需 Spark 团队预处理，ETL 工程师在半小时内即可完成原本需 2 天的数据接入流程。
-----------------------------------------------------------------------------------------------------
如你再会点 Python ，还可以利用 Databend 这类支持外置 UDF 的产品，
实现表级增量捕获，替换原来的 Flink 任务。原先游戏行业里，
打完一把游戏立刻输出本局对战详情的任务就可以这样搞定。
原来几十台 Flink 集群才能跑的流计划任务，现在只要半天就能搞定，而且还能做到弹性伸缩。
-----------------------------------------------------------------------------------------------------
这时候，我们会发现“数据准备工程师”角色消失了，传统意义上的“数仓平台搭建专家”也逐渐被边缘化。
大数据进入了一个“轻平台 + 重表达 + 强业务理解”的新阶段。
目前，Snowflake、Databricks、Databend 等产品在这方面都有比较完美的实现。
04.总结
a.分类1
如今大数据生态的工作依然比较多，涉及到的角色包括不限于：
大数据数据准备工程师 （曾经说的数据搬运工）(平台化 & SaaS)
ETL工程师
BI 及分析人员[7] (可能每天用 Excel 记录任务， 也会使用Text2SQL辅助）
数据质量管理 & 血源治理工程师（ 平台化 & SaaS)
算法 & 机器学习工程师
调度平台研发（SaaS)
数据同步工具开发（SaaS, 变身称谓：Data pipeline)
可视化相关的工作 (平台化 & SaaS)
数据中台（由一堆概念堆出来的一个大数据平台，当前都在转向 Data + AI）
专注于业务的数据分析师（那些花了 10万投放，如何用数据分析来指导投放）
利用数据去变现的运营或决策。
b.分类2
其实大数据行业对人才需求还是依然旺盛的，只是需要更加专业的人了，
原来定位大数据的数据搬运工的工作确实少了，因为有更简单的方式去替代。
如果你想从事大数据工作，我认为还是大有可为。
c.分类3
以下是我个人的一些建议，从入门到进阶的路径：
ETL 工程师或是数据抓取工程师 （低代码 + SQL ）
参与专项任务的开发工程师， 例如： 数据同步工具、调度平台、可视化等
深入底层核心：存储、算法、SQL 编译器等，都是不是错的工作
2 分布式协调与消息
2.1 zookeeper：分布式协调
01.介绍
ZooKeeper是Apache开源的分布式协调服务，为分布式应用提供一致性服务。
它提供了配置管理、命名服务、分布式锁、集群管理等功能。
ZooKeeper采用类似文件系统的树形数据结构，通过Watcher机制实现数据变更通知。
广泛应用于Hadoop、Kafka、HBase等分布式系统中。
02.核心概念
a.数据节点ZNode
持久节点：创建后一直存在，除非主动删除
临时节点：客户端会话结束后自动删除
顺序节点：节点名称后自动追加递增序号
容器节点：当子节点全部删除后自动删除
b.会话Session
客户端与服务器建立TCP长连接
通过心跳保持会话活跃
会话超时后临时节点自动删除
支持会话迁移
c.监听器Watcher
一次性触发机制
监听节点数据变化
监听子节点变化
异步通知客户端
d.ACL权限控制
CREATE：创建子节点
READ：读取节点数据
WRITE：写入节点数据
DELETE：删除子节点
ADMIN：设置权限
03.集群架构
a.角色分类
Leader：处理所有写请求，负责投票发起和决议
Follower：处理读请求，参与投票
Observer：处理读请求，不参与投票
集群需要半数以上节点存活才能正常工作
b.ZAB协议
原子广播协议，保证数据一致性
两阶段提交：提议阶段和提交阶段
崩溃恢复：Leader选举和数据同步
消息顺序：ZXID全局递增事务ID
c.数据同步
Leader接收写请求
广播提议给所有Follower
半数以上确认后提交
通知所有节点应用事务
04.常用命令
a.节点操作
create /path data：创建节点
create -e /path data：创建临时节点
create -s /path data：创建顺序节点
get /path：获取节点数据
set /path data：设置节点数据
delete /path：删除节点
ls /path：列出子节点
b.监听操作
get /path watch：监听节点数据变化
ls /path watch：监听子节点变化
stat /path watch：监听节点状态变化
c.管理命令
stat：查看节点状态
history：查看历史命令
redo：重新执行命令
close：关闭连接
quit：退出客户端
05.应用场景
a.配置管理
集中存储配置信息
配置变更实时通知
多个应用共享配置
动态更新配置
b.命名服务
提供全局唯一命名
服务注册与发现
分布式ID生成
资源定位
c.分布式锁
临时顺序节点实现
公平锁和非公平锁
读写锁
防止死锁
d.集群管理
节点上下线感知
Leader选举
负载均衡
故障转移
06.Java客户端
a.原生API
ZooKeeper zk = new ZooKeeper("localhost:2181", 3000, watcher);
zk.create("/test", "data".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
byte[] data = zk.getData("/test", false, null);
zk.setData("/test", "newdata".getBytes(), -1);
zk.delete("/test", -1);
zk.close();
b.Curator框架
CuratorFramework client = CuratorFrameworkFactory.newClient("localhost:2181", new RetryNTimes(3, 1000));
client.start();
client.create().creatingParentsIfNeeded().forPath("/test", "data".getBytes());
byte[] data = client.getData().forPath("/test");
client.setData().forPath("/test", "newdata".getBytes());
client.delete().forPath("/test");
c.分布式锁实现
InterProcessMutex lock = new InterProcessMutex(client, "/locks/mylock");
lock.acquire();
try {
// 执行业务逻辑
} finally {
lock.release();
}
07.配置文件
a.zoo.cfg核心配置
tickTime=2000：基本时间单位（毫秒）
initLimit=10：Follower连接Leader的超时时间
syncLimit=5：Follower同步Leader的超时时间
dataDir=/var/lib/zookeeper：数据目录
clientPort=2181：客户端连接端口
maxClientCnxns=60：单个客户端最大连接数
b.集群配置
server.1=node1:2888:3888
server.2=node2:2888:3888
server.3=node3:2888:3888
2888：Follower与Leader通信端口
3888：Leader选举端口
c.高级配置
autopurge.snapRetainCount=3：保留快照数量
autopurge.purgeInterval=1：清理间隔（小时）
preAllocSize=64M：预分配事务日志空间
snapCount=100000：快照触发阈值
08.运维管理
a.启动停止
zkServer.sh start：启动服务
zkServer.sh stop：停止服务
zkServer.sh restart：重启服务
zkServer.sh status：查看状态
b.监控命令
echo stat | nc localhost 2181：查看服务器状态
echo mntr | nc localhost 2181：查看监控指标
echo conf | nc localhost 2181：查看配置信息
echo cons | nc localhost 2181：查看连接信息
c.数据备份
定期备份dataDir目录
备份事务日志和快照文件
使用ZooKeeper自带工具
验证备份完整性
09.性能优化
a.硬件优化
使用SSD存储事务日志
独立磁盘存储日志和快照
充足的内存
千兆网络
b.配置优化
调整tickTime和超时时间
合理设置快照频率
启用自动清理
限制客户端连接数
c.使用优化
避免频繁创建删除节点
控制节点数据大小（建议<1MB）
合理使用Watcher
批量操作减少网络开销
10.常见问题
a.脑裂问题
网络分区导致多个Leader
通过过半机制避免
确保奇数个节点
监控网络状态
b.会话超时
调整sessionTimeout参数
优化网络延迟
增加心跳频率
处理会话过期事件
c.数据不一致
检查ZAB协议配置
确保半数以上节点正常
验证事务日志
重新同步数据
2.2 kafka：消息队列
01.介绍
Apache Kafka是分布式流处理平台，最初由LinkedIn开发。
具有高吞吐量、低延迟、可扩展、持久化等特点。
支持发布订阅模式，广泛用于日志收集、消息系统、流处理等场景。
核心组件包括Producer、Broker、Consumer、ZooKeeper。
02.核心概念
a.Topic主题
消息的逻辑分类
由多个Partition组成
支持多个Producer和Consumer
可配置副本数和分区数
b.Partition分区
Topic的物理分组
顺序写入，追加日志
每个分区有唯一的offset
分区内消息有序
c.Offset偏移量
消息在分区中的位置
Consumer消费进度标识
自动提交或手动提交
存储在__consumer_offsets主题
d.Consumer Group
多个Consumer组成消费组
每个分区只能被组内一个Consumer消费
实现负载均衡和故障转移
支持消费者动态加入和退出
03.架构组件
a.Producer生产者
发送消息到指定Topic
支持同步和异步发送
可指定分区策略
消息压缩和批量发送
b.Broker服务器
存储和管理消息
处理读写请求
副本管理和同步
集群协调
c.Consumer消费者
订阅Topic消费消息
拉取模式消费
支持消费组
offset管理
d.ZooKeeper
集群元数据管理
Broker注册和发现
Controller选举
配置管理
04.消息发送
a.Producer配置
bootstrap.servers：Broker地址列表
key.serializer：Key序列化器
value.serializer：Value序列化器
acks：确认机制（0/1/all）
retries：重试次数
batch.size：批量大小
linger.ms：延迟时间
b.发送方式
同步发送：send().get()等待结果
异步发送：send(callback)回调处理
发后即忘：send()不关心结果
c.分区策略
DefaultPartitioner：根据key的hash值
RoundRobinPartitioner：轮询分配
自定义Partitioner：实现Partitioner接口
d.消息可靠性
acks=all：所有副本确认
retries>0：失败重试
enable.idempotence=true：幂等性
transactional.id：事务支持
05.消息消费
a.Consumer配置
bootstrap.servers：Broker地址
group.id：消费组ID
key.deserializer：Key反序列化器
value.deserializer：Value反序列化器
auto.offset.reset：offset重置策略
enable.auto.commit：自动提交offset
max.poll.records：单次拉取最大记录数
b.消费模式
订阅Topic：subscribe(topics)
指定分区：assign(partitions)
正则订阅：subscribe(pattern)
c.offset提交
自动提交：enable.auto.commit=true
手动同步提交：commitSync()
手动异步提交：commitAsync()
提交特定offset：commitSync(offsets)
d.Rebalance再平衡
消费者加入或退出触发
分区重新分配
暂停消费直到完成
通过心跳检测消费者状态
06.副本机制
a.副本类型
Leader副本：处理读写请求
Follower副本：同步Leader数据
ISR副本集：同步副本列表
OSR副本集：非同步副本列表
b.副本同步
Follower从Leader拉取数据
HW高水位：所有ISR副本已同步的offset
LEO日志末端：副本最新消息的offset
保证数据一致性
c.故障恢复
Leader故障：从ISR中选举新Leader
Follower故障：移出ISR，恢复后重新加入
Broker故障：分区Leader重新选举
数据不丢失保证
07.存储机制
a.日志文件
分段存储：每个分区多个segment
.log文件：存储消息数据
.index文件：offset索引
.timeindex文件：时间戳索引
b.消息格式
offset：消息偏移量
timestamp：时间戳
key：消息键
value：消息值
headers：消息头
c.日志清理
delete策略：超过保留时间删除
compact策略：保留每个key的最新值
log.retention.hours：保留时间
log.retention.bytes：保留大小
08.性能优化
a.Producer优化
batch.size增大批量大小
linger.ms增加延迟提高吞吐
compression.type启用压缩
buffer.memory增加缓冲区
b.Consumer优化
max.poll.records增加拉取量
fetch.min.bytes增加最小拉取大小
增加消费者数量
合理设置消费组
c.Broker优化
num.network.threads增加网络线程
num.io.threads增加IO线程
log.segment.bytes调整段大小
使用RAID10提高IO性能
09.监控管理
a.监控指标
消息吞吐量：messages/sec
字节吞吐量：bytes/sec
消费延迟：lag
副本同步状态：ISR
b.管理工具
kafka-topics.sh：Topic管理
kafka-consumer-groups.sh：消费组管理
kafka-configs.sh：配置管理
kafka-reassign-partitions.sh：分区重分配
c.第三方工具
Kafka Manager：Web管理界面
Kafka Monitor：监控工具
Burrow：消费延迟监控
Cruise Control：集群自动化管理
10.应用场景
a.消息系统
异步解耦
削峰填谷
消息持久化
高可靠性
b.日志收集
应用日志聚合
系统日志收集
实时日志分析
日志存储
c.流处理
实时计算
数据管道
事件驱动
Kafka Streams
d.数据集成
数据同步
CDC变更捕获
ETL处理
数据湖导入
2.3 azkaban：任务调度
01.介绍
Azkaban是LinkedIn开源的批量工作流任务调度器。
用于在Hadoop环境中运行一组作业，支持工作流依赖管理。
提供Web界面管理和监控任务执行。
支持多种作业类型，包括command、java、pig、hive等。
02.核心概念
a.Project项目
工作流的容器
包含多个Flow
版本管理
权限控制
b.Flow工作流
由多个Job组成
定义Job执行顺序
支持依赖关系
可嵌套子Flow
c.Job作业
最小执行单元
支持多种类型
可配置参数
失败重试
d.Schedule调度
定时触发Flow
Cron表达式
依赖调度
手动触发
03.架构组件
a.AzkabanWebServer
Web界面
用户认证
项目管理
调度管理
b.AzkabanExecutorServer
执行Job
资源管理
日志收集
状态上报
c.MySQL数据库
存储元数据
项目信息
执行历史
调度配置
04.Job类型
a.Command类型
type=command
执行Shell脚本
支持环境变量
返回退出码
b.Java类型
type=java
执行Java程序
指定main类
传递参数
c.Hive类型
type=hive
执行Hive SQL
支持参数化
结果输出
d.Pig类型
type=pig
执行Pig脚本
数据处理
支持UDF
05.工作流定义
a.Job文件格式
name.job文件
key=value格式
type：作业类型
command：执行命令
dependencies：依赖作业
b.Flow文件格式
name.flow文件
YAML格式
nodes：作业节点
edges：依赖关系
c.依赖关系
串行依赖：A->B->C
并行执行：A,B->C
条件依赖：基于返回值
跨Flow依赖
06.调度配置
a.Cron调度
schedule.type=cron
schedule.value：Cron表达式
0 0 * * * ?：每天0点
0 */2 * * * ?：每2小时
b.依赖调度
基于其他Flow完成
检查执行状态
触发下游Flow
级联调度
c.失败处理
failure.emails：失败通知邮件
retries：重试次数
retry.backoff：重试间隔
failure.action：失败动作
07.权限管理
a.用户角色
Admin：管理员权限
Read：只读权限
Write：写入权限
Execute：执行权限
Schedule：调度权限
b.项目权限
Owner：项目所有者
添加用户
分配角色
权限继承
c.认证方式
XML文件认证
LDAP认证
数据库认证
自定义认证
08.监控告警
a.执行监控
实时查看日志
执行进度
资源使用
执行历史
b.告警通知
邮件通知
成功通知
失败通知
SLA告警
c.性能指标
执行时长
成功率
失败率
资源消耗
09.最佳实践
a.工作流设计
合理拆分Job
控制依赖复杂度
避免循环依赖
使用子Flow
b.参数管理
使用properties文件
环境变量传递
参数化配置
敏感信息加密
c.错误处理
设置重试策略
配置告警通知
日志详细记录
失败回滚机制
10.运维管理
a.部署架构
单机模式：开发测试
双机模式：Web+Executor
集群模式：多Executor
高可用配置
b.性能优化
增加Executor节点
调整线程池大小
优化数据库连接
日志定期清理
c.故障处理
Web服务重启
Executor故障转移
数据库备份恢复
日志排查问题
2.4 oozie：工作流调度
01.介绍
Apache Oozie是Hadoop平台的工作流调度系统。
专门为Hadoop生态设计，支持MapReduce、Pig、Hive、Sqoop等作业。
基于XML定义工作流，支持复杂的依赖关系和控制逻辑。
提供协调器（Coordinator）和捆绑包（Bundle）功能。
02.核心概念
a.Workflow工作流
有向无环图DAG
定义作业执行顺序
支持控制节点
XML格式定义
b.Coordinator协调器
基于时间和数据触发
周期性执行Workflow
数据依赖检查
SLA监控
c.Bundle捆绑包
管理多个Coordinator
统一启动停止
版本管理
批量操作
d.Action动作
执行具体任务
MapReduce、Hive、Pig等
支持自定义Action
失败重试
03.工作流节点
a.控制节点
start：开始节点
end：结束节点
kill：终止节点
decision：条件分支
fork/join：并行执行
b.动作节点
map-reduce：MapReduce作业
pig：Pig脚本
hive：Hive SQL
sqoop：数据导入导出
shell：Shell脚本
java：Java程序
spark：Spark作业
c.流程控制
decision：条件判断
switch-case：多分支
fork：并行分支
join：汇聚节点
04.Workflow定义
a.workflow.xml
<workflow-app name="sample" xmlns="uri:oozie:workflow:0.5">
<start to="mr-node"/>
<action name="mr-node">
<map-reduce>
<job-tracker>${jobTracker}</job-tracker>
<name-node>${nameNode}</name-node>
<configuration>...</configuration>
</map-reduce>
<ok to="end"/>
<error to="fail"/>
</action>
<kill name="fail">
<message>Workflow failed</message>
</kill>
<end name="end"/>
</workflow-app>
b.job.properties
nameNode=hdfs://localhost:9000
jobTracker=localhost:8032
queueName=default
oozie.wf.application.path=${nameNode}/user/oozie/workflow
c.参数传递
${变量名}：引用参数
EL表达式：${fs:exists(path)}
系统变量：${wf:id()}
用户变量：job.properties定义
05.Coordinator定义
a.coordinator.xml
<coordinator-app name="sample-coord" frequency="${coord:days(1)}" start="${start}" end="${end}" timezone="UTC" xmlns="uri:oozie:coordinator:0.4">
<datasets>
<dataset name="input" frequency="${coord:days(1)}" initial-instance="${start}" timezone="UTC">
<uri-template>${nameNode}/data/${YEAR}/${MONTH}/${DAY}</uri-template>
</dataset>
</datasets>
<action>
<workflow>
<app-path>${workflowPath}</app-path>
</workflow>
</action>
</coordinator-app>
b.时间触发
frequency：执行频率
coord:days(1)：每天
coord:hours(2)：每2小时
coord:minutes(30)：每30分钟
c.数据依赖
dataset：数据集定义
data-in：输入数据
data-out：输出数据
等待数据就绪
06.Bundle定义
a.bundle.xml
<bundle-app name="sample-bundle" xmlns="uri:oozie:bundle:0.2">
<coordinator name="coord1">
<app-path>${nameNode}/user/oozie/coord1</app-path>
<configuration>
<property>
<name>start</name>
<value>${start}</value>
</property>
</configuration>
</coordinator>
<coordinator name="coord2">
<app-path>${nameNode}/user/oozie/coord2</app-path>
</coordinator>
</bundle-app>
b.批量管理
统一启动多个Coordinator
统一停止
统一暂停恢复
版本控制
07.作业提交
a.命令行提交
oozie job -oozie http://localhost:11000/oozie -config job.properties -run
oozie job -info <job-id>：查看作业信息
oozie job -kill <job-id>：终止作业
oozie job -suspend <job-id>：暂停作业
oozie job -resume <job-id>：恢复作业
b.REST API
POST /oozie/v1/jobs：提交作业
GET /oozie/v1/job/<job-id>：查询作业
PUT /oozie/v1/job/<job-id>?action=kill：终止作业
c.Java API
OozieClient client = new OozieClient("http://localhost:11000/oozie");
Properties conf = client.createConfiguration();
conf.setProperty(OozieClient.APP_PATH, "hdfs://localhost:9000/user/oozie/workflow");
String jobId = client.run(conf);
08.SLA监控
a.SLA配置
<sla:info xmlns:sla="uri:oozie:sla:0.2">
<sla:nominal-time>${nominalTime}</sla:nominal-time>
<sla:should-start>${10 * MINUTES}</sla:should-start>
<sla:should-end>${30 * MINUTES}</sla:should-end>
<sla:alert-events>start_miss,end_miss</sla:alert-events>
<sla:alert-contact>admin@example.com</sla:alert-contact>
</sla:info>
b.监控指标
should-start：应该开始时间
should-end：应该结束时间
alert-events：告警事件
alert-contact：告警联系人
c.告警通知
邮件通知
JMS消息
自定义通知
告警升级
09.高可用配置
a.HA架构
多个Oozie Server
ZooKeeper协调
共享数据库
负载均衡
b.故障转移
自动切换
作业迁移
状态同步
数据一致性
c.数据库配置
MySQL/PostgreSQL
连接池配置
事务管理
定期备份
10.最佳实践
a.工作流设计
合理拆分Action
使用fork/join并行
设置合理超时
错误处理机制
b.性能优化
减少Action数量
合并小作业
使用Coordinator批处理
优化HDFS访问
c.运维管理
定期清理历史数据
监控作业执行
日志归档
版本管理
2.5 airflow：工作流调度
01.介绍
Apache Airflow是Python编写的工作流调度平台。
使用Python代码定义工作流，灵活性高。
提供丰富的Operator支持多种任务类型。
Web界面管理和监控，支持动态工作流。
02.核心概念
a.DAG有向无环图
定义工作流结构
Python代码编写
任务依赖关系
调度配置
b.Operator操作符
任务的抽象
BashOperator：执行Shell
PythonOperator：执行Python函数
EmailOperator：发送邮件
自定义Operator
c.Task任务
Operator的实例
执行单元
状态管理
重试机制
d.Task Instance
Task的执行实例
execution_date标识
状态跟踪
日志记录
03.架构组件
a.Scheduler调度器
解析DAG文件
触发任务执行
监控任务状态
依赖检查
b.Executor执行器
SequentialExecutor：顺序执行
LocalExecutor：本地多进程
CeleryExecutor：分布式执行
KubernetesExecutor：K8s执行
c.Web Server
Web界面
DAG管理
任务监控
日志查看
d.Metadata Database
存储元数据
DAG信息
任务状态
执行历史
04.DAG定义
a.基本结构
from airflow import DAG
from airflow.operators.bash import BashOperator
from datetime import datetime, timedelta
default_args = {
'owner': 'airflow',
'depends_on_past': False,
'start_date': datetime(2024, 1, 1),
'email_on_failure': True,
'email_on_retry': False,
'retries': 1,
'retry_delay': timedelta(minutes=5),
}
dag = DAG('example_dag', default_args=default_args, schedule_interval='@daily')
b.任务定义
task1 = BashOperator(task_id='print_date', bash_command='date', dag=dag)
task2 = BashOperator(task_id='sleep', bash_command='sleep 5', dag=dag)
task3 = BashOperator(task_id='print_hello', bash_command='echo "hello"', dag=dag)
c.依赖关系
task1 >> task2 >> task3：串行
task1 >> [task2, task3]：并行
task1.set_downstream(task2)：设置下游
task2.set_upstream(task1)：设置上游
05.常用Operator
a.BashOperator
执行Shell命令
bash_command：命令字符串
env：环境变量
返回退出码
b.PythonOperator
执行Python函数
python_callable：函数对象
op_args：位置参数
op_kwargs：关键字参数
c.EmailOperator
发送邮件
to：收件人
subject：主题
html_content：邮件内容
d.HttpOperator
HTTP请求
endpoint：API端点
method：请求方法
data：请求数据
06.调度配置
a.schedule_interval
'@once'：执行一次
'@hourly'：每小时
'@daily'：每天
'@weekly'：每周
'@monthly'：每月
Cron表达式：'0 0 * * *'
b.时间参数
start_date：开始日期
end_date：结束日期
execution_date：执行日期
catchup：是否回填
c.依赖触发
TriggerDagRunOperator：触发其他DAG
ExternalTaskSensor：等待外部任务
depends_on_past：依赖上次执行
07.XCom通信
a.推送数据
task_instance.xcom_push(key='key', value='value')
return value：自动推送return_value
b.拉取数据
task_instance.xcom_pull(task_ids='task1', key='key')
ti.xcom_pull(task_ids='task1')：拉取return_value
c.使用场景
任务间传递数据
共享配置
状态传递
小数据量（<1MB）
08.Sensor传感器
a.FileSensor
等待文件出现
filepath：文件路径
poke_interval：检查间隔
timeout：超时时间
b.HttpSensor
等待HTTP响应
endpoint：API端点
response_check：响应检查函数
c.ExternalTaskSensor
等待其他任务完成
external_dag_id：外部DAG ID
external_task_id：外部Task ID
d.自定义Sensor
继承BaseSensorOperator
实现poke方法
返回True/False
09.监控告警
a.Web界面
DAG视图：工作流结构
Tree视图：执行历史
Gantt图：时间分布
日志查看：任务日志
b.邮件告警
email_on_failure：失败通知
email_on_retry：重试通知
email_on_success：成功通知
email：收件人列表
c.SLA监控
sla：任务SLA时间
sla_miss_callback：SLA违反回调
check_slas：SLA检查
d.Metrics指标
Prometheus集成
StatsD集成
自定义指标
监控大盘
10.最佳实践
a.DAG设计
保持DAG简单
避免动态生成过多任务
合理设置依赖
使用SubDAG拆分
b.性能优化
并行度配置
使用连接池
优化Sensor检查间隔
定期清理元数据
c.错误处理
设置重试策略
配置告警通知
on_failure_callback
on_retry_callback
2.6 dolphinscheduler：任务调度
01.介绍
Apache DolphinScheduler是分布式易扩展的可视化工作流任务调度平台。
国产开源项目，由易观开源。
支持多种任务类型，提供拖拽式工作流设计。
高可用、高性能、易扩展。
02.核心概念
a.Project项目
工作流的容器
权限隔离
资源管理
成员管理
b.Process Definition
工作流定义
DAG结构
任务节点
依赖关系
c.Task任务
Shell、SQL、Python等
参数配置
资源文件
环境变量
d.Instance实例
工作流实例
任务实例
执行状态
日志记录
03.架构组件
a.Master Server
工作流调度
任务分发
监控管理
故障转移
b.Worker Server
任务执行
日志上报
心跳检测
资源隔离
c.API Server
REST API
Web界面后端
用户认证
权限控制
d.Alert Server
告警服务
邮件通知
钉钉、企业微信
自定义插件
04.任务类型
a.Shell任务
执行Shell脚本
自定义脚本
资源文件
环境变量
b.SQL任务
MySQL、PostgreSQL
Hive、Spark SQL
ClickHouse
参数化SQL
c.Python任务
执行Python脚本
依赖管理
虚拟环境
参数传递
d.Spark任务
Spark Submit
Spark SQL
PySpark
资源配置
e.Flink任务
Flink Run
Flink SQL
检查点配置
资源管理
f.其他任务
HTTP任务
DataX任务
Sqoop任务
Procedure任务
05.工作流设计
a.拖拽式设计
可视化画布
拖拽任务节点
连线定义依赖
参数配置
b.任务依赖
串行依赖
并行执行
条件分支
子流程
c.全局参数
${变量名}
系统参数
自定义参数
参数传递
d.资源管理
上传资源文件
UDF函数
文件引用
版本管理
06.调度配置
a.定时调度
Cron表达式
开始时间
结束时间
时区设置
b.依赖调度
依赖其他工作流
自依赖
跨项目依赖
补数据
c.优先级
工作流优先级
任务优先级
队列管理
资源分配
d.失败策略
继续执行
结束流程
通知告警
重试策略
07.告警配置
a.告警类型
邮件告警
钉钉告警
企业微信
Webhook
b.告警规则
成功通知
失败通知
超时通知
自定义规则
c.告警组
告警组管理
成员管理
通知策略
告警升级
08.权限管理
a.租户管理
租户隔离
资源配额
队列管理
Linux用户映射
b.用户角色
管理员
普通用户
项目权限
资源权限
c.Token认证
API Token
过期时间
权限范围
安全管理
09.监控运维
a.监控指标
工作流执行状态
任务成功率
执行时长
资源使用
b.日志管理
任务日志
工作流日志
系统日志
日志下载
c.数据补录
历史数据补录
批量补数
依赖补数
补数策略
d.集群管理
Master管理
Worker管理
服务监控
故障恢复
10.最佳实践
a.工作流设计
合理拆分任务
控制任务数量
设置超时时间
错误处理
b.资源管理
合理分配资源
使用资源组
队列管理
优先级设置
c.性能优化
并行度配置
Worker扩容
数据库优化
日志清理
d.高可用
Master HA
Worker HA
数据库HA
监控告警
3 查询与分析引擎
3.1 presto：分布式SQL查询
01.介绍
Presto是Facebook开源的分布式SQL查询引擎。
专为交互式分析查询设计，支持PB级数据查询。
采用MPP架构，内存计算，查询速度快。
支持多种数据源，包括Hive、MySQL、Kafka、Elasticsearch等。
02.核心概念
a.Coordinator协调器
接收查询请求
解析SQL语句
生成执行计划
调度任务执行
汇总结果返回
b.Worker工作节点
执行查询任务
处理数据
中间结果交换
内存管理
c.Connector连接器
数据源适配器
元数据获取
数据读取
谓词下推
d.Catalog目录
数据源配置
Schema映射
表定义
权限控制
03.架构特点
a.MPP架构
大规模并行处理
无共享架构
流水线执行
内存计算
b.内存计算
数据不落盘
中间结果内存传输
快速响应
资源消耗大
c.分布式执行
查询分解为Stage
Stage分解为Task
Task分配到Worker
并行执行
d.优化器
基于成本优化CBO
谓词下推
列裁剪
JOIN重排序
04.数据源支持
a.Hive Connector
读取Hive表
支持ORC、Parquet
分区裁剪
元数据缓存
b.MySQL Connector
连接MySQL数据库
谓词下推
JOIN下推
事务支持
c.Kafka Connector
实时读取Kafka
JSON、Avro格式
时间范围查询
流式处理
d.其他Connector
PostgreSQL
MongoDB
Elasticsearch
Redis
自定义Connector
05.SQL查询
a.基本查询
SELECT * FROM hive.default.users WHERE age > 18;
SELECT COUNT(*) FROM mysql.db.orders;
SELECT * FROM kafka.topic.events LIMIT 100;
b.JOIN查询
SELECT u.name, o.amount
FROM hive.default.users u
JOIN mysql.db.orders o ON u.id = o.user_id;
跨数据源JOIN
c.聚合查询
SELECT region, COUNT(*), SUM(amount)
FROM hive.default.sales
GROUP BY region
ORDER BY SUM(amount) DESC;
d.窗口函数
SELECT name, salary,
ROW_NUMBER() OVER (PARTITION BY dept ORDER BY salary DESC) as rank
FROM employees;
06.性能优化
a.数据分区
按分区键查询
分区裁剪
减少扫描数据量
提高查询速度
b.数据格式
使用ORC、Parquet
列式存储
压缩编码
减少IO
c.查询优化
避免SELECT *
使用LIMIT限制结果
合理使用WHERE过滤
优化JOIN顺序
d.资源配置
增加Worker节点
调整内存配置
并发度控制
队列管理
07.配置管理
a.config.properties
coordinator=true/false
http-server.http.port=8080
query.max-memory=50GB
query.max-memory-per-node=10GB
discovery.uri=http://coordinator:8080
b.jvm.config
-Xmx16G：最大堆内存
-XX:+UseG1GC：GC算法
-XX:G1HeapRegionSize=32M
-XX:+ExplicitGCInvokesConcurrent
c.catalog配置
connector.name=hive-hadoop2
hive.metastore.uri=thrift://localhost:9083
hive.config.resources=/etc/hadoop/core-site.xml
08.监控管理
a.Web界面
http://coordinator:8080
查询列表
执行计划
资源使用
集群状态
b.监控指标
查询QPS
查询延迟
内存使用
CPU使用
失败率
c.日志管理
server.log：服务日志
http-request.log：请求日志
launcher.log：启动日志
日志级别配置
09.高可用
a.Coordinator HA
多个Coordinator
负载均衡
故障转移
会话保持
b.Worker扩展
动态添加Worker
自动发现
负载均衡
故障隔离
c.元数据缓存
Hive元数据缓存
减少Metastore压力
提高查询速度
定期刷新
10.最佳实践
a.查询优化
使用分区过滤
避免大表JOIN
合理使用聚合
限制结果集大小
b.资源管理
合理配置内存
控制并发查询
使用资源组
队列管理
c.数据组织
合理分区
使用列式格式
数据压缩
小文件合并
3.10 solr：搜索引擎
01.介绍
Apache Solr是基于Lucene的企业级搜索平台。
功能强大，配置灵活，扩展性好。
支持全文检索、分面搜索、实时索引。
提供REST API和管理界面。
02.核心概念
a.Core核心
独立的索引实例
配置文件
Schema定义
数据目录
b.Collection集合
分布式索引
多个Shard组成
副本机制
SolrCloud模式
c.Shard分片
数据分区
水平扩展
并行查询
负载均衡
d.Replica副本
数据备份
高可用
读负载分担
故障转移
03.架构模式
a.Standalone模式
单机部署
简单配置
适合开发测试
无高可用
b.Master-Slave模式
主从复制
读写分离
手动故障转移
配置复杂
c.SolrCloud模式
分布式架构
ZooKeeper协调
自动分片
自动故障转移
04.Schema定义
a.字段类型
<fieldType name="text_general" class="solr.TextField">
<analyzer>
<tokenizer class="solr.StandardTokenizerFactory"/>
<filter class="solr.LowerCaseFilterFactory"/>
</analyzer>
</fieldType>
b.字段定义
<field name="id" type="string" indexed="true" stored="true" required="true"/>
<field name="title" type="text_general" indexed="true" stored="true"/>
<field name="price" type="pdouble" indexed="true" stored="true"/>
indexed：是否索引
stored：是否存储
required：是否必填
c.动态字段
<dynamicField name="*_i" type="pint" indexed="true" stored="true"/>
<dynamicField name="*_s" type="string" indexed="true" stored="true"/>
通配符匹配
d.Copy Field
<copyField source="title" dest="text"/>
<copyField source="content" dest="text"/>
字段复制
05.数据导入
a.Post工具
bin/post -c my_core data.json
bin/post -c my_core data.xml
bin/post -c my_core data.csv
命令行导入
b.DataImportHandler
配置数据源
SQL查询
增量导入
定时任务
c.SolrJ客户端
SolrClient client = new HttpSolrClient.Builder("http://localhost:8983/solr/my_core").build();
SolrInputDocument doc = new SolrInputDocument();
doc.addField("id", "1");
doc.addField("title", "Product");
client.add(doc);
client.commit();
d.批量导入
client.add(docList);
client.commit();
提高效率
06.查询语法
a.基本查询
q=title:product：字段查询
q=title:product AND price:[50 TO 100]：组合查询
q=*:*：查询所有
fq=category:electronics：过滤查询
b.查询参数
q：查询条件
fq：过滤条件
sort：排序
start：起始位置
rows：返回数量
fl：返回字段
c.高级查询
q={!dismax qf='title^2 content'}product
DisMax查询
权重提升
多字段查询
d.查询示例
http://localhost:8983/solr/my_core/select?q=title:product&fq=price:[50 TO 100]&sort=price asc&start=0&rows=10
07.分面搜索
a.字段分面
facet=true
facet.field=category
facet.field=brand
统计分组数量
b.查询分面
facet.query=price:[0 TO 50]
facet.query=price:[50 TO 100]
自定义范围统计
c.范围分面
facet.range=price
facet.range.start=0
facet.range.end=1000
facet.range.gap=100
区间统计
d.Pivot分面
facet.pivot=category,brand
多维度分面
层级统计
08.高亮显示
a.高亮配置
hl=true
hl.fl=title,content
hl.simple.pre=<em>
hl.simple.post=</em>
hl.fragsize=100
b.高亮结果
返回高亮片段
匹配词高亮
自定义标签
片段长度
09.性能优化
a.索引优化
合理分片
副本配置
commit策略
merge策略
b.查询优化
使用fq过滤
缓存利用
避免深度分页
字段裁剪
c.缓存配置
queryResultCache：查询结果缓存
documentCache：文档缓存
filterCache：过滤缓存
fieldValueCache：字段值缓存
d.JVM优化
堆内存配置
GC算法选择
GC参数调优
监控GC日志
10.监控管理
a.Admin界面
http://localhost:8983/solr
Core管理
查询测试
Schema浏览
日志查看
b.监控指标
索引大小
文档数量
查询QPS
缓存命中率
JVM内存
c.管理API
Core管理API
Collection管理API
Config管理API
Schema管理API
3.2 impala：实时查询
01.介绍
Apache Impala是Cloudera开源的MPP SQL查询引擎。
专为Hadoop设计，直接访问HDFS和HBase数据。
C++实现，性能优异，低延迟。
与Hive共享元数据，兼容HiveQL。
02.核心组件
a.Impalad守护进程
运行在每个DataNode
接收查询请求
执行查询任务
返回结果
b.Statestore状态存储
跟踪集群状态
节点健康检查
元数据分发
故障检测
c.Catalogd目录服务
管理元数据
DDL操作
元数据缓存
变更通知
d.Admission Control
并发控制
资源管理
队列管理
查询排队
03.查询执行
a.查询流程
客户端连接Impalad
解析SQL生成执行计划
分发到各节点执行
流式返回结果
b.执行计划
分布式执行
并行扫描
本地计算
结果聚合
c.内存管理
内存池管理
Spill to Disk
内存限制
OOM处理
d.调度策略
数据本地性
负载均衡
资源感知
动态调度
04.数据格式
a.Parquet格式
列式存储
高效压缩
谓词下推
列裁剪
推荐使用
b.ORC格式
列式存储
索引支持
事务支持
压缩效率高
c.Text格式
文本文件
易于生成
性能较低
适合小数据
d.Avro格式
行式存储
Schema演进
序列化框架
适合流式数据
05.分区表
a.静态分区
CREATE TABLE sales (id INT, amount DECIMAL)
PARTITIONED BY (year INT, month INT)
STORED AS PARQUET;
INSERT INTO sales PARTITION(year=2024, month=1) VALUES (1, 100.0);
b.动态分区
INSERT INTO sales PARTITION(year, month)
SELECT id, amount, year, month FROM source;
自动创建分区
c.分区裁剪
SELECT * FROM sales WHERE year=2024 AND month=1;
只扫描相关分区
提高查询性能
06.性能优化
a.统计信息
COMPUTE STATS table_name;
收集表统计信息
优化执行计划
定期更新
b.查询优化
使用分区过滤
避免SELECT *
合理使用JOIN
利用统计信息
c.资源配置
mem_limit：内存限制
request_pool：资源池
max_row_size：最大行大小
batch_size：批量大小
d.并发控制
admission_control_enabled
max_requests：最大请求数
max_queued：最大排队数
queue_timeout_ms：排队超时
07.与Hive集成
a.共享元数据
使用Hive Metastore
表定义共享
分区信息共享
权限共享
b.兼容HiveQL
支持大部分Hive语法
UDF兼容
SerDe支持
文件格式兼容
c.元数据刷新
REFRESH table_name;
INVALIDATE METADATA table_name;
增量刷新
全量刷新
08.Kudu集成
a.Kudu表
CREATE TABLE kudu_table (id INT PRIMARY KEY, name STRING)
PARTITION BY HASH(id) PARTITIONS 4
STORED AS KUDU;
b.实时更新
INSERT INTO kudu_table VALUES (1, 'Alice');
UPDATE kudu_table SET name='Bob' WHERE id=1;
DELETE FROM kudu_table WHERE id=1;
UPSERT INTO kudu_table VALUES (1, 'Charlie');
c.性能优势
快速随机访问
实时更新
列式存储
低延迟查询
09.监控管理
a.Web界面
http://impalad:25000
查询列表
执行计划
资源使用
日志查看
b.监控指标
查询延迟
吞吐量
内存使用
CPU使用
失败率
c.日志管理
impalad.INFO：信息日志
impalad.WARNING：警告日志
impalad.ERROR：错误日志
audit.log：审计日志
10.最佳实践
a.表设计
使用Parquet格式
合理分区
收集统计信息
避免小文件
b.查询优化
分区过滤
列裁剪
合理JOIN
使用LIMIT
c.资源管理
配置资源池
并发控制
内存限制
队列管理
3.3 druid：实时分析
01.介绍
Apache Druid是实时分析数据库，专为OLAP设计。
支持亚秒级查询，高并发，低延迟。
列式存储，预聚合，时间序列优化。
适合实时数据分析、用户行为分析、监控等场景。
02.核心概念
a.DataSource数据源
类似表的概念
时间序列数据
维度和指标
分段存储
b.Segment数据段
数据存储单元
按时间分区
不可变
列式存储
c.Dimension维度
分组字段
字符串类型
支持过滤
支持分组
d.Metric指标
聚合字段
数值类型
预聚合
支持多种聚合函数
03.架构组件
a.Coordinator协调器
管理Segment
负载均衡
数据保留策略
元数据管理
b.Overlord监督者
任务管理
索引任务调度
资源分配
任务监控
c.Broker代理
接收查询请求
路由查询
合并结果
缓存管理
d.Historical历史节点
存储历史数据
处理查询
Segment加载
缓存数据
e.MiddleManager中间管理器
运行索引任务
实时数据摄入
Segment生成
资源隔离
04.数据摄入
a.批量摄入
从HDFS、S3加载
Hadoop索引任务
并行处理
历史数据导入
b.流式摄入
Kafka索引服务
Kinesis索引服务
实时数据摄入
exactly-once语义
c.摄入规范
dataSchema：数据模式
ioConfig：输入输出配置
tuningConfig：调优配置
JSON格式定义
d.数据转换
transformSpec：转换规则
filter：数据过滤
dimensionsSpec：维度定义
metricsSpec：指标定义
05.查询类型
a.Timeseries查询
时间序列聚合
按时间分组
指标计算
趋势分析
b.TopN查询
Top K查询
排序聚合
维度排名
高性能
c.GroupBy查询
多维分组
灵活聚合
复杂查询
资源消耗大
d.Scan查询
原始数据扫描
明细查询
分页支持
大数据量
06.SQL查询
a.基本查询
SELECT __time, country, SUM(revenue) as total
FROM datasource
WHERE __time >= TIMESTAMP '2024-01-01'
GROUP BY __time, country
ORDER BY total DESC
LIMIT 10;
b.时间函数
FLOOR(__time TO DAY)：按天聚合
TIME_FLOOR(__time, 'PT1H')：按小时聚合
TIMESTAMPADD：时间加减
TIMESTAMPDIFF：时间差
c.聚合函数
SUM、COUNT、AVG
MAX、MIN
APPROX_COUNT_DISTINCT：近似去重
APPROX_QUANTILE：近似分位数
07.Rollup聚合
a.预聚合
摄入时聚合
减少数据量
提高查询速度
损失明细
b.Rollup配置
granularitySpec：时间粒度
queryGranularity：查询粒度
rollup：是否启用
aggregators：聚合器
c.适用场景
指标监控
报表统计
趋势分析
不需要明细
08.性能优化
a.数据建模
合理选择维度
预聚合指标
时间粒度
数据分区
b.查询优化
使用时间过滤
TopN替代GroupBy
近似聚合
结果缓存
c.集群配置
增加Historical节点
调整Segment大小
配置缓存
资源分配
d.索引优化
Bitmap索引
字典编码
压缩算法
分段策略
09.监控管理
a.Web界面
Coordinator控制台
Overlord控制台
任务监控
Segment管理
b.监控指标
查询延迟
吞吐量
Segment数量
缓存命中率
任务状态
c.告警配置
查询失败告警
摄入失败告警
资源告警
自定义告警
10.最佳实践
a.数据建模
时间为主键
合理维度设计
预聚合指标
控制基数
b.摄入优化
批量摄入大数据
流式摄入实时数据
合理分区
并行处理
c.查询优化
时间范围过滤
使用TopN
近似计算
缓存利用
3.4 trino：SQL查询引擎
01.介绍
Trino（原名 PrestoSQL）是一个开源的分布式 SQL 查询引擎，专为大数据分析而设计。
它可以对存储在不同数据源（如 HDFS、S3、MySQL、PostgreSQL、Kafka 等）中的数据进行快速交互式查询。
Trino 采用 MPP（大规模并行处理）架构，能够在秒级内查询 PB 级别的数据。
02.核心特性
a.联邦查询
跨多个数据源查询
统一 SQL 接口
无需数据迁移
支持 JOIN 跨源数据
b.高性能
内存计算引擎
流水线执行
向量化执行
代码生成优化
c.标准SQL支持
ANSI SQL 兼容
丰富的函数库
窗口函数
子查询和 CTE
d.可扩展性
水平扩展
动态添加节点
支持数千节点集群
PB 级数据查询
03.架构组件
a.Coordinator
接收客户端查询
解析和优化 SQL
生成执行计划
调度任务到 Worker
聚合最终结果
b.Worker
执行查询任务
读取数据源
处理数据
返回结果给 Coordinator
可动态扩展
c.Connector
连接不同数据源
内置多种 Connector
可自定义 Connector
统一数据访问接口
d.Catalog
定义数据源
配置连接信息
管理 Schema
权限控制
04.支持的数据源
a.关系型数据库
MySQL
PostgreSQL
Oracle
SQL Server
通过 JDBC Connector
b.大数据存储
HDFS（Hive）
Amazon S3
Azure Blob Storage
Google Cloud Storage
Iceberg、Delta Lake、Hudi
c.NoSQL数据库
MongoDB
Cassandra
Elasticsearch
Redis
d.消息队列
Kafka
Kinesis
实时数据流
e.其他
ClickHouse
Druid
Pinot
自定义 Connector
05.查询优化
a.CBO（基于成本的优化）
统计信息收集
成本估算
最优执行计划
JOIN 顺序优化
b.谓词下推
过滤条件下推到数据源
减少数据传输
提高查询性能
c.列裁剪
只读取需要的列
减少 I/O
列式存储优化
d.分区裁剪
利用分区信息
跳过不相关分区
加速查询
e.动态过滤
运行时过滤
减少数据扫描
JOIN 优化
06.使用场景
a.交互式分析
即席查询
数据探索
BI 报表
快速响应
b.数据湖查询
查询 S3/HDFS 数据
Iceberg/Delta Lake
无需数据移动
统一查询接口
c.ETL处理
数据转换
跨源数据集成
INSERT INTO SELECT
CTAS（Create Table As Select）
d.联邦查询
跨数据库查询
数据整合
实时数据 + 历史数据
统一视图
07.SQL示例
a.基本查询
SELECT * FROM hive.default.orders WHERE order_date >= DATE '2024-01-01';
指定 catalog.schema.table
标准 SQL 语法
b.跨源JOIN
SELECT o.order_id, c.customer_name
FROM mysql.sales.orders o
JOIN postgresql.crm.customers c ON o.customer_id = c.id;
跨数据库 JOIN
无需数据迁移
c.聚合查询
SELECT product_id, COUNT(*), SUM(amount)
FROM hive.default.sales
GROUP BY product_id
HAVING SUM(amount) > 10000;
分组聚合
HAVING 过滤
d.窗口函数
SELECT order_id, amount,
ROW_NUMBER() OVER (PARTITION BY customer_id ORDER BY amount DESC) as rank
FROM orders;
窗口函数
排名分析
e.CTAS
CREATE TABLE hive.default.summary AS
SELECT product_id, SUM(amount) as total
FROM mysql.sales.orders
GROUP BY product_id;
创建表并插入数据
跨源 ETL
08.性能优化
a.分区和分桶
利用分区信息
合理设计分桶
提高并行度
b.数据格式
使用 Parquet/ORC
列式存储
压缩数据
减少 I/O
c.内存配置
调整 JVM 堆内存
配置查询内存限制
避免 OOM
d.并行度调整
task.concurrency
task.max-worker-threads
合理设置并行度
e.缓存
元数据缓存
统计信息缓存
减少重复计算
09.与其他工具对比
a.vs Presto
Trino 是 Presto 的分支
更活跃的社区
更多新特性
兼容性好
b.vs Spark SQL
Trino 更快的交互式查询
Spark 更适合批处理
Trino 无需数据加载
Spark 支持更多算法
c.vs Impala
Trino 支持更多数据源
Impala 与 Hadoop 集成更紧密
Trino 更灵活
Impala 性能更稳定
d.vs Hive
Trino 更快的查询速度
Hive 更成熟稳定
Trino 交互式查询
Hive 批处理
10.部署和运维
a.部署模式
单机模式（开发测试）
集群模式（生产环境）
容器化部署（Docker/K8s）
云服务（AWS EMR、Azure HDInsight）
b.监控指标
查询延迟
吞吐量
资源使用率
失败率
JMX 监控
c.故障排查
查看日志
分析执行计划
检查资源使用
优化慢查询
d.安全配置
认证（LDAP、Kerberos）
授权（基于角色）
加密（TLS/SSL）
审计日志
11.最佳实践
a.合理设计Catalog
按业务划分
配置连接池
设置超时时间
b.优化查询
避免 SELECT *
使用分区过滤
合理使用 JOIN
利用统计信息
c.资源管理
配置资源组
限制查询内存
设置并发数
避免资源争抢
d.数据组织
使用列式格式
合理分区
定期压缩
清理过期数据
3.5 doris：实时分析数据库
01.介绍
Apache Doris 是一个现代化的开源分布式 SQL 数据库管理系统，专为在线分析处理（OLAP）和实时分析而设计。
它提供高性能的查询能力，支持大规模的数据分析和实时数据处理。Doris 的设计目标是提供简单易用的界面，
同时具备高效的数据导入和查询性能。
02.关键特性
a.高性能
通过列式存储和向量化执行引擎，Doris 能够提供快速的查询响应时间
MPP 架构，支持大规模并行处理
智能查询优化器
亚秒级查询响应
b.实时分析
支持实时数据导入和更新
适合需要实时数据分析的场景
毫秒级数据可见
支持流式导入
c.易用性
提供类似 MySQL 的 SQL 接口，降低了学习和使用的门槛
兼容 MySQL 协议
丰富的 SQL 函数
简单的运维管理
d.弹性扩展
支持水平扩展，可以处理从 GB 到 PB 级别的数据
动态增删节点
自动负载均衡
弹性伸缩
e.数据集成
支持多种数据源的集成，方便进行数据的提取、加载和转换（ELT）
丰富的数据导入方式
外部表支持
联邦查询
03.架构组件
a.Frontend（FE）
接收客户端连接
SQL 解析和优化
元数据管理
查询调度
支持主从架构
b.Backend（BE）
存储数据
执行查询
数据压缩和编码
副本管理
可水平扩展
c.Broker
访问外部存储
HDFS、S3 等
数据导入辅助
可选组件
04.数据模型
a.Aggregate 模型
预聚合数据
适合聚合查询
减少存储空间
提高查询性能
示例：SUM、MAX、MIN、REPLACE
b.Unique 模型
主键唯一
支持更新和删除
适合维度表
REPLACE 聚合方式
c.Duplicate 模型
明细数据
不做聚合
适合日志、明细查询
保留所有数据
05.存储引擎
a.列式存储
按列存储数据
高效压缩
适合分析查询
减少 I/O
b.分区和分桶
Range 分区
List 分区
Hash 分桶
灵活的数据组织
c.副本机制
多副本存储
自动故障转移
数据高可用
默认 3 副本
d.索引
前缀索引
Bloom Filter
Bitmap 索引
加速查询
06.数据导入
a.Stream Load
HTTP 导入
实时导入
小批量数据
curl 命令
b.Broker Load
大批量导入
HDFS、S3 数据
异步导入
支持 Parquet、ORC
c.Routine Load
Kafka 实时消费
持续导入
自动容错
exactly-once 语义
d.Insert Into
SQL 插入
小数据量
事务支持
简单易用
e.Spark Load
Spark 批量导入
大数据量
分布式导入
高吞吐量
07.跨源数据处理
a.数据源连接器
Doris支持多种数据源连接器，可使用SQL对这些数据源进行联邦查询
无论是 Hive、Iceberg、Hudi 、Paimon，还是支持 JDBC 协议的数据库系统，Doris 均能轻松连接并高效提取数据
b.支持数据源
Apache Hive
Apache Iceberg
Apache Hudi
Apache Paimon(Incubating)
Elasticsearch
MySQL、Oracle、SQL Server 等主流数据库
JDBC 协议数据源
c.外部数据源集成
通过与外部数据源的集成，实现对外部数据的查询和部分数据导入到 Doris 表中
可以创建 Catalog 读取外部数据源中的数据
使用 INSERT INTO SELECT 将外部数据源中的数据同步写入到 Doris 中
配合 JOB 可以异步写入
d.X2Doris
可以使用 X2Doris 将其他 AP 系统的数据迁移到 Doris 中
支持多种数据源迁移
自动化迁移工具
08.查询优化
a.CBO 优化器
基于成本的优化
统计信息收集
最优执行计划
JOIN 重排序
b.向量化执行
批量处理数据
SIMD 指令
提高 CPU 利用率
加速计算
c.物化视图
预计算结果
加速查询
自动改写
透明使用
d.分区裁剪
利用分区信息
跳过无关分区
减少扫描
提高性能
09.SQL示例
a.建表
CREATE TABLE sales (
order_id BIGINT,
product_id INT,
amount DECIMAL(10,2),
order_date DATE
)
DUPLICATE KEY(order_id)
PARTITION BY RANGE(order_date) (
PARTITION p202401 VALUES LESS THAN ('2024-02-01'),
PARTITION p202402 VALUES LESS THAN ('2024-03-01')
)
DISTRIBUTED BY HASH(order_id) BUCKETS 10;
定义表结构
分区和分桶
b.数据导入
curl --location-trusted -u user:passwd -H "label:label123" \
-H "column_separator:," -T data.csv \
http://fe_host:8030/api/db/table/_stream_load
Stream Load 导入
c.查询
SELECT product_id, SUM(amount) as total
FROM sales
WHERE order_date >= '2024-01-01'
GROUP BY product_id
ORDER BY total DESC
LIMIT 10;
聚合查询
d.外部表查询
CREATE CATALOG hive_catalog PROPERTIES (
"type"="hms",
"hive.metastore.uris" = "thrift://localhost:9083"
);
SELECT * FROM hive_catalog.db.table;
创建 Catalog
查询外部数据
10.使用场景
a.实时数仓
实时数据分析
BI 报表
实时大屏
秒级查询
b.用户画像
多维分析
标签计算
人群圈选
精准营销
c.日志分析
日志存储和查询
实时监控
异常检测
运维分析
d.广告分析
广告效果分析
实时竞价
转化分析
ROI 计算
11.性能优化
a.表设计
合理选择数据模型
设计分区策略
选择分桶键
设置副本数
b.查询优化
避免 SELECT *
使用分区过滤
合理使用索引
优化 JOIN 顺序
c.导入优化
批量导入
合理设置并发
使用压缩
避免小文件
d.资源配置
调整内存配置
设置查询超时
配置并发数
监控资源使用
12.运维管理
a.监控
查询性能监控
资源使用监控
导入任务监控
系统指标监控
b.备份恢复
定期备份
快照备份
增量备份
灾难恢复
c.扩容缩容
动态增加节点
数据自动均衡
平滑扩容
在线操作
d.升级
滚动升级
灰度发布
版本兼容
最小化影响
3.6 clickhouse：实时分析数据库
01.介绍
ClickHouse 是俄罗斯 Yandex 公司开源的一个用于在线分析处理（OLAP）的列式数据库管理系统。
它以极高的查询性能著称，能够在秒级内处理数十亿行数据的复杂查询。
ClickHouse 采用列式存储、向量化执行、数据压缩等技术，是实时分析场景的首选数据库之一。
02.核心特性
a.极致性能
列式存储
向量化执行
数据压缩
并行处理
亿级数据秒级响应
b.SQL 支持
标准 SQL 语法
丰富的函数
窗口函数
JOIN 支持
子查询
c.高可用
数据副本
分片集群
自动故障转移
负载均衡
横向扩展
d.实时写入
高吞吐写入
批量导入
流式写入
异步写入
数据实时可查
03.架构设计
a.存储引擎
MergeTree 系列
MergeTree：基础引擎
ReplacingMergeTree：去重
SummingMergeTree：预聚合
AggregatingMergeTree：聚合
CollapsingMergeTree：折叠
Log 系列
TinyLog：简单日志
Log：日志
StripeLog：条带日志
特殊引擎
Distributed：分布式表
Dictionary：字典
Merge：合并
File：文件
b.表引擎选择
实时分析：MergeTree
去重场景：ReplacingMergeTree
预聚合：SummingMergeTree
状态变更：CollapsingMergeTree
分布式：Distributed
c.分片和副本
分片：水平分区
副本：数据冗余
ZooKeeper 协调
自动同步
高可用保证
04.数据类型
a.数值类型
Int8, Int16, Int32, Int64
UInt8, UInt16, UInt32, UInt64
Float32, Float64
Decimal(P, S)
丰富的数值类型
b.字符串类型
String：变长字符串
FixedString(N)：定长字符串
UUID：唯一标识符
c.日期时间
Date：日期
DateTime：日期时间
DateTime64：高精度时间
时区支持
d.复杂类型
Array(T)：数组
Tuple(T1, T2, ...)：元组
Map(K, V)：映射
Nested：嵌套结构
e.特殊类型
Nullable(T)：可空类型
LowCardinality(T)：低基数优化
Enum：枚举
05.SQL 操作
a.建表
CREATE TABLE events (
event_date Date,
event_time DateTime,
user_id UInt64,
event_type String,
value Float64
)
ENGINE = MergeTree()
PARTITION BY toYYYYMM(event_date)
ORDER BY (event_date, user_id)
SETTINGS index_granularity = 8192;
定义表结构
指定引擎和分区
b.插入数据
INSERT INTO events VALUES
('2024-01-01', '2024-01-01 10:00:00', 1001, 'click', 1.0),
('2024-01-01', '2024-01-01 10:05:00', 1002, 'view', 2.0);
INSERT INTO events SELECT * FROM other_table;
单条或批量插入
c.查询数据
SELECT
event_date,
event_type,
count() as cnt,
sum(value) as total
FROM events
WHERE event_date >= '2024-01-01'
GROUP BY event_date, event_type
ORDER BY event_date DESC
LIMIT 100;
聚合查询
d.更新删除
ALTER TABLE events UPDATE value = value * 2 WHERE user_id = 1001;
ALTER TABLE events DELETE WHERE event_date < '2023-01-01';
轻量级更新删除
异步执行
06.性能优化
a.表设计
选择合适的引擎
合理设计主键
使用分区
设置采样键
优化排序键
b.索引优化
主键索引
跳数索引
布隆过滤器
数据跳过
加速查询
c.数据压缩
LZ4：默认压缩
ZSTD：高压缩比
Delta：数值压缩
DoubleDelta：时间序列
Gorilla：浮点数
d.查询优化
避免 SELECT *
使用 PREWHERE
合理使用 JOIN
利用物化视图
并行查询
07.分布式表
a.创建本地表
CREATE TABLE events_local ON CLUSTER cluster (
event_date Date,
user_id UInt64,
value Float64
)
ENGINE = ReplicatedMergeTree('/clickhouse/tables/{shard}/events', '{replica}')
PARTITION BY toYYYYMM(event_date)
ORDER BY (event_date, user_id);
本地表定义
副本配置
b.创建分布式表
CREATE TABLE events_all ON CLUSTER cluster AS events_local
ENGINE = Distributed(cluster, default, events_local, rand());
分布式表
分片键
c.查询分布式表
SELECT * FROM events_all WHERE event_date = '2024-01-01';
自动路由到各分片
聚合结果
d.写入分布式表
INSERT INTO events_all VALUES (...);
自动分片写入
负载均衡
08.物化视图
a.创建物化视图
CREATE MATERIALIZED VIEW events_daily
ENGINE = SummingMergeTree()
PARTITION BY toYYYYMM(event_date)
ORDER BY (event_date, event_type)
AS SELECT
event_date,
event_type,
count() as cnt,
sum(value) as total
FROM events
GROUP BY event_date, event_type;
预聚合
加速查询
b.刷新策略
自动刷新
增量更新
实时计算
查询加速
c.应用场景
预聚合
实时报表
数据转换
性能优化
09.数据导入
a.批量导入
clickhouse-client --query="INSERT INTO events FORMAT CSV" < data.csv
cat data.tsv | clickhouse-client --query="INSERT INTO events FORMAT TabSeparated"
文件导入
b.Kafka 导入
CREATE TABLE kafka_queue (
event_date Date,
user_id UInt64,
value Float64
)
ENGINE = Kafka()
SETTINGS
kafka_broker_list = 'localhost:9092',
kafka_topic_list = 'events',
kafka_group_name = 'clickhouse',
kafka_format = 'JSONEachRow';
实时消费 Kafka
c.JDBC 导入
CREATE TABLE mysql_table
ENGINE = MySQL('localhost:3306', 'db', 'table', 'user', 'password');
INSERT INTO events SELECT * FROM mysql_table;
从 MySQL 导入
d.HDFS 导入
INSERT INTO events SELECT * FROM hdfs('hdfs://namenode:9000/path/to/file', 'CSV');
从 HDFS 导入
10.使用场景
a.实时分析
用户行为分析
实时报表
监控告警
业务大屏
b.日志分析
应用日志
访问日志
审计日志
安全日志
c.时序数据
IoT 数据
监控指标
传感器数据
金融行情
d.数据仓库
OLAP 查询
多维分析
即席查询
BI 报表
11.监控运维
a.系统表
system.tables：表信息
system.parts：分区信息
system.mutations：变更信息
system.replicas：副本状态
system.query_log：查询日志
b.监控指标
查询性能
写入速度
磁盘使用
内存使用
副本延迟
c.性能分析
EXPLAIN 查询计划
查询日志分析
慢查询优化
资源使用分析
d.备份恢复
数据备份
元数据备份
增量备份
灾难恢复
12.最佳实践
a.表设计
合理分区
选择主键
使用压缩
避免宽表
b.查询优化
使用 PREWHERE
避免大 JOIN
利用物化视图
合理使用索引
c.写入优化
批量写入
异步写入
控制频率
避免小批次
d.集群管理
合理分片
副本配置
负载均衡
监控告警
3.7 starrocks：实时分析数据库
01.介绍
StarRocks 是一款高性能分析型数据仓库，专为实时分析场景设计。
它采用全面向量化引擎、智能物化视图、CBO 优化器等技术，提供极速的多维分析能力。
StarRocks 兼容 MySQL 协议，支持标准 SQL，易于使用和集成，是新一代 MPP 数据库的代表。
02.核心特性
a.极致性能
全面向量化引擎
智能查询优化
列式存储
并行执行
亚秒级查询
b.实时更新
主键模型
实时 Upsert
秒级数据可见
高并发写入
流批一体
c.联邦查询
外部表支持
跨源查询
数据湖分析
无需数据搬迁
统一查询接口
d.易用性
MySQL 协议兼容
标准 SQL
丰富的函数
简单运维
可视化工具
03.架构组件
a.Frontend（FE）
接收查询请求
SQL 解析和优化
元数据管理
查询调度
支持主从架构
b.Backend（BE）
存储数据
执行查询
数据压缩
副本管理
水平扩展
c.Broker
访问外部存储
HDFS、S3 等
数据导入
可选组件
04.数据模型
a.明细模型（Duplicate）
保留所有数据
不做聚合
适合明细查询
日志分析
原始数据存储
b.聚合模型（Aggregate）
预聚合数据
减少存储
加速查询
适合指标统计
SUM、MAX、MIN、REPLACE
c.更新模型（Unique）
主键唯一
支持 Upsert
实时更新
适合维度表
CDC 场景
d.主键模型（Primary Key）
主键约束
实时更新
高并发写入
ACID 保证
实时数仓
05.表引擎
a.存储引擎
列式存储
数据压缩
编码优化
索引支持
高效查询
b.分区分桶
Range 分区
List 分区
Hash 分桶
随机分桶
灵活组织
c.副本机制
多副本存储
自动同步
故障转移
数据高可用
默认 3 副本
d.索引
前缀索引
Bloom Filter
Bitmap 索引
倒排索引
加速查询
06.SQL 操作
a.建表
CREATE TABLE orders (
order_id BIGINT,
user_id BIGINT,
amount DECIMAL(10,2),
order_date DATE
)
PRIMARY KEY (order_id)
PARTITION BY RANGE(order_date) (
PARTITION p202401 VALUES [('2024-01-01'), ('2024-02-01')),
PARTITION p202402 VALUES [('2024-02-01'), ('2024-03-01'))
)
DISTRIBUTED BY HASH(order_id) BUCKETS 10;
主键模型
分区分桶
b.数据导入
INSERT INTO orders VALUES
(1, 1001, 99.99, '2024-01-01'),
(2, 1002, 199.99, '2024-01-02');
LOAD LABEL label1 (
DATA INFILE("hdfs://path/to/file")
INTO TABLE orders
);
INSERT 或 LOAD
c.数据更新
UPDATE orders SET amount = 299.99 WHERE order_id = 1;
主键模型支持
实时更新
d.数据删除
DELETE FROM orders WHERE order_date < '2023-01-01';
条件删除
e.查询
SELECT
order_date,
count(*) as order_count,
sum(amount) as total_amount
FROM orders
WHERE order_date >= '2024-01-01'
GROUP BY order_date
ORDER BY order_date DESC;
聚合查询
07.物化视图
a.同步物化视图
CREATE MATERIALIZED VIEW order_daily AS
SELECT
order_date,
count(*) as cnt,
sum(amount) as total
FROM orders
GROUP BY order_date;
自动刷新
查询改写
透明加速
b.异步物化视图
CREATE MATERIALIZED VIEW order_summary
REFRESH ASYNC EVERY(INTERVAL 1 HOUR)
AS SELECT
user_id,
count(*) as order_count,
sum(amount) as total_amount
FROM orders
GROUP BY user_id;
定时刷新
复杂聚合
跨表查询
c.查询改写
自动识别
透明使用
加速查询
无需修改 SQL
d.应用场景
预聚合
加速报表
实时指标
多维分析
08.外部表和联邦查询
a.Hive 外部表
CREATE EXTERNAL TABLE hive_orders
(
order_id BIGINT,
amount DECIMAL(10,2)
)
ENGINE=HIVE
PROPERTIES (
"resource" = "hive0",
"database" = "default",
"table" = "orders"
);
查询 Hive 数据
b.Iceberg 外部表
CREATE EXTERNAL TABLE iceberg_orders
ENGINE=ICEBERG
PROPERTIES (
"resource" = "iceberg0",
"database" = "default",
"table" = "orders"
);
查询 Iceberg 表
c.MySQL 外部表
CREATE EXTERNAL TABLE mysql_users
ENGINE=MYSQL
PROPERTIES (
"host" = "localhost",
"port" = "3306",
"user" = "root",
"password" = "password",
"database" = "test",
"table" = "users"
);
查询 MySQL 数据
d.联邦查询
SELECT o.order_id, u.user_name
FROM orders o
JOIN mysql_users u ON o.user_id = u.user_id;
跨源 JOIN
无需数据搬迁
09.数据导入
a.Stream Load
curl --location-trusted -u user:passwd \
-H "label:label1" \
-H "column_separator:," \
-T data.csv \
http://fe_host:8030/api/db/table/_stream_load
HTTP 导入
实时导入
b.Broker Load
LOAD LABEL label1 (
DATA INFILE("hdfs://path/to/file")
INTO TABLE orders
COLUMNS TERMINATED BY ","
)
WITH BROKER "broker_name";
大批量导入
HDFS、S3
c.Routine Load
CREATE ROUTINE LOAD load_orders ON orders
COLUMNS(order_id, user_id, amount, order_date)
PROPERTIES (
"desired_concurrent_number"="3",
"max_batch_interval" = "20",
"max_batch_rows" = "300000"
)
FROM KAFKA (
"kafka_broker_list" = "localhost:9092",
"kafka_topic" = "orders"
);
Kafka 实时消费
d.Spark Load
INSERT INTO orders
SELECT * FROM spark_table;
Spark 批量导入
10.查询优化
a.CBO 优化器
基于成本优化
统计信息收集
最优执行计划
JOIN 重排序
智能优化
b.向量化执行
批量处理
SIMD 指令
CPU 利用率高
性能提升
c.查询加速
物化视图
Colocate Join
Bucket Shuffle Join
Runtime Filter
查询缓存
d.分区裁剪
利用分区信息
跳过无关分区
减少扫描
提高性能
11.使用场景
a.实时数仓
实时 ETL
实时报表
实时大屏
秒级更新
b.用户行为分析
点击流分析
用户画像
漏斗分析
留存分析
c.日志分析
应用日志
访问日志
安全审计
运维监控
d.BI 分析
多维分析
即席查询
自助分析
可视化报表
12.性能优化
a.表设计
选择合适模型
合理分区
设计分桶键
使用索引
b.查询优化
避免 SELECT *
使用分区过滤
合理使用 JOIN
利用物化视图
c.导入优化
批量导入
并发控制
压缩传输
避免小文件
d.集群优化
资源配置
负载均衡
副本策略
监控调优
13.监控运维
a.监控指标
查询性能
导入速度
资源使用
副本状态
集群健康
b.系统表
information_schema
查询历史
导入任务
表信息
分区信息
c.日志分析
FE 日志
BE 日志
审计日志
错误日志
d.备份恢复
数据备份
增量备份
快照备份
灾难恢复
14.最佳实践
a.架构设计
合理规划集群
选择数据模型
设计分区策略
考虑扩展性
b.性能调优
优化表结构
使用物化视图
合理配置资源
监控调优
c.数据治理
元数据管理
数据质量
权限控制
审计日志
d.运维管理
定期巡检
容量规划
版本升级
故障处理
3.8 MaxCompute：大数据计算
01.介绍
MaxCompute（原名 ODPS）是阿里云提供的一种快速、完全托管的 PB 级数据仓库解决方案。
它提供了完善的数据导入方案以及多种经典的分布式计算模型，能够快速解决海量数据计算问题。
MaxCompute 采用存储与计算分离架构，支持多种开源生态，是企业级大数据计算服务的首选。
02.核心特性
a.海量数据处理
PB 级数据存储
EB 级数据计算
高性能计算
弹性扩展
按需付费
b.完全托管
无需运维
自动扩缩容
高可用保证
数据安全
服务稳定
c.多种计算模型
SQL 计算
MapReduce
Graph 计算
机器学习
流计算
d.开放生态
兼容 Hive 语法
Spark 集成
Flink 集成
开源工具支持
生态丰富
03.架构组件
a.存储层
分布式文件系统
列式存储
数据压缩
多副本
高可靠
b.计算层
SQL 引擎
MapReduce 引擎
Graph 引擎
机器学习引擎
资源调度
c.元数据层
表管理
分区管理
权限管理
统计信息
血缘追踪
d.服务层
作业调度
资源管理
监控告警
安全审计
API 接口
04.数据类型
a.基本类型
BIGINT：整数
DOUBLE：浮点数
STRING：字符串
DATETIME：日期时间
BOOLEAN：布尔
DECIMAL：精确数值
b.复杂类型
ARRAY：数组
MAP：映射
STRUCT：结构体
JSON：JSON 对象
c.特殊类型
BINARY：二进制
TIMESTAMP：时间戳
VARCHAR：变长字符串
05.SQL 操作
a.建表
CREATE TABLE IF NOT EXISTS sale_detail (
shop_name STRING,
customer_id STRING,
total_price DOUBLE
)
PARTITIONED BY (sale_date STRING, region STRING)
LIFECYCLE 365;
分区表
生命周期管理
b.分区操作
ALTER TABLE sale_detail ADD PARTITION (sale_date='20240101', region='hangzhou');
ALTER TABLE sale_detail DROP PARTITION (sale_date='20230101');
添加删除分区
c.数据插入
INSERT INTO TABLE sale_detail PARTITION (sale_date='20240101', region='hangzhou')
VALUES ('shop1', 'c001', 100.5);
INSERT OVERWRITE TABLE sale_detail PARTITION (sale_date='20240101', region='hangzhou')
SELECT * FROM source_table;
INSERT 或 INSERT OVERWRITE
d.查询
SELECT
region,
COUNT(*) as order_count,
SUM(total_price) as total_amount
FROM sale_detail
WHERE sale_date >= '20240101'
GROUP BY region
ORDER BY total_amount DESC
LIMIT 100;
标准 SQL 查询
06.数据导入导出
a.Tunnel 上传
odps tunnel upload data.txt sale_detail/sale_date=20240101,region=hangzhou;
批量上传
高效传输
b.DataWorks 数据集成
可视化配置
多源数据同步
定时调度
监控告警
c.OSS 导入
CREATE EXTERNAL TABLE oss_table (
col1 STRING,
col2 BIGINT
)
STORED BY 'com.aliyun.odps.CsvStorageHandler'
LOCATION 'oss://bucket/path/';
INSERT INTO sale_detail SELECT * FROM oss_table;
从 OSS 导入
d.数据导出
odps tunnel download sale_detail/sale_date=20240101 data.txt;
INSERT OVERWRITE TABLE oss_table SELECT * FROM sale_detail;
导出到本地或 OSS
07.UDF 开发
a.Java UDF
public class Lower extends UDF {
public String evaluate(String s) {
if (s == null) return null;
return s.toLowerCase();
}
}
自定义标量函数
b.注册 UDF
ADD JAR my_udf.jar;
CREATE FUNCTION lower AS 'com.example.Lower' USING 'my_udf.jar';
SELECT lower(shop_name) FROM sale_detail;
注册和使用
c.UDAF
public class MySum extends Aggregator {
// 实现聚合逻辑
}
自定义聚合函数
d.UDTF
public class Split extends UDTF {
@Override
public void process(Object[] args) {
String str = (String) args[0];
for (String s : str.split(",")) {
forward(s);
}
}
}
自定义表函数
08.MapReduce 开发
a.Mapper
public class WordCountMapper extends Mapper {
@Override
public void map(long key, Record record, TaskContext context) {
String line = record.getString(0);
for (String word : line.split(" ")) {
Record out = context.createOutputRecord();
out.set(0, word);
out.set(1, 1L);
context.write(out);
}
}
}
Map 逻辑
b.Reducer
public class WordCountReducer extends Reducer {
@Override
public void reduce(Record key, Iterator<Record> values, TaskContext context) {
long count = 0;
while (values.hasNext()) {
Record val = values.next();
count += val.getBigint(1);
}
Record result = context.createOutputRecord();
result.set(0, key.get(0));
result.set(1, count);
context.write(result);
}
}
Reduce 逻辑
c.提交作业
jar -resources my_mr.jar -classpath my_mr.jar
com.example.WordCount
input_table output_table;
提交 MapReduce 作业
09.性能优化
a.分区设计
合理设计分区
避免小分区
分区裁剪
提高查询效率
b.数据倾斾
使用 DISTRIBUTE BY
调整并发度
数据预处理
避免热点
c.SQL 优化
避免 SELECT *
使用分区过滤
合理使用 JOIN
利用统计信息
d.资源配置
调整内存配置
设置优先级
合理使用资源组
成本优化
10.权限管理
a.项目权限
Admin：管理员
Dev：开发者
Visitor：访问者
角色分配
b.表权限
SELECT：查询
UPDATE：更新
ALTER：修改
DROP：删除
细粒度控制
c.列级权限
列级别授权
敏感数据保护
数据脱敏
合规要求
d.标签授权
基于标签
动态授权
灵活管理
安全合规
11.数据安全
a.数据加密
存储加密
传输加密
密钥管理
安全保障
b.数据脱敏
动态脱敏
静态脱敏
自定义规则
隐私保护
c.审计日志
操作审计
访问审计
SQL 审计
合规要求
d.网络隔离
VPC 网络
白名单
专线接入
安全访问
12.与开源生态集成
a.Spark on MaxCompute
Spark SQL
Spark Streaming
MLlib
GraphX
无缝集成
b.Flink on MaxCompute
实时计算
流批一体
状态管理
Exactly-Once
c.Hive 兼容
HiveQL 语法
元数据同步
UDF 兼容
平滑迁移
d.开源工具
Sqoop
DataX
Kettle
数据集成
13.使用场景
a.离线数据仓库
T+1 数据处理
批量计算
报表生成
数据分析
b.实时数仓
实时数据处理
流批一体
实时报表
实时分析
c.机器学习
特征工程
模型训练
模型部署
在线预测
d.日志分析
海量日志
行为分析
安全审计
运维监控
14.成本优化
a.存储优化
生命周期管理
数据压缩
冷热分层
定期清理
b.计算优化
包年包月
按量付费
预留资源
成本分析
c.资源管理
资源组
配额管理
优先级设置
合理分配
d.监控告警
成本监控
用量分析
异常告警
优化建议
15.最佳实践
a.表设计
合理分区
选择数据类型
设置生命周期
避免小文件
b.SQL 优化
分区过滤
避免全表扫描
合理使用 JOIN
利用统计信息
c.作业调度
合理安排时间
依赖管理
错误重试
监控告警
d.安全合规
权限最小化
数据脱敏
审计日志
定期检查
3.9 elasticsearch：搜索引擎
01.介绍
Elasticsearch是基于Lucene的分布式搜索和分析引擎。
支持全文检索、结构化搜索、分析聚合。
RESTful API，JSON格式，易于使用。
广泛应用于日志分析、全文搜索、数据分析等场景。
02.核心概念
a.Index索引
类似数据库的database
文档的容器
分片存储
可配置副本
b.Document文档
JSON格式数据
最小数据单元
包含字段
唯一ID标识
c.Field字段
文档的属性
支持多种类型
可分词索引
可聚合分析
d.Mapping映射
字段定义
数据类型
分词器配置
索引选项
03.架构组件
a.Master Node
集群管理
索引创建删除
节点管理
分片分配
b.Data Node
存储数据
执行查询
聚合计算
分片管理
c.Coordinating Node
请求路由
结果合并
负载均衡
不存储数据
d.Ingest Node
数据预处理
Pipeline处理
字段转换
数据增强
04.数据类型
a.基本类型
text：全文本，分词
keyword：关键字，不分词
long、integer、short、byte
double、float
boolean
date：日期时间
b.复杂类型
object：嵌套对象
nested：嵌套数组
array：数组
geo_point：地理坐标
geo_shape：地理形状
c.特殊类型
ip：IP地址
completion：自动补全
token_count：词条计数
percolator：反向查询
05.索引操作
a.创建索引
PUT /my_index
{
"settings": {
"number_of_shards": 3,
"number_of_replicas": 1
},
"mappings": {
"properties": {
"title": {"type": "text"},
"price": {"type": "double"},
"created_at": {"type": "date"}
}
}
}
b.文档操作
POST /my_index/_doc
{"title": "Product", "price": 99.9}
PUT /my_index/_doc/1
{"title": "Product", "price": 99.9}
GET /my_index/_doc/1
DELETE /my_index/_doc/1
c.批量操作
POST /_bulk
{"index": {"_index": "my_index"}}
{"title": "Product1", "price": 99.9}
{"index": {"_index": "my_index"}}
{"title": "Product2", "price": 199.9}
06.查询DSL
a.全文查询
match查询：分词匹配
match_phrase：短语匹配
multi_match：多字段匹配
query_string：查询字符串
b.精确查询
term：精确匹配
terms：多值匹配
range：范围查询
exists：字段存在
c.复合查询
bool：布尔查询
must：必须匹配
should：应该匹配
must_not：必须不匹配
filter：过滤条件
d.查询示例
GET /my_index/_search
{
"query": {
"bool": {
"must": [
{"match": {"title": "product"}}
],
"filter": [
{"range": {"price": {"gte": 50, "lte": 200}}}
]
}
}
}
07.聚合分析
a.指标聚合
avg：平均值
sum：求和
min、max：最小最大值
stats：统计信息
cardinality：基数统计
b.桶聚合
terms：分组聚合
date_histogram：时间直方图
histogram：数值直方图
range：范围聚合
c.管道聚合
derivative：导数
cumulative_sum：累计和
moving_avg：移动平均
bucket_sort：桶排序
d.聚合示例
GET /sales/_search
{
"aggs": {
"sales_per_month": {
"date_histogram": {
"field": "date",
"calendar_interval": "month"
},
"aggs": {
"total_sales": {
"sum": {"field": "amount"}
}
}
}
}
}
08.分词器
a.内置分词器
standard：标准分词器
simple：简单分词器
whitespace：空格分词器
keyword：不分词
pattern：正则分词器
b.中文分词
IK分词器：ik_max_word、ik_smart
jieba分词器
HanLP分词器
自定义词典
c.分词器配置
analyzer：索引分词器
search_analyzer：查询分词器
normalizer：标准化器
char_filter：字符过滤
tokenizer：分词器
token_filter：词条过滤
09.性能优化
a.索引优化
合理分片数量
副本数量配置
refresh_interval调整
merge策略优化
b.查询优化
使用filter替代query
避免深度分页
使用scroll遍历
缓存利用
c.写入优化
批量写入
禁用refresh
增加bulk size
异步写入
d.硬件优化
SSD存储
充足内存
多核CPU
千兆网络
10.监控管理
a.集群健康
GET /_cluster/health
green：所有分片正常
yellow：主分片正常，副本异常
red：主分片异常
b.监控指标
索引速率
查询延迟
内存使用
磁盘使用
JVM GC
c.管理工具
Kibana：可视化管理
Cerebro：集群管理
ElasticHQ：监控工具
Head插件：Web管理
4 数据湖与缓存
4.1 hudi：数据湖框架
01.介绍
Apache Hudi是Uber开源的数据湖存储框架。
支持增量数据处理，Upsert和Delete操作。
提供快照隔离和时间旅行功能。
与Spark、Flink、Hive等深度集成。
02.核心概念
a.Timeline时间线
记录所有操作
Instant瞬时状态
Commit提交
Rollback回滚
b.File Layout
Base文件：Parquet格式
Log文件：Avro格式
元数据文件
归档文件
c.Index索引
Bloom Filter索引
HBase索引
Simple索引
Global索引
d.Table Type
Copy on Write：COW
Merge on Read：MOR
03.表类型
a.Copy on Write
写时复制
更新时重写整个文件
读优化，写代价高
适合读多写少
查询性能好
b.Merge on Read
读时合并
增量写入Log文件
写优化，读代价高
适合写多读少
近实时查询
04.核心功能
a.Upsert更新插入
根据主键更新或插入
自动去重
增量数据处理
CDC场景
b.增量查询
查询增量数据
指定时间范围
Streaming Read
实时处理
c.时间旅行
查询历史版本
Snapshot查询
数据回滚
审计追溯
d.数据清理
Cleaner清理旧版本
Archive归档元数据
Compaction合并小文件
保留策略
05.Spark集成
a.写入数据
df.write
.format("hudi")
.option("hoodie.table.name", "my_table")
.option("hoodie.datasource.write.recordkey.field", "id")
.option("hoodie.datasource.write.partitionpath.field", "dt")
.option("hoodie.datasource.write.precombine.field", "ts")
.option("hoodie.datasource.write.operation", "upsert")
.mode("append")
.save("/path/to/table")
b.读取数据
spark.read
.format("hudi")
.load("/path/to/table")
读取最新快照
c.增量读取
spark.read
.format("hudi")
.option("hoodie.datasource.query.type", "incremental")
.option("hoodie.datasource.read.begin.instanttime", "20240101000000")
.load("/path/to/table")
d.时间旅行
spark.read
.format("hudi")
.option("as.of.instant", "20240101000000")
.load("/path/to/table")
06.Flink集成
a.Flink SQL
CREATE TABLE hudi_table (
id BIGINT,
name STRING,
ts TIMESTAMP(3),
dt STRING,
PRIMARY KEY (id) NOT ENFORCED
) PARTITIONED BY (dt)
WITH (
'connector' = 'hudi',
'path' = '/path/to/table',
'table.type' = 'MERGE_ON_READ'
);
b.流式写入
INSERT INTO hudi_table SELECT * FROM source_table;
实时Upsert
exactly-once
c.流式读取
SELECT * FROM hudi_table;
增量消费
实时查询
07.索引策略
a.Bloom Filter
默认索引
内存占用小
误判率可配置
适合大数据量
b.Simple Index
基于分区
无额外存储
适合分区表
性能一般
c.HBase Index
外部HBase存储
全局索引
查询快
维护成本高
d.Global Index
全局唯一性
跨分区去重
性能开销大
强一致性
08.Compaction压缩
a.Inline Compaction
写入时触发
同步执行
影响写入性能
保证查询性能
b.Async Compaction
异步执行
独立进程
不影响写入
延迟合并
c.压缩策略
LogFileSizeBasedCompactionStrategy
UnBoundedCompactionStrategy
自定义策略
09.性能优化
a.写入优化
调整parallelism
合理设置索引
批量写入
异步Compaction
b.读取优化
使用COW表
定期Compaction
分区裁剪
列裁剪
c.索引优化
选择合适索引类型
调整Bloom Filter参数
分区策略
全局索引慎用
10.最佳实践
a.表类型选择
读多写少：COW
写多读少：MOR
实时查询：MOR
批量查询：COW
b.分区设计
合理分区粒度
避免小分区
时间分区
复合分区
c.运维管理
定期Compaction
清理旧版本
监控表大小
元数据归档
4.2 iceberg：表格式
01.介绍
Apache Iceberg是Netflix开源的表格式标准。
为大数据分析设计，支持ACID事务。
Schema演进，分区演进，时间旅行。
多引擎支持：Spark、Flink、Presto、Hive等。
02.核心概念
a.Table Metadata
表元数据
Schema定义
分区规则
快照历史
b.Manifest File
数据文件清单
文件级元数据
统计信息
删除文件
c.Data File
实际数据文件
Parquet、ORC、Avro
不可变
列式存储
d.Snapshot快照
表的某个时间点状态
包含所有数据文件
不可变
时间旅行
03.核心特性
a.ACID事务
原子性操作
隔离级别
并发控制
乐观锁
b.Schema演进
添加列
删除列
重命名列
修改类型
向后兼容
c.分区演进
动态调整分区
无需重写数据
隐藏分区
分区转换
d.时间旅行
查询历史快照
数据回滚
增量读取
审计追溯
04.隐藏分区
a.分区转换
years(ts)：按年分区
months(ts)：按月分区
days(ts)：按天分区
hours(ts)：按小时分区
bucket(N, id)：哈希分桶
truncate(length, str)：截断分区
b.优势
用户无需关心分区
自动分区裁剪
分区演进
查询简化
c.示例
CREATE TABLE events (
id BIGINT,
ts TIMESTAMP,
data STRING
) USING iceberg
PARTITIONED BY (days(ts))
05.Spark集成
a.创建表
spark.sql("""
CREATE TABLE iceberg_table (
id BIGINT,
name STRING,
ts TIMESTAMP
) USING iceberg
PARTITIONED BY (days(ts))
""")
b.写入数据
df.writeTo("iceberg_table").append()
df.writeTo("iceberg_table").overwrite(col("dt") == "2024-01-01")
df.writeTo("iceberg_table").createOrReplace()
c.读取数据
spark.read.table("iceberg_table")
spark.read.option("snapshot-id", 123456).table("iceberg_table")
spark.read.option("as-of-timestamp", "2024-01-01 00:00:00").table("iceberg_table")
d.增量读取
spark.read
.option("start-snapshot-id", 123)
.option("end-snapshot-id", 456)
.table("iceberg_table")
06.表维护
a.快照管理
CALL catalog.system.expire_snapshots('db.table', TIMESTAMP '2024-01-01 00:00:00')
清理过期快照
保留策略
b.文件压缩
CALL catalog.system.rewrite_data_files('db.table')
合并小文件
优化布局
Z-Order排序
c.元数据清理
CALL catalog.system.remove_orphan_files('db.table')
删除孤儿文件
清理元数据
07.Flink集成
a.Flink SQL
CREATE CATALOG iceberg_catalog WITH (
'type'='iceberg',
'catalog-type'='hive',
'uri'='thrift://localhost:9083',
'warehouse'='hdfs://namenode:8020/warehouse'
);
b.流式写入
INSERT INTO iceberg_table SELECT * FROM kafka_source;
实时写入
exactly-once
c.流式读取
SELECT * FROM iceberg_table /*+ OPTIONS('streaming'='true', 'monitor-interval'='1s') */;
增量消费
08.性能优化
a.数据布局
Z-Order排序
合并小文件
分区策略
文件大小
b.元数据优化
元数据缓存
Manifest缓存
统计信息
分区裁剪
c.查询优化
谓词下推
列裁剪
分区过滤
向量化读取
09.多引擎支持
a.Spark
读写支持
DDL操作
时间旅行
增量读取
b.Flink
流式读写
CDC集成
exactly-once
实时查询
c.Presto/Trino
SQL查询
联邦查询
跨源JOIN
高性能
d.Hive
元数据集成
HiveQL兼容
批量查询
10.最佳实践
a.表设计
合理分区
隐藏分区
Schema设计
数据类型选择
b.写入优化
批量写入
合理并发
文件大小控制
分区策略
c.维护策略
定期压缩
快照清理
元数据清理
监控表大小
4.3 delta lake：数据湖存储
01.介绍
Delta Lake是Databricks开源的存储层。
基于Parquet，提供ACID事务。
时间旅行，Schema演进，流批一体。
与Apache Spark深度集成。
02.核心概念
a.Transaction Log
事务日志
JSON格式
记录所有操作
ACID保证
b.Checkpoint检查点
元数据快照
加速读取
定期生成
Parquet格式
c.Version版本
每次操作生成新版本
不可变
时间旅行
数据回滚
d.Optimistic Concurrency
乐观并发控制
冲突检测
自动重试
高并发
03.核心特性
a.ACID事务
原子性写入
隔离级别
一致性保证
持久化
b.时间旅行
VERSION AS OF
TIMESTAMP AS OF
查询历史版本
数据恢复
c.Schema演进
添加列
修改列类型
重命名列
Schema验证
d.Upsert/Delete
MERGE INTO
UPDATE
DELETE
CDC支持
04.基本操作
a.创建表
df.write
.format("delta")
.mode("overwrite")
.save("/path/to/table")
spark.sql("""
CREATE TABLE delta_table
USING DELTA
LOCATION '/path/to/table'
""")
b.读取数据
spark.read.format("delta").load("/path/to/table")
spark.table("delta_table")
c.写入数据
df.write.format("delta").mode("append").save("/path/to/table")
df.write.format("delta").mode("overwrite").save("/path/to/table")
d.更新删除
deltaTable.update(condition, set)
deltaTable.delete(condition)
05.MERGE操作
a.Upsert语法
deltaTable.alias("target")
.merge(source.alias("source"), "target.id = source.id")
.whenMatched().updateAll()
.whenNotMatched().insertAll()
.execute()
b.条件更新
.whenMatched(condition).update(set)
.whenMatched(condition).delete()
.whenNotMatched(condition).insert(values)
c.CDC场景
处理变更数据
增量同步
实时更新
数据一致性
06.时间旅行
a.版本查询
SELECT * FROM delta_table VERSION AS OF 10
df = spark.read.format("delta").option("versionAsOf", 10).load("/path/to/table")
查询指定版本
b.时间戳查询
SELECT * FROM delta_table TIMESTAMP AS OF '2024-01-01 00:00:00'
df = spark.read.format("delta").option("timestampAsOf", "2024-01-01").load("/path/to/table")
查询指定时间
c.历史查看
DESCRIBE HISTORY delta_table
查看操作历史
版本信息
操作详情
07.表优化
a.OPTIMIZE
OPTIMIZE delta_table
合并小文件
Z-Order排序
提高查询性能
b.VACUUM
VACUUM delta_table RETAIN 168 HOURS
清理过期文件
释放存储空间
保留期配置
c.Z-Order
OPTIMIZE delta_table ZORDER BY (col1, col2)
多维聚簇
加速过滤查询
减少文件扫描
08.流式处理
a.Streaming Write
df.writeStream
.format("delta")
.outputMode("append")
.option("checkpointLocation", "/path/to/checkpoint")
.start("/path/to/table")
b.Streaming Read
spark.readStream
.format("delta")
.load("/path/to/table")
增量消费
exactly-once
c.Change Data Feed
spark.read
.format("delta")
.option("readChangeFeed", "true")
.option("startingVersion", 0)
.load("/path/to/table")
CDC流
09.性能优化
a.数据布局
合理分区
Z-Order排序
文件大小控制
定期OPTIMIZE
b.写入优化
批量写入
Auto Optimize
调整并发度
分区策略
c.读取优化
分区裁剪
列裁剪
Data Skipping
缓存利用
10.最佳实践
a.表设计
合理分区键
主键选择
数据类型
Schema设计
b.维护策略
定期OPTIMIZE
定期VACUUM
监控表大小
版本管理
c.并发控制
合理隔离级别
冲突处理
重试策略
锁超时配置
4.4 lakehouse：数据湖仓架构
01.介绍
Lakehouse（数据湖仓）是一种新型的数据架构，结合了数据湖和数据仓库的优点。
它在数据湖的基础上提供了数据仓库的 ACID 事务、Schema 管理、数据治理等能力，
同时保持了数据湖的灵活性、低成本和对多种数据类型的支持。
Lakehouse 架构正在成为现代数据平台的主流选择。
02.核心概念
a.数据湖
存储原始数据
支持多种格式
低成本存储
Schema-on-Read
灵活性高
b.数据仓库
结构化数据
ACID 事务
高性能查询
Schema-on-Write
数据质量高
c.Lakehouse 优势
统一存储
ACID 事务支持
Schema 管理
高性能查询
成本优化
数据治理
03.技术架构
a.存储层
对象存储（S3、ADLS、OSS）
HDFS
低成本
高可靠
可扩展
b.元数据层
表格式（Delta Lake、Iceberg、Hudi）
Schema 管理
分区管理
版本控制
事务日志
c.计算层
Spark
Presto/Trino
Flink
Hive
多引擎支持
d.治理层
数据质量
数据血缘
权限管理
审计日志
合规管理
04.主流实现
a.Delta Lake
Databricks 开源
基于 Parquet
ACID 事务
时间旅行
Schema 演进
与 Spark 深度集成
b.Apache Iceberg
Netflix 开源
表格式标准
隐藏分区
Schema 演进
时间旅行
多引擎支持
c.Apache Hudi
Uber 开源
增量处理
Upsert 支持
快照隔离
增量查询
流批一体
d.对比
Delta Lake：Spark 生态最佳
Iceberg：标准化、多引擎
Hudi：增量处理强
根据场景选择
05.Delta Lake 详解
a.核心特性
ACID 事务
可扩展元数据
时间旅行
Schema 演进
Upsert/Delete
流批统一
b.表操作
CREATE TABLE delta.`/path/to/table`
INSERT INTO delta.`/path/to/table`
UPDATE delta.`/path/to/table` SET ... WHERE ...
DELETE FROM delta.`/path/to/table` WHERE ...
MERGE INTO target USING source ON ... WHEN MATCHED ...
SQL 操作
c.时间旅行
SELECT * FROM delta.`/path/to/table` VERSION AS OF 10
SELECT * FROM delta.`/path/to/table` TIMESTAMP AS OF '2024-01-01'
历史版本查询
数据回滚
d.优化
OPTIMIZE delta.`/path/to/table`
VACUUM delta.`/path/to/table` RETAIN 168 HOURS
文件压缩
清理过期文件
06.Apache Iceberg 详解
a.核心特性
表格式标准
隐藏分区
Schema 演进
时间旅行
快照隔离
多引擎支持
b.表操作
CREATE TABLE iceberg_table (id bigint, name string)
USING iceberg
PARTITIONED BY (days(ts))
INSERT INTO iceberg_table VALUES (1, 'Alice')
UPDATE iceberg_table SET name = 'Bob' WHERE id = 1
SQL 操作
c.分区演进
ALTER TABLE iceberg_table ADD PARTITION FIELD years(ts)
ALTER TABLE iceberg_table DROP PARTITION FIELD days(ts)
动态调整分区
无需重写数据
d.快照管理
SELECT * FROM iceberg_table.snapshots
SELECT * FROM iceberg_table FOR SYSTEM_TIME AS OF '2024-01-01'
快照查询
时间旅行
07.Apache Hudi 详解
a.核心特性
增量处理
Upsert 支持
快照隔离
增量查询
流批一体
多种表类型
b.表类型
Copy on Write (COW)
写时复制
读优化
适合读多写少
Merge on Read (MOR)
读时合并
写优化
适合写多读少
c.表操作
df.write.format("hudi")
.option("hoodie.table.name", "hudi_table")
.option("hoodie.datasource.write.operation", "upsert")
.mode("append")
.save("/path/to/table")
Spark API
d.增量查询
spark.read.format("hudi")
.option("hoodie.datasource.query.type", "incremental")
.option("hoodie.datasource.read.begin.instanttime", "20240101000000")
.load("/path/to/table")
增量读取
CDC 场景
08.数据治理
a.Schema 管理
Schema 演进
兼容性检查
版本控制
自动推断
b.数据质量
数据验证
质量检查
异常检测
质量报告
c.权限管理
表级权限
列级权限
行级权限
细粒度控制
d.审计日志
操作记录
变更追踪
合规审计
安全监控
09.性能优化
a.文件管理
小文件合并
文件大小优化
Z-Order 排序
数据聚簇
b.分区策略
合理分区
分区裁剪
动态分区
隐藏分区
c.索引优化
布隆过滤器
列统计信息
数据跳过
加速查询
d.缓存策略
元数据缓存
数据缓存
查询结果缓存
提高性能
10.使用场景
a.数据湖建设
统一数据存储
多源数据集成
灵活数据处理
低成本存储
b.实时数仓
流批一体
增量更新
实时查询
ACID 保证
c.数据科学
数据探索
特征工程
模型训练
版本管理
d.数据治理
元数据管理
数据血缘
质量管理
合规管理
11.与传统架构对比
a.vs 数据湖
Lakehouse 优势
ACID 事务
Schema 管理
数据质量
高性能查询
数据湖优势
更灵活
更简单
成本更低
b.vs 数据仓库
Lakehouse 优势
低成本
支持多种格式
灵活扩展
开放标准
数据仓库优势
成熟稳定
性能优化
工具丰富
企业支持
c.选择建议
新建项目：Lakehouse
已有数据湖：升级 Lakehouse
已有数仓：逐步迁移
混合架构：共存
12.最佳实践
a.架构设计
选择合适的表格式
规划分区策略
设计 Schema
考虑扩展性
b.性能优化
合理分区
文件大小控制
使用索引
定期优化
c.数据治理
Schema 管理
数据质量
权限控制
审计日志
d.运维管理
监控告警
备份恢复
版本升级
容量规划
4.5 kudu：列式存储引擎
01.介绍
Apache Kudu 是一个开源的分布式列式存储引擎，专为快速分析和实时数据处理而设计。
Kudu 结合了 HDFS 的高吞吐量顺序访问和 HBase 的低延迟随机访问的优点，提供了一种新的存储方案。
它特别适合需要快速扫描和更新的场景，如实时分析、时序数据存储等。
02.核心特性
a.列式存储
数据按列存储，提高查询性能
支持高效的列压缩
适合分析型查询
减少 I/O 开销
b.快速随机访问
支持低延迟的随机读写
毫秒级别的更新和删除
适合实时数据更新场景
比 HDFS 更快的随机访问
c.高吞吐量扫描
支持大规模数据扫描
优化的顺序读取性能
适合批量分析
与 Impala、Spark 集成良好
d.强一致性
提供强一致性保证
支持 ACID 事务
数据更新立即可见
避免数据不一致问题
03.架构组件
a.Master Server
管理元数据
协调 Tablet Server
处理表的创建和删除
维护集群状态
通常部署 3 个实例（高可用）
b.Tablet Server
存储实际数据
处理读写请求
管理 Tablet（数据分片）
执行数据压缩和合并
可水平扩展
c.Tablet
数据的基本分片单元
类似 HBase 的 Region
每个 Tablet 包含行的子集
自动分裂和合并
支持副本复制
04.数据模型
a.表结构
定义主键
指定列和数据类型
支持的类型：INT8、INT16、INT32、INT64、STRING、BOOL、FLOAT、DOUBLE、BINARY、UNIXTIME_MICROS
主键不可变
b.分区策略
Range 分区：按范围分区
Hash 分区：按哈希分区
组合分区：Range + Hash
灵活的分区设计
c.副本策略
默认 3 个副本
Raft 协议保证一致性
自动故障转移
数据高可用
05.与Hadoop生态集成
a.Impala 集成
Impala 原生支持 Kudu
高性能 SQL 查询
实时分析场景
CREATE TABLE ... STORED AS KUDU
b.Spark 集成
Spark SQL 读写 Kudu
DataFrame API 支持
批处理和流处理
kudu-spark 连接器
c.Hive 集成
通过 Impala 间接集成
元数据同步
SQL 兼容性
d.NiFi/Flume 集成
数据采集和导入
实时数据流
Kudu Sink 支持
06.使用场景
a.实时分析
实时数据更新和查询
低延迟要求
OLAP 场景
BI 报表
b.时序数据
IoT 数据存储
监控数据
日志分析
传感器数据
c.数据更新频繁
需要频繁更新的场景
CDC（变更数据捕获）
实时数仓
增量更新
d.混合负载
同时支持批处理和实时查询
OLTP + OLAP
统一存储层
07.优势与限制
a.优势
快速随机访问和扫描
支持更新和删除
强一致性保证
与 Hadoop 生态集成好
列式存储高效压缩
b.限制
不支持二级索引
主键不可变
不支持事务跨表
相比 HBase 功能较少
社区相对较小
08.最佳实践
a.表设计
合理选择主键
避免热点分区
使用组合分区
预分区策略
b.性能优化
合理设置副本数
调整 Tablet 大小
使用批量写入
定期压缩数据
c.运维建议
监控 Master 和 Tablet Server
定期备份元数据
合理规划容量
及时升级版本
4.6 alluxio：分布式缓存
01.介绍
Alluxio是开源的分布式虚拟文件系统。
提供统一的数据访问层，连接计算框架和存储系统。
内存级速度，支持多种底层存储。
广泛应用于大数据和AI场景。
02.核心概念
a.Namespace命名空间
统一文件系统视图
挂载多个存储系统
透明访问
路径映射
b.数据分层
Memory层：内存存储
SSD层：SSD存储
HDD层：磁盘存储
自动分层
c.元数据
文件元数据
目录结构
权限信息
Master管理
d.数据块
文件分块存储
默认64MB
副本机制
Worker管理
03.架构组件
a.Master
元数据管理
命名空间管理
Worker协调
高可用支持
b.Worker
数据块存储
缓存管理
读写服务
心跳上报
c.Client
文件系统接口
透明访问
本地缓存
多种API
d.Job Service
异步任务
数据迁移
负载均衡
批量操作
04.存储集成
a.HDFS
挂载HDFS路径
透明访问
元数据同步
性能加速
b.S3
挂载S3 Bucket
对象存储
跨云访问
成本优化
c.OSS
阿里云OSS
对象存储
国内访问优化
d.其他存储
Azure Blob
Google Cloud Storage
Ceph
本地文件系统
05.数据管理
a.数据加载
alluxio fs load /path
预加载数据到缓存
提高访问速度
批量加载
b.数据持久化
alluxio fs persist /path
写入底层存储
数据持久化
异步写入
c.数据释放
alluxio fs free /path
释放缓存空间
保留元数据
按需释放
d.数据固定
alluxio fs pin /path
固定在缓存中
防止淘汰
重要数据
06.缓存策略
a.读缓存
Cache on Read
首次读取缓存
后续访问加速
自动缓存
b.写缓存
Cache Through：同步写
Must Cache：必须缓存
Cache：异步写
Async Through：异步持久化
c.淘汰策略
LRU：最近最少使用
LFU：最不经常使用
LRFU：混合策略
自定义策略
07.性能优化
a.内存配置
增加Worker内存
分层存储配置
缓存容量规划
内存预留
b.网络优化
本地优先读取
短路读取
域套接字
零拷贝
c.元数据优化
元数据缓存
异步元数据同步
批量操作
元数据分片
d.数据预取
预加载热数据
批量加载
定时任务
智能预测
08.Spark集成
a.配置
spark.hadoop.fs.alluxio.impl=alluxio.hadoop.FileSystem
spark.hadoop.fs.AbstractFileSystem.alluxio.impl=alluxio.hadoop.AlluxioFileSystem
b.读取数据
df = spark.read.parquet("alluxio://master:19998/data/file.parquet")
透明访问
自动缓存
c.写入数据
df.write.parquet("alluxio://master:19998/output/result.parquet")
写入缓存
异步持久化
09.监控管理
a.Web界面
http://master:19999
集群状态
文件浏览
配置查看
日志查看
b.监控指标
缓存命中率
吞吐量
内存使用
Worker状态
任务状态
c.命令行工具
alluxio fs：文件系统操作
alluxio fsadmin：管理命令
alluxio job：任务管理
alluxio table：表管理
10.最佳实践
a.缓存策略
热数据缓存
冷数据分层
合理配置容量
定期清理
b.性能调优
增加Worker节点
优化网络配置
本地优先访问
批量操作
c.高可用
Master HA配置
ZooKeeper集成
元数据备份
故障恢复
4.7 ranger：安全管理
01.介绍
Apache Ranger是Hadoop生态的安全管理框架。
提供集中式权限管理和审计。
支持细粒度访问控制。
与Hadoop生态组件深度集成。
02.核心概念
a.Policy策略
访问控制规则
资源定义
用户组权限
条件表达式
b.Service服务
HDFS、Hive、HBase等
插件集成
策略同步
审计日志
c.Resource资源
数据库、表、列
文件路径
Topic主题
细粒度控制
d.User/Group
用户管理
用户组管理
角色管理
权限继承
03.架构组件
a.Ranger Admin
Web管理界面
策略管理
用户管理
审计查看
b.Ranger Plugin
集成各组件
策略执行
权限检查
审计上报
c.Ranger UserSync
用户同步
LDAP集成
Unix用户同步
定期同步
d.Ranger KMS
密钥管理
加密服务
密钥轮换
审计日志
04.HDFS集成
a.策略配置
资源：/data/warehouse/*
用户：hadoop_user
权限：Read、Write、Execute
递归：是
b.权限类型
Read：读取文件
Write：写入文件
Execute：执行/遍历
Admin：管理权限
c.路径匹配
精确匹配：/data/file.txt
通配符：/data/*.txt
递归：/data/**
正则表达式
05.Hive集成
a.策略配置
数据库：default
表：users
列：id, name
权限：Select、Update、Create、Drop
b.权限类型
Select：查询
Update：更新
Create：创建
Drop：删除
Alter：修改
Index：索引
Lock：锁定
All：所有权限
c.列级权限
敏感列控制
数据脱敏
条件访问
动态列过滤
06.HBase集成
a.策略配置
表：user_table
列族：cf1
列：name, age
权限：Read、Write、Create、Admin
b.权限类型
Read：读取数据
Write：写入数据
Create：创建表
Admin：管理权限
c.行级过滤
基于标签
条件表达式
动态过滤
细粒度控制
07.Kafka集成
a.策略配置
Topic：user_events
权限：Publish、Consume、Configure、Describe
用户组：kafka_users
b.权限类型
Publish：发布消息
Consume：消费消息
Configure：配置Topic
Describe：查看元数据
Create：创建Topic
Delete：删除Topic
08.审计功能
a.审计日志
访问记录
操作类型
用户信息
时间戳
结果状态
b.审计存储
Solr存储
Elasticsearch存储
HDFS存储
数据库存储
c.审计查询
按用户查询
按资源查询
按时间查询
按结果查询
d.审计报表
访问统计
权限使用
异常检测
合规报告
09.标签管理
a.标签定义
PII：个人信息
Sensitive：敏感数据
Public：公开数据
自定义标签
b.标签策略
基于标签授权
动态权限
批量管理
继承规则
c.标签分类
数据分类
安全级别
合规要求
业务分类
10.最佳实践
a.策略设计
最小权限原则
角色管理
用户组管理
定期审查
b.审计管理
定期审计
异常检测
合规检查
日志归档
c.性能优化
策略缓存
批量同步
异步审计
资源优化
4.8 atlas：元数据管理
01.介绍
Apache Atlas是Hadoop生态的元数据和数据治理平台。
提供数据分类、血缘追踪、搜索发现。
与Hadoop组件深度集成。
支持自定义元数据模型。
02.核心概念
a.Type类型
Entity Type：实体类型
Relationship Type：关系类型
Classification：分类标签
Struct Type：结构类型
b.Entity实体
数据资产
表、列、进程等
属性集合
唯一标识
c.Lineage血缘
数据流向
上下游关系
转换过程
影响分析
d.Classification分类
数据标签
敏感数据
业务分类
合规标签
03.架构组件
a.Atlas Server
REST API
元数据存储
搜索服务
通知服务
b.Type System
类型定义
模型管理
关系定义
继承体系
c.Graph Engine
JanusGraph
图存储
关系查询
遍历算法
d.Notification
Kafka消息
事件通知
元数据变更
Hook集成
04.Hive集成
a.元数据采集
Hive Hook
自动采集
表、列、分区
DDL操作
b.血缘追踪
表级血缘
列级血缘
SQL解析
依赖关系
c.实体类型
hive_db：数据库
hive_table：表
hive_column：列
hive_process：进程
05.HBase集成
a.元数据采集
HBase Hook
表定义
列族、列
命名空间
b.实体类型
hbase_namespace
hbase_table
hbase_column_family
hbase_column
06.Kafka集成
a.元数据采集
Kafka Hook
Topic信息
Schema定义
消费组
b.实体类型
kafka_topic
kafka_schema
kafka_consumer_group
07.数据分类
a.预定义分类
PII：个人信息
PHI：健康信息
PCI：支付卡信息
Confidential：机密
b.自定义分类
业务分类
安全级别
数据域
标签体系
c.分类传播
自动传播
继承规则
批量打标
规则引擎
08.血缘追踪
a.表级血缘
输入表
输出表
转换过程
依赖关系
b.列级血缘
字段映射
转换逻辑
计算过程
细粒度追踪
c.影响分析
上游影响
下游影响
变更评估
风险分析
09.搜索发现
a.全文搜索
实体搜索
属性搜索
分类搜索
模糊匹配
b.高级搜索
DSL查询
属性过滤
分类过滤
关系查询
c.浏览导航
类型浏览
分类浏览
血缘浏览
关系导航
10.最佳实践
a.元数据管理
及时采集
定期清理
版本管理
质量检查
b.分类管理
统一标准
分类体系
自动打标
定期审查
c.血缘管理
完整追踪
定期验证
影响分析
文档化
4.9 datahub：元数据管理
01.介绍
DataHub 是 LinkedIn 开源的一个现代化元数据管理平台，用于发现、理解和治理企业数据资产。
它提供了统一的元数据模型，支持数据发现、数据血缘、数据质量、数据治理等功能。
DataHub 采用流式架构，支持实时元数据更新，是企业数据治理的重要工具。
02.核心功能
a.元数据管理
统一元数据模型
多源元数据采集
元数据存储
元数据搜索
元数据版本管理
b.数据发现
全文搜索
智能推荐
数据目录
标签分类
数据预览
c.数据血缘
表级血缘
字段级血缘
血缘可视化
影响分析
上下游追溯
d.数据治理
数据质量
数据标准
数据安全
合规管理
权限管理
03.架构组件
a.GMS（General Metadata Service）
元数据服务
REST API
GraphQL API
元数据存储
业务逻辑
b.MAE（Metadata Audit Event）
元数据审计事件
变更记录
事件流
Kafka 消息
c.MCE（Metadata Change Event）
元数据变更事件
实时更新
事件驱动
异步处理
d.Frontend
Web UI
数据发现
血缘展示
用户交互
可视化
e.Ingestion
元数据采集
多源连接器
定时采集
增量更新
04.元数据模型
a.实体（Entity）
Dataset：数据集
Dashboard：仪表板
Chart：图表
DataJob：数据作业
DataFlow：数据流
MLModel：机器学习模型
可扩展实体
b.关系（Relationship）
Consumes：消费关系
Produces：生产关系
Contains：包含关系
OwnedBy：所属关系
自定义关系
c.方面（Aspect）
Schema：表结构
Ownership：所有权
Tags：标签
GlossaryTerms：术语
DataPlatformInstance：数据平台实例
可扩展方面
05.数据源集成
a.数据库
MySQL
PostgreSQL
Oracle
SQL Server
Snowflake
BigQuery
b.数据仓库
Hive
Presto
Trino
Redshift
Teradata
c.数据湖
HDFS
S3
Iceberg
Delta Lake
Hudi
d.BI 工具
Tableau
Looker
Superset
PowerBI
Metabase
e.数据处理
Spark
Airflow
Kafka
Flink
dbt
06.元数据采集
a.配置采集
recipe.yml 配置文件
source：数据源配置
sink：目标配置
transformers：转换器
定时调度
b.采集示例
source:
type: mysql
config:
username: root
password: password
host_port: localhost:3306
database: test
sink:
type: datahub-rest
config:
server: http://localhost:8080
MySQL 元数据采集
c.执行采集
datahub ingest -c recipe.yml
命令行工具
定时任务
增量采集
07.数据血缘
a.血缘类型
表级血缘
字段级血缘
作业血缘
Pipeline 血缘
端到端血缘
b.血缘来源
SQL 解析
作业日志
API 上报
手动标注
自动推断
c.血缘展示
可视化图谱
上下游追溯
影响分析
交互式探索
导出功能
d.应用场景
影响分析
根因分析
数据质量追溯
合规审计
优化决策
08.数据治理
a.数据所有权
Owner 标注
团队管理
责任划分
联系方式
审批流程
b.数据标签
自定义标签
标签分类
标签搜索
标签管理
标签继承
c.术语表
业务术语
术语定义
术语关联
术语层级
术语搜索
d.数据质量
质量规则
质量检查
质量报告
异常告警
质量趋势
09.搜索和发现
a.全文搜索
Elasticsearch 支持
模糊搜索
高亮显示
搜索建议
搜索历史
b.高级搜索
字段搜索
标签过滤
Owner 过滤
平台过滤
组合查询
c.智能推荐
热门数据集
相关数据集
用户偏好
协同过滤
个性化推荐
d.数据预览
Schema 预览
数据样例
统计信息
使用文档
相关资源
10.API 使用
a.REST API
GET /entities/{urn}
POST /entities
PUT /entities/{urn}
DELETE /entities/{urn}
CRUD 操作
b.GraphQL API
query {
dataset(urn: "urn:li:dataset:...") {
name
description
schema {
fields {
fieldPath
type
}
}
}
}
灵活查询
关联查询
c.Python SDK
from datahub.emitter.mce_builder import make_dataset_urn
from datahub.emitter.rest_emitter import DatahubRestEmitter
emitter = DatahubRestEmitter("http://localhost:8080")
dataset_urn = make_dataset_urn("hive", "db.table")
emitter.emit_mce(mce)
编程接口
批量操作
d.Java SDK
DataHubRestEmitter emitter = new DataHubRestEmitter("http://localhost:8080");
MetadataChangeEvent mce = ...;
emitter.emit(mce);
Java 集成
11.使用场景
a.数据发现
快速查找数据
了解数据含义
查看数据血缘
评估数据质量
b.数据治理
元数据管理
数据标准化
合规管理
权限管理
c.影响分析
变更影响评估
下游影响分析
根因分析
优化决策
d.数据质量
质量监控
异常检测
质量报告
持续改进
12.部署和运维
a.部署方式
Docker Compose
Kubernetes
云服务
单机部署
b.存储后端
MySQL/PostgreSQL
Elasticsearch
Kafka
Neo4j（可选）
c.监控
服务健康检查
API 性能监控
采集任务监控
资源使用监控
d.扩展性
水平扩展
负载均衡
高可用
容灾备份
13.最佳实践
a.元数据采集
定时采集
增量更新
错误处理
监控告警
b.数据治理
明确 Owner
规范标签
完善文档
定期审查
c.性能优化
合理索引
缓存策略
批量操作
资源配置
d.安全管理
访问控制
敏感数据保护
审计日志
合规要求
5 数据集成与同步
5.1 nifi：数据流处理
01.介绍
Apache NiFi是强大的数据流处理和分发系统。
提供可视化的数据流设计界面。
支持数据路由、转换、系统集成。
实时数据流处理，高可靠性。
02.核心概念
a.FlowFile流文件
数据单元
属性和内容
不可变
生命周期管理
b.Processor处理器
数据处理组件
输入输出端口
配置属性
调度策略
c.Connection连接
Processor间连接
队列管理
背压机制
优先级
d.Process Group
Processor容器
逻辑分组
可嵌套
模板化
03.架构组件
a.Web Server
UI界面
流程设计
监控管理
配置管理
b.Flow Controller
流程调度
资源管理
线程池
状态管理
c.FlowFile Repository
FlowFile元数据
持久化
WAL日志
快速恢复
d.Content Repository
FlowFile内容
文件存储
多存储位置
容量管理
e.Provenance Repository
数据血缘
审计日志
事件记录
可追溯
04.常用Processor
a.GetFile/PutFile
读取本地文件
写入本地文件
文件过滤
目录监控
b.GetHTTP/InvokeHTTP
HTTP请求
RESTful API
认证支持
响应处理
c.ConsumeKafka/PublishKafka
Kafka消费
Kafka生产
批量处理
事务支持
d.ExecuteSQL/PutSQL
SQL查询
数据库写入
连接池
批量操作
e.ConvertRecord
数据格式转换
JSON、Avro、CSV
Schema注册
高性能
05.数据转换
a.UpdateAttribute
修改FlowFile属性
表达式语言
动态赋值
条件设置
b.ReplaceText
内容替换
正则表达式
全局替换
行处理
c.JoltTransformJSON
JSON转换
Jolt规范
复杂转换
嵌套处理
d.QueryRecord
SQL查询FlowFile
过滤数据
聚合计算
多输出
06.路由控制
a.RouteOnAttribute
基于属性路由
表达式匹配
多路输出
默认路由
b.RouteOnContent
基于内容路由
正则匹配
多模式
优先级
c.DistributeLoad
负载均衡
轮询分发
权重分配
故障转移
07.表达式语言
a.属性引用
${filename}：文件名
${fileSize}：文件大小
${uuid}：唯一ID
${now()}：当前时间
b.函数
${attribute:substring(0,10)}
${attribute:toUpper()}
${attribute:matches('pattern')}
${math:add(1,2)}
c.条件表达式
${attribute:equals('value')}
${attribute:gt(100)}
${attribute:isEmpty()}
${attribute:notNull()}
08.集群模式
a.Zero-Master Clustering
无主节点
自动选举
负载均衡
高可用
b.节点角色
Primary Node：主节点
Cluster Coordinator：协调器
所有节点平等
自动故障转移
c.数据分发
负载均衡
站点到站点
远程进程组
数据复制
09.监控管理
a.UI监控
实时流量
队列状态
Processor状态
系统资源
b.数据血缘
FlowFile追踪
处理历史
事件查看
可视化
c.告警通知
背压告警
错误告警
自定义告警
邮件通知
10.最佳实践
a.流程设计
合理分组
错误处理
日志记录
监控点设置
b.性能优化
并发配置
批量处理
背压设置
资源分配
c.高可用
集群部署
数据持久化
故障恢复
备份策略
5.2 streamsets：数据集成
01.介绍
StreamSets是企业级数据集成平台。
可视化Pipeline设计。
支持批处理和流处理。
数据漂移检测和处理。
02.核心概念
a.Pipeline管道
数据流定义
Origin到Destination
Processor处理
可视化设计
b.Stage阶段
Origin：数据源
Processor：处理器
Destination：目标
Executor：执行器
c.Record记录
数据单元
字段和值
Schema定义
类型系统
d.Data Drift
Schema变更检测
自动适应
告警通知
版本管理
03.数据源Origin
a.File Tail
实时读取文件
日志采集
多文件监控
断点续传
b.Kafka Consumer
Kafka消费
多Topic
消费组
offset管理
c.JDBC Query
数据库查询
增量读取
CDC支持
分页查询
d.HTTP Client
REST API
分页支持
认证
重试机制
04.处理器Processor
a.Field Renamer
字段重命名
批量操作
正则匹配
条件重命名
b.Field Type Converter
类型转换
格式化
默认值
错误处理
c.Expression Evaluator
表达式计算
字段派生
条件判断
函数支持
d.Stream Selector
数据路由
条件分流
多输出
默认流
05.目标Destination
a.Kafka Producer
Kafka生产
分区策略
批量发送
事务支持
b.JDBC Producer
数据库写入
批量插入
Upsert操作
事务控制
c.Hadoop FS
HDFS写入
文件滚动
压缩
分区
d.Elasticsearch
ES写入
批量索引
动态映射
错误处理
06.数据漂移
a.Schema检测
自动检测变更
新增字段
删除字段
类型变更
b.处理策略
告警通知
自动适应
停止Pipeline
记录日志
c.版本管理
Schema版本
兼容性检查
回滚支持
历史记录
07.错误处理
a.Error Records
错误记录
错误原因
原始数据
重试机制
b.Error Handling
丢弃
发送到错误流
停止Pipeline
自定义处理
c.Dead Letter Queue
错误队列
后续处理
人工介入
数据恢复
08.监控管理
a.Pipeline监控
实时吞吐量
记录数
错误率
延迟
b.告警配置
数据漂移告警
错误告警
性能告警
自定义告警
c.指标收集
Prometheus集成
JMX指标
自定义指标
监控大盘
09.集群部署
a.Control Hub
集中管理
Pipeline部署
作业调度
权限管理
b.Data Collector
执行引擎
分布式部署
资源隔离
高可用
c.Edge
边缘计算
轻量级
本地处理
数据过滤
10.最佳实践
a.Pipeline设计
模块化设计
错误处理
监控埋点
文档注释
b.性能优化
批量处理
并行度配置
内存管理
网络优化
c.数据质量
Schema验证
数据清洗
去重
格式标准化
5.3 canal：数据同步
01.介绍
Canal是阿里开源的MySQL binlog增量订阅和消费组件。
基于MySQL主从复制协议。
实时捕获数据变更。
支持多种下游存储。
02.核心概念
a.Server服务端
binlog订阅
事件解析
数据分发
HA支持
b.Instance实例
MySQL连接
binlog消费
过滤规则
位点管理
c.Client客户端
订阅数据
消费处理
ACK确认
批量获取
d.EventParser
binlog解析
事件转换
DDL/DML识别
Schema管理
03.工作原理
a.伪装Slave
模拟MySQL Slave
连接Master
请求binlog
接收事件流
b.binlog解析
Row格式解析
事件类型识别
数据提取
Schema映射
c.数据分发
发送到Client
Kafka集成
RocketMQ集成
自定义Sink
04.部署模式
a.独立部署
单机模式
简单配置
适合测试
无HA
b.HA部署
ZooKeeper协调
主备切换
自动故障转移
高可用
c.集群部署
多Instance
负载均衡
水平扩展
分库分表
05.配置管理
a.Instance配置
canal.instance.mysql.slaveId
canal.instance.master.address
canal.instance.dbUsername
canal.instance.dbPassword
canal.instance.filter.regex
b.过滤规则
库表过滤：db1.table1,db2.*
正则表达式
黑白名单
DML类型过滤
c.位点管理
binlog文件名
binlog位置
GTID支持
断点续传
06.客户端使用
a.SimpleCanalConnector
CanalConnector connector = CanalConnectors.newSingleConnector(...);
connector.connect();
connector.subscribe("db\\..*");
Message message = connector.get(100);
处理数据
connector.ack(message.getId());
b.ClusterCanalConnector
集群模式连接
自动故障转移
负载均衡
ZooKeeper协调
c.消息处理
遍历Entry
解析RowChange
处理Insert/Update/Delete
业务逻辑
07.Kafka集成
a.Canal-Kafka
binlog发送到Kafka
Topic映射
分区策略
消息格式
b.配置
canal.serverMode=kafka
canal.mq.servers=kafka:9092
canal.mq.topic=canal-topic
canal.mq.partition=0
c.消息格式
JSON格式
包含before/after
事件类型
Schema信息
08.数据同步场景
a.异构数据库同步
MySQL到PostgreSQL
MySQL到Oracle
实时同步
数据转换
b.缓存更新
MySQL到Redis
实时更新缓存
缓存失效
一致性保证
c.搜索引擎同步
MySQL到Elasticsearch
实时索引
全文检索
数据同步
d.数据仓库
MySQL到Hive
实时ETL
增量同步
数据湖
09.监控管理
a.Admin管理
Web界面
Instance管理
配置管理
监控查看
b.监控指标
binlog延迟
消费速度
错误次数
连接状态
c.告警通知
延迟告警
错误告警
连接断开
自定义告警
10.最佳实践
a.性能优化
批量获取
并行消费
合理ACK
网络优化
b.高可用
HA部署
位点备份
故障恢复
监控告警
c.数据一致性
事务处理
顺序保证
幂等设计
补偿机制
5.4 datax：离线同步
01.介绍
DataX 是阿里巴巴开源的一个异构数据源离线同步工具，致力于实现包括关系型数据库（MySQL、Oracle等）、
HDFS、Hive、ODPS、HBase、FTP 等各种异构数据源之间稳定高效的数据同步功能。
DataX 采用 Framework + Plugin 架构，支持丰富的数据源类型，是企业数据集成的重要工具。
02.核心特性
a.丰富的数据源支持
关系型数据库（MySQL、Oracle、PostgreSQL、SQL Server等）
大数据存储（HDFS、Hive、HBase、MongoDB等）
文件系统（FTP、本地文件、OSS、S3等）
NoSQL（Redis、Elasticsearch等）
50+ 数据源插件
b.高性能
并行数据同步
内存缓冲队列
批量提交
支持限流
TB 级数据同步
c.灵活配置
JSON 配置文件
支持数据转换
字段映射
过滤条件
自定义 SQL
d.易于扩展
插件化架构
自定义 Reader/Writer
开放接口
社区活跃
03.架构设计
a.Framework
Job 管理
任务调度
资源分配
监控统计
错误处理
b.Reader Plugin
读取数据源
数据抽取
格式转换
发送到 Channel
c.Channel
内存缓冲队列
数据传输通道
流量控制
缓冲管理
d.Writer Plugin
接收数据
数据转换
写入目标
批量提交
e.Transformer
数据转换
字段映射
类型转换
数据清洗
04.支持的数据源
a.关系型数据库
Reader/Writer
MySQLReader/MySQLWriter
OracleReader/OracleWriter
PostgreSQLReader/PostgreSQLWriter
SQLServerReader/SQLServerWriter
DB2Reader/DB2Writer
特点
支持分库分表
支持增量同步
支持自定义 SQL
b.大数据存储
Reader/Writer
HDFSReader/HDFSWriter
HiveReader/HiveWriter
HBaseReader/HBaseWriter
MongoDBReader/MongoDBWriter
特点
支持 Parquet、ORC 格式
支持分区表
支持压缩
c.文件系统
Reader/Writer
FTPReader/FTPWriter
OSSReader/OSSWriter
S3Reader/S3Writer
LocalFileReader/LocalFileWriter
特点
支持多种文件格式
支持压缩文件
支持通配符
d.NoSQL
Reader/Writer
RedisReader/RedisWriter
ElasticsearchReader/ElasticsearchWriter
CassandraReader/CassandraWriter
特点
支持批量操作
支持数据转换
05.配置文件
a.基本结构
{
"job": {
"setting": {
"speed": {
"channel": 3
}
},
"content": [{
"reader": {},
"writer": {}
}]
}
}
JSON 格式
包含 setting 和 content
b.Reader 配置
"reader": {
"name": "mysqlreader",
"parameter": {
"username": "root",
"password": "password",
"column": ["id", "name", "age"],
"connection": [{
"table": ["user"],
"jdbcUrl": ["jdbc:mysql://localhost:3306/test"]
}]
}
}
指定数据源类型
配置连接信息
选择字段和表
c.Writer 配置
"writer": {
"name": "hdfswriter",
"parameter": {
"defaultFS": "hdfs://namenode:9000",
"fileType": "text",
"path": "/user/hive/warehouse/test",
"fileName": "user",
"column": [
{"name": "id", "type": "bigint"},
{"name": "name", "type": "string"},
{"name": "age", "type": "int"}
],
"writeMode": "append",
"fieldDelimiter": "\t"
}
}
指定目标类型
配置写入参数
字段映射
d.性能配置
"setting": {
"speed": {
"channel": 5,
"byte": 1048576,
"record": 10000
},
"errorLimit": {
"record": 0,
"percentage": 0.02
}
}
并发通道数
限流配置
错误容忍
06.数据转换
a.字段映射
Reader 和 Writer 的 column 对应
支持常量
支持函数
类型自动转换
b.数据过滤
Reader 中使用 where 条件
自定义 SQL
减少数据传输
c.数据清洗
Transformer 插件
字段转换
数据脱敏
格式化
d.类型转换
自动类型转换
日期格式转换
字符编码转换
数值精度处理
07.使用示例
a.MySQL 到 HDFS
{
"job": {
"content": [{
"reader": {
"name": "mysqlreader",
"parameter": {
"username": "root",
"password": "password",
"column": ["*"],
"connection": [{
"table": ["orders"],
"jdbcUrl": ["jdbc:mysql://localhost:3306/sales"]
}]
}
},
"writer": {
"name": "hdfswriter",
"parameter": {
"defaultFS": "hdfs://namenode:9000",
"fileType": "text",
"path": "/data/orders",
"fileName": "orders",
"column": [
{"name": "order_id", "type": "bigint"},
{"name": "amount", "type": "double"}
],
"fieldDelimiter": ","
}
}
}]
}
}
MySQL 到 HDFS 同步
b.执行命令
python datax.py job.json
指定配置文件
开始同步
08.性能优化
a.并发控制
调整 channel 数量
根据资源情况设置
避免过高并发
监控资源使用
b.批量大小
调整 batchSize
平衡性能和内存
减少网络开销
提高吞吐量
c.限流配置
byte 限流
record 限流
避免影响源库
保护目标库
d.分片策略
按主键分片
按时间分片
并行读取
提高效率
09.监控和日志
a.执行日志
任务开始和结束时间
读写记录数
字节数
错误信息
性能统计
b.监控指标
同步速度
成功率
错误率
资源使用
任务状态
c.错误处理
脏数据记录
错误日志
重试机制
告警通知
10.使用场景
a.数据迁移
数据库迁移
系统升级
数据中心迁移
云上云下迁移
b.数据同步
实时同步
定时同步
增量同步
全量同步
c.数据集成
多源数据汇总
数据仓库建设
数据湖导入
ETL 处理
d.数据备份
定期备份
异地备份
容灾备份
归档存储
11.与调度工具集成
a.Azkaban
配置 DataX 任务
定时调度
依赖管理
监控告警
b.DolphinScheduler
可视化配置
工作流编排
资源管理
任务监控
c.Airflow
DAG 定义
任务依赖
重试机制
日志管理
d.Cron
简单定时
Shell 脚本
日志记录
错误处理
12.最佳实践
a.配置优化
合理设置并发
选择合适的批量大小
配置限流
错误容忍设置
b.性能调优
分片并行
压缩传输
批量提交
资源监控
c.安全考虑
密码加密
权限控制
审计日志
网络隔离
d.运维管理
定期检查
日志归档
监控告警
文档维护
5.5 debezium：CDC工具
01.介绍
Debezium是开源的CDC（Change Data Capture）平台。
基于Kafka Connect构建。
支持多种数据库的变更捕获。
低延迟，高可靠，易扩展。
02.核心概念
a.Connector连接器
数据库连接
变更捕获
事件发送
状态管理
b.Change Event
变更事件
before/after状态
事件类型
元数据信息
c.Offset偏移量
位置记录
断点续传
Kafka存储
状态恢复
d.Schema Registry
Schema管理
版本控制
兼容性检查
Avro格式
03.支持数据库
a.MySQL
binlog捕获
Row格式
GTID支持
DDL变更
b.PostgreSQL
逻辑复制
WAL日志
插件支持
Schema变更
c.MongoDB
Oplog捕获
Change Stream
文档变更
集合监控
d.其他数据库
SQL Server
Oracle
DB2
Cassandra
04.MySQL Connector
a.配置
{
"name": "mysql-connector",
"config": {
"connector.class": "io.debezium.connector.mysql.MySqlConnector",
"database.hostname": "localhost",
"database.port": "3306",
"database.user": "debezium",
"database.password": "password",
"database.server.id": "184054",
"database.server.name": "dbserver1",
"database.include.list": "inventory",
"database.history.kafka.bootstrap.servers": "kafka:9092",
"database.history.kafka.topic": "schema-changes.inventory"
}
}
b.事件格式
{
"before": {"id": 1, "name": "Alice"},
"after": {"id": 1, "name": "Bob"},
"source": {...},
"op": "u",
"ts_ms": 1234567890
}
op：c(create)、u(update)、d(delete)、r(read)
c.过滤配置
table.include.list：包含表
table.exclude.list：排除表
column.include.list：包含列
column.exclude.list：排除列
05.事件处理
a.消费事件
KafkaConsumer订阅Topic
解析JSON事件
提取before/after
业务处理
b.事件类型
CREATE：插入
UPDATE：更新
DELETE：删除
READ：快照读取
TRUNCATE：截断
c.Schema变更
DDL事件
表结构变更
自动适应
版本管理
06.快照模式
a.initial快照
首次启动全量读取
生成READ事件
建立基线
后续增量
b.schema_only
只读取Schema
不读取数据
快速启动
适合已有数据
c.when_needed
需要时快照
检测位点
自动决策
灵活处理
d.never
不做快照
只增量
需要确保位点
风险较高
07.Kafka Connect集成
a.Standalone模式
单机运行
配置文件
适合开发测试
无高可用
b.Distributed模式
分布式集群
REST API管理
自动负载均衡
高可用
c.Connector管理
POST /connectors：创建
GET /connectors：列表
GET /connectors/{name}/status：状态
DELETE /connectors/{name}：删除
08.数据转换
a.SMT转换
Single Message Transform
内置转换器
自定义转换
链式处理
b.常用转换
ExtractField：提取字段
InsertField：插入字段
ReplaceField：替换字段
TimestampConverter：时间转换
Flatten：扁平化
c.转换配置
"transforms": "unwrap",
"transforms.unwrap.type": "io.debezium.transforms.ExtractNewRecordState",
"transforms.unwrap.drop.tombstones": "false"
09.监控管理
a.JMX指标
事件处理速度
延迟时间
错误次数
连接状态
b.Kafka Connect监控
Connector状态
Task状态
Offset lag
吞吐量
c.告警配置
延迟告警
错误告警
连接断开
数据积压
10.最佳实践
a.性能优化
批量处理
并行度配置
网络优化
资源分配
b.高可用
分布式部署
Offset备份
故障恢复
监控告警
c.数据一致性
exactly-once语义
事务处理
幂等设计
补偿机制
5.6 seatunnel：数据集成
01.介绍
Apache SeaTunnel是新一代高性能分布式数据集成工具。
前身是Waterdrop。
支持海量数据的同步和转换。
统一的批流处理API。
02.核心概念
a.Source数据源
读取数据
多种数据源
批处理/流处理
Schema定义
b.Transform转换
数据处理
字段映射
过滤聚合
自定义逻辑
c.Sink目标
写入数据
多种目标
批量写入
事务支持
d.Connector连接器
插件化设计
易于扩展
社区贡献
版本管理
03.支持引擎
a.Spark引擎
批处理
流处理
Structured Streaming
高性能
b.Flink引擎
流批一体
状态管理
exactly-once
低延迟
c.SeaTunnel引擎
原生引擎
轻量级
高性能
易部署
04.配置文件
a.基本结构
env {
execution.parallelism = 2
job.mode = "BATCH"
}
source {
Jdbc {
url = "jdbc:mysql://localhost:3306/test"
driver = "com.mysql.jdbc.Driver"
query = "select * from users"
}
}
transform {
Sql {
sql = "select id, name, age from users where age > 18"
}
}
sink {
Jdbc {
url = "jdbc:postgresql://localhost:5432/target"
driver = "org.postgresql.Driver"
query = "insert into users values(?, ?, ?)"
}
}
b.环境配置
execution.parallelism：并行度
job.mode：BATCH/STREAMING
checkpoint.interval：检查点间隔
job.name：作业名称
05.Source连接器
a.Jdbc Source
关系型数据库
SQL查询
分页读取
增量读取
b.Kafka Source
Kafka消费
多Topic
消费组
offset管理
c.File Source
本地文件
HDFS文件
S3文件
多种格式
d.Hive Source
Hive表读取
分区读取
ORC/Parquet
元数据集成
06.Transform转换
a.Sql Transform
SQL转换
字段映射
过滤聚合
JOIN操作
b.FieldMapper
字段映射
重命名
类型转换
默认值
c.Filter
数据过滤
条件表达式
正则匹配
自定义函数
d.Split
数据分流
条件路由
多输出
动态分发
07.Sink连接器
a.Jdbc Sink
数据库写入
批量插入
Upsert操作
事务控制
b.Kafka Sink
Kafka生产
分区策略
批量发送
事务支持
c.File Sink
文件写入
多种格式
压缩支持
分区写入
d.Elasticsearch Sink
ES写入
批量索引
动态映射
错误处理
08.批流一体
a.批处理模式
job.mode = "BATCH"
全量数据处理
离线计算
T+1场景
b.流处理模式
job.mode = "STREAMING"
实时数据处理
增量计算
低延迟
c.统一API
相同配置
无缝切换
代码复用
降低成本
09.性能优化
a.并行度配置
execution.parallelism
Source并行度
Sink并行度
资源分配
b.批量处理
batch.size
批量读取
批量写入
提高吞吐
c.内存管理
合理配置内存
避免OOM
GC优化
资源监控
10.最佳实践
a.作业设计
合理分区
批量处理
错误处理
监控埋点
b.性能调优
并行度配置
批量大小
资源分配
网络优化
c.运维管理
日志管理
监控告警
故障恢复
版本管理
6 集群管理与监控
6.1 ambari：集群管理
01.介绍
Apache Ambari是Hadoop集群管理和监控工具。
提供Web界面管理Hadoop生态组件。
自动化部署、配置、监控。
支持多种Hadoop发行版。
02.核心功能
a.集群部署
自动化安装
组件选择
配置管理
依赖处理
b.服务管理
启动停止
重启服务
滚动重启
维护模式
c.配置管理
集中配置
版本管理
配置对比
配置推送
d.监控告警
实时监控
指标收集
告警规则
通知机制
03.架构组件
a.Ambari Server
Web界面
REST API
配置管理
任务调度
b.Ambari Agent
运行在各节点
执行命令
上报状态
日志收集
c.数据库
元数据存储
配置信息
监控数据
PostgreSQL/MySQL
04.集群部署
a.准备工作
SSH免密登录
主机名配置
防火墙设置
JDK安装
b.安装Ambari Server
yum install ambari-server
ambari-server setup
配置数据库
启动服务
c.安装Ambari Agent
yum install ambari-agent
配置Server地址
启动Agent
注册节点
d.部署集群
选择Stack版本
选择组件
分配服务
配置参数
安装部署
05.服务管理
a.服务操作
Start：启动服务
Stop：停止服务
Restart：重启服务
Service Check：服务检查
b.组件操作
Add Component：添加组件
Delete Component：删除组件
Move Component：移动组件
Decommission：下线节点
c.维护模式
关闭告警
暂停监控
维护操作
恢复监控
06.配置管理
a.配置修改
Web界面修改
版本记录
配置对比
回滚支持
b.配置组
默认配置组
自定义配置组
主机分组
差异化配置
c.配置推送
保存配置
重启提示
滚动重启
配置生效
07.监控功能
a.Dashboard
集群概览
服务状态
告警信息
资源使用
b.Metrics指标
CPU、内存、磁盘
网络流量
服务指标
自定义指标
c.Heatmaps热力图
资源分布
负载均衡
热点识别
可视化
08.告警管理
a.告警规则
预定义规则
自定义规则
阈值设置
告警级别
b.通知方式
邮件通知
SNMP通知
脚本通知
Webhook
c.告警组
告警分组
通知对象
通知策略
告警升级
09.用户管理
a.用户认证
本地认证
LDAP认证
Kerberos认证
PAM认证
b.权限管理
集群权限
视图权限
操作权限
角色管理
c.审计日志
操作记录
配置变更
用户行为
合规审计
10.最佳实践
a.集群规划
合理分配组件
资源规划
网络规划
安全规划
b.配置优化
JVM参数
服务参数
资源配置
性能调优
c.运维管理
定期巡检
日志分析
备份恢复
版本升级
6.2 cloudera manager：集群管理
01.介绍
Cloudera Manager是Cloudera提供的企业级集群管理工具。
功能强大，界面友好。
自动化部署、配置、监控、诊断。
支持CDH和CDP平台。
02.核心功能
a.集群管理
自动化部署
服务管理
配置管理
升级管理
b.监控诊断
实时监控
健康检查
性能分析
问题诊断
c.安全管理
Kerberos集成
TLS加密
审计日志
权限控制
d.资源管理
资源池
动态资源分配
YARN队列
Impala资源池
03.架构组件
a.Cloudera Manager Server
Web界面
REST API
配置管理
任务调度
b.Cloudera Manager Agent
节点代理
命令执行
状态上报
日志收集
c.Service Monitor
服务监控
指标收集
健康检查
告警生成
d.Host Monitor
主机监控
资源监控
进程监控
磁盘监控
04.集群部署
a.准备工作
操作系统配置
网络配置
数据库准备
JDK安装
b.安装CM Server
下载安装包
安装Server
配置数据库
启动服务
c.安装CM Agent
自动安装
手动安装
批量部署
验证安装
d.部署集群
添加主机
选择服务
分配角色
配置参数
启动服务
05.服务管理
a.服务操作
Start/Stop/Restart
Rolling Restart
Service Check
Decommission
b.角色管理
添加角色实例
删除角色实例
移动角色实例
角色配置
c.服务依赖
依赖关系
启动顺序
健康依赖
自动处理
06.配置管理
a.配置修改
搜索配置
修改配置
配置验证
配置历史
b.配置组
默认配置组
角色组
主机模板
差异化配置
c.安全配置
Kerberos配置
TLS配置
加密配置
认证配置
07.监控功能
a.Dashboard
集群状态
服务健康
告警信息
资源使用
b.Charts图表
时间序列
多维度
自定义
导出数据
c.健康检查
服务健康
角色健康
主机健康
配置健康
08.诊断工具
a.日志管理
集中日志
日志搜索
日志下载
日志分析
b.Events事件
事件列表
事件过滤
事件详情
事件导出
c.诊断Bundle
收集诊断信息
日志收集
配置收集
系统信息
09.资源管理
a.YARN资源池
静态资源池
动态资源池
队列配置
资源限制
b.Impala资源池
查询资源池
内存限制
查询限制
优先级
c.动态资源池
Fair Scheduler
Capacity Scheduler
资源抢占
弹性配置
10.最佳实践
a.集群规划
硬件选型
网络规划
存储规划
安全规划
b.性能优化
JVM调优
服务调优
资源调优
网络调优
c.运维管理
定期巡检
备份策略
升级计划
灾难恢复
6.3 prometheus：监控告警
01.介绍
Prometheus是开源的监控告警系统。
时间序列数据库。
多维数据模型，灵活查询。
主动拉取指标，服务发现。
02.核心概念
a.Metric指标
时间序列数据
指标名称
标签维度
样本值
b.Label标签
键值对
多维度
过滤聚合
动态标签
c.Target目标
监控对象
抓取端点
服务发现
健康检查
d.Job作业
Target集合
抓取配置
标签添加
重写规则
03.数据模型
a.指标类型
Counter：计数器，只增不减
Gauge：仪表盘，可增可减
Histogram：直方图，分布统计
Summary：摘要，分位数
b.指标命名
<metric_name>{<label_name>=<label_value>, ...}
http_requests_total{method="GET", status="200"}
规范命名
c.时间序列
唯一标识
时间戳
样本值
存储压缩
04.配置文件
a.全局配置
global:
scrape_interval: 15s
evaluation_interval: 15s
external_labels:
cluster: 'prod'
b.抓取配置
scrape_configs:
- job_name: 'prometheus'
static_configs:
- targets: ['localhost:9090']
- job_name: 'node'
static_configs:
- targets: ['node1:9100', 'node2:9100']
c.告警配置
alerting:
alertmanagers:
- static_configs:
- targets: ['localhost:9093']
05.PromQL查询
a.基本查询
http_requests_total：查询指标
http_requests_total{job="api"}：标签过滤
http_requests_total[5m]：范围查询
b.聚合函数
sum(http_requests_total)：求和
avg(cpu_usage)：平均值
max(memory_usage)：最大值
count(up == 1)：计数
c.操作符
rate(http_requests_total[5m])：速率
increase(http_requests_total[1h])：增量
irate(http_requests_total[5m])：瞬时速率
d.高级查询
topk(5, http_requests_total)：Top K
histogram_quantile(0.95, rate(http_request_duration_seconds_bucket[5m]))：分位数
06.服务发现
a.静态配置
static_configs
手动配置Target
适合小规模
b.文件发现
file_sd_configs
JSON/YAML文件
动态更新
灵活配置
c.Kubernetes发现
kubernetes_sd_configs
自动发现Pod/Service
标签映射
动态更新
d.Consul发现
consul_sd_configs
服务注册发现
健康检查
动态更新
07.告警规则
a.规则定义
groups:
- name: example
rules:
- alert: HighRequestRate
expr: rate(http_requests_total[5m]) > 100
for: 5m
labels:
severity: warning
annotations:
summary: "High request rate"
b.告警状态
Inactive：未触发
Pending：等待中
Firing：已触发
状态转换
c.告警路由
Alertmanager处理
分组聚合
抑制静默
通知发送
08.Exporter
a.Node Exporter
主机指标
CPU、内存、磁盘
网络、文件系统
系统监控
b.MySQL Exporter
数据库指标
连接数、QPS
慢查询
复制状态
c.JMX Exporter
Java应用
JVM指标
GC信息
线程池
d.自定义Exporter
业务指标
自定义逻辑
HTTP接口
指标暴露
09.存储优化
a.本地存储
TSDB时间序列数据库
数据压缩
数据分块
保留策略
b.远程存储
Remote Write
Remote Read
长期存储
扩展性
c.数据保留
--storage.tsdb.retention.time
--storage.tsdb.retention.size
自动清理
容量规划
10.最佳实践
a.指标设计
合理命名
标签使用
基数控制
避免高基数
b.查询优化
避免大范围查询
合理使用聚合
缓存利用
分页查询
c.高可用
联邦集群
远程存储
Alertmanager集群
数据备份
6.4 finebi：可视化分析
01.介绍
FineBI 是帆软软件推出的一款商业智能（BI）和数据分析工具，专注于企业级数据分析和可视化。
它提供了强大的自助式分析能力，使业务人员无需编写代码即可进行数据探索、分析和报表制作。
FineBI 支持多种数据源连接，提供丰富的可视化图表，是企业数字化转型的重要工具。
02.核心功能
a.自助式分析
拖拽式操作
无需编程
业务人员可用
快速上手
灵活探索数据
b.数据连接
支持多种数据库
Excel、CSV 文件
API 接口
实时数据连接
定时更新
c.数据处理
数据清洗
数据转换
字段计算
数据关联
ETL 功能
d.可视化分析
丰富的图表类型
交互式仪表板
钻取联动
动态筛选
移动端支持
03.数据源支持
a.关系型数据库
MySQL
Oracle
SQL Server
PostgreSQL
DB2
JDBC 连接
b.大数据平台
Hive
Impala
Spark SQL
ClickHouse
Doris
c.文件数据
Excel
CSV
TXT
本地文件
FTP 文件
d.云数据库
阿里云 RDS
腾讯云数据库
AWS RDS
Azure SQL
e.其他数据源
API 接口
SAP
Salesforce
自定义数据源
04.数据处理能力
a.数据准备
数据抽取
数据清洗
去重去空
数据类型转换
字段重命名
b.数据建模
维度建模
事实表和维度表
星型模型
雪花模型
自助数据集
c.数据计算
计算字段
聚合计算
同环比计算
累计计算
排名计算
d.数据关联
表关联
左右连接
内外连接
多表关联
关联关系管理
05.可视化图表
a.基础图表
柱状图
折线图
饼图
散点图
面积图
b.高级图表
地图（热力图、区域图）
漏斗图
雷达图
仪表盘
词云图
c.表格
明细表
分组表
交叉表
汇总表
树形表
d.自定义图表
组合图
双轴图
自定义配色
图表联动
钻取功能
06.仪表板设计
a.布局设计
自由布局
网格布局
响应式布局
组件对齐
自适应屏幕
b.交互功能
参数控件
过滤器
联动钻取
跳转链接
动态标题
c.美化功能
主题配色
背景设置
边框样式
字体设置
图标美化
d.移动端
移动端适配
手势操作
离线查看
消息推送
07.权限管理
a.用户管理
用户创建
角色分配
部门组织
用户组
LDAP 集成
b.数据权限
行级权限
列级权限
数据过滤
动态权限
细粒度控制
c.功能权限
查看权限
编辑权限
导出权限
分享权限
管理权限
d.审计日志
操作记录
访问日志
数据追踪
安全审计
08.协作分享
a.报表分享
链接分享
定时推送
邮件发送
钉钉/企业微信
公开链接
b.订阅推送
定时订阅
邮件订阅
移动端推送
条件触发
自定义频率
c.协作编辑
多人协作
版本管理
评论功能
收藏夹
标签分类
d.导出功能
Excel 导出
PDF 导出
图片导出
数据导出
批量导出
09.性能优化
a.数据缓存
智能缓存
定时更新
增量更新
缓存预热
缓存管理
b.查询优化
SQL 优化
索引利用
分区查询
并行查询
查询限制
c.抽取引擎
数据抽取
本地存储
快速查询
列式存储
压缩存储
d.集群部署
负载均衡
高可用
横向扩展
资源隔离
10.使用场景
a.经营分析
销售分析
财务分析
运营分析
KPI 监控
经营驾驶舱
b.业务监控
实时监控
异常预警
趋势分析
对比分析
多维分析
c.数据报表
日报周报
月度报表
年度总结
专题分析
定制报表
d.决策支持
数据洞察
趋势预测
辅助决策
战略分析
风险评估
11.部署方式
a.单机部署
开发测试环境
小规模使用
快速部署
资源要求低
b.集群部署
生产环境
高可用
负载均衡
横向扩展
c.云部署
公有云
私有云
混合云
SaaS 服务
d.容器化部署
Docker
Kubernetes
微服务架构
弹性伸缩
12.最佳实践
a.数据建模
合理设计数据模型
优化表关联
减少数据冗余
提高查询效率
b.仪表板设计
简洁明了
重点突出
交互友好
性能优化
c.权限设计
最小权限原则
分级管理
定期审查
安全合规
d.性能调优
合理使用缓存
优化 SQL 查询
控制数据量
监控系统资源
6.5 DataEase：可视化分析
01.介绍
DataEase 是开源的数据可视化分析工具，专为企业级应用设计。
它提供了丰富的数据连接能力、灵活的可视化组件、强大的权限管理，帮助企业快速构建数据分析平台。
DataEase 采用前后端分离架构，支持私有化部署，是国产开源 BI 工具的代表。
02.核心功能
a.数据连接
关系型数据库
大数据平台
Excel 文件
API 接口
多源数据集成
b.数据处理
数据集管理
SQL 数据集
自定义数据集
数据关联
计算字段
c.可视化分析
丰富的图表类型
拖拽式操作
交互式仪表板
钻取联动
移动端支持
d.权限管理
用户管理
角色管理
数据权限
功能权限
细粒度控制
03.数据源支持
a.关系型数据库
MySQL
PostgreSQL
Oracle
SQL Server
MariaDB
ClickHouse
Doris
b.大数据平台
Hive
Impala
Presto
StarRocks
Elasticsearch
c.文件数据
Excel
CSV
API 接口
自定义数据源
d.云数据库
阿里云 RDS
腾讯云数据库
华为云数据库
AWS RDS
04.数据集管理
a.数据库数据集
连接数据源
选择表
字段配置
数据预览
定时更新
b.SQL 数据集
自定义 SQL
复杂查询
多表关联
参数化查询
灵活定制
c.Excel 数据集
上传 Excel
数据解析
字段映射
增量更新
简单易用
d.API 数据集
HTTP 接口
JSON 数据
参数配置
定时拉取
实时数据
e.关联数据集
多数据集关联
左右连接
内外连接
字段映射
数据整合
05.图表类型
a.基础图表
柱状图
折线图
饼图
环形图
面积图
散点图
b.高级图表
组合图
双轴图
瀑布图
漏斗图
雷达图
仪表盘
c.地图
中国地图
世界地图
热力图
气泡图
飞线图
自定义地图
d.表格
明细表
分组表
交叉表
透视表
汇总表
e.其他图表
词云图
矩形树图
桑基图
关系图
自定义图表
06.仪表板设计
a.布局设计
自由布局
网格布局
Tab 布局
组件对齐
响应式设计
b.组件配置
图表组件
文本组件
图片组件
视频组件
iframe 组件
时间组件
c.交互功能
参数控件
过滤器
联动
钻取
跳转
下钻
d.样式美化
主题配色
背景设置
边框样式
字体配置
图标美化
自定义 CSS
07.权限管理
a.用户管理
用户创建
用户组
部门组织
LDAP 集成
单点登录
b.角色管理
系统角色
自定义角色
权限分配
角色继承
灵活配置
c.数据权限
行级权限
列级权限
数据过滤
动态权限
细粒度控制
d.功能权限
查看权限
编辑权限
导出权限
分享权限
管理权限
e.审计日志
操作记录
访问日志
数据追踪
安全审计
合规管理
08.分享和协作
a.仪表板分享
链接分享
公开链接
密码保护
有效期设置
访问统计
b.定时推送
邮件推送
钉钉推送
企业微信推送
飞书推送
定时任务
c.导出功能
PDF 导出
Excel 导出
图片导出
数据导出
批量导出
d.协作功能
收藏夹
评论
标签
版本管理
团队协作
09.移动端支持
a.移动端适配
响应式布局
手势操作
触摸交互
自适应屏幕
b.移动端功能
查看仪表板
数据筛选
图表交互
离线查看
消息推送
c.移动端应用
iOS 应用
Android 应用
微信小程序
H5 页面
原生体验
10.插件扩展
a.数据源插件
自定义数据源
插件开发
插件市场
社区贡献
b.图表插件
自定义图表
ECharts 集成
第三方图表
插件开发
c.功能插件
认证插件
推送插件
导出插件
扩展功能
11.部署方式
a.单机部署
Docker 部署
快速启动
开发测试
资源要求低
b.集群部署
高可用部署
负载均衡
数据库集群
生产环境
c.Kubernetes 部署
容器化部署
弹性伸缩
自动恢复
云原生
d.私有化部署
内网部署
数据安全
定制开发
企业级支持
12.使用场景
a.经营分析
销售分析
财务分析
运营分析
KPI 监控
经营驾驶舱
b.业务监控
实时监控
异常预警
趋势分析
对比分析
多维分析
c.数据报表
日报周报
月度报表
年度总结
专题分析
定制报表
d.自助分析
业务人员自助
数据探索
即席查询
灵活分析
降低门槛
13.性能优化
a.数据缓存
查询缓存
定时更新
增量更新
缓存管理
b.查询优化
SQL 优化
索引利用
分页查询
并发控制
c.前端优化
懒加载
虚拟滚动
图表优化
资源压缩
d.系统优化
数据库优化
服务器配置
网络优化
监控调优
14.最佳实践
a.数据建模
合理设计数据集
优化 SQL 查询
减少数据冗余
提高查询效率
b.仪表板设计
简洁明了
重点突出
交互友好
性能优化
c.权限设计
最小权限原则
分级管理
定期审查
安全合规
d.运维管理
定期备份
监控告警
日志管理
版本升级
6.6 grafana：可视化监控
01.介绍
Grafana是开源的可视化和分析平台。
支持多种数据源。
丰富的图表类型。
强大的Dashboard功能。
02.核心概念
a.Dashboard仪表板
可视化面板集合
布局管理
变量支持
模板化
b.Panel面板
单个图表
多种类型
查询配置
样式设置
c.Data Source
数据源
Prometheus、InfluxDB等
查询语言
数据转换
d.Alert告警
告警规则
通知渠道
告警状态
静默管理
03.数据源配置
a.Prometheus
URL配置
认证设置
查询优化
数据缓存
b.InfluxDB
连接配置
数据库选择
查询语言
时间范围
c.Elasticsearch
集群配置
索引模式
时间字段
查询DSL
d.MySQL
连接配置
SQL查询
时间序列
表格数据
04.Panel类型
a.Graph图表
时间序列
多条曲线
堆叠显示
阈值线
b.Stat统计
单值显示
趋势指示
阈值颜色
单位格式
c.Table表格
表格数据
列配置
排序过滤
样式设置
d.Heatmap热力图
密度分布
颜色映射
时间维度
数值范围
05.查询配置
a.Prometheus查询
PromQL表达式
Legend格式
时间范围
步长设置
b.查询变量
$variable引用
动态查询
多选支持
级联变量
c.数据转换
Transform
计算字段
过滤数据
合并Series
06.变量管理
a.Query变量
数据源查询
动态值
多选支持
正则过滤
b.Custom变量
自定义值
静态列表
键值对
默认值
c.Interval变量
时间间隔
自动调整
最小间隔
步长计算
d.变量使用
Panel查询
Panel标题
重复Panel
链接跳转
07.告警配置
a.告警规则
查询条件
阈值设置
评估频率
持续时间
b.通知渠道
Email邮件
Slack
钉钉、企业微信
Webhook
c.告警状态
OK：正常
Pending：待定
Alerting：告警
No Data：无数据
08.Dashboard管理
a.Dashboard设计
布局规划
Panel组织
变量设计
交互设计
b.模板变量
动态过滤
多维度切换
级联选择
URL参数
c.Dashboard导入导出
JSON格式
分享Dashboard
版本管理
模板库
09.用户权限
a.组织管理
多租户
组织隔离
资源分配
权限继承
b.用户角色
Admin：管理员
Editor：编辑者
Viewer：查看者
自定义角色
c.Dashboard权限
查看权限
编辑权限
文件夹权限
细粒度控制
10.最佳实践
a.Dashboard设计
合理布局
变量使用
性能优化
用户体验
b.查询优化
合理时间范围
减少查询数量
使用变量
缓存利用
c.告警管理
合理阈值
告警分级
通知策略
告警收敛
6.7 superset：数据可视化
01.介绍
Apache Superset是现代化的数据探索和可视化平台。
支持多种数据库。
丰富的可视化类型。
SQL Lab交互式查询。
02.核心功能
a.数据探索
可视化图表
交互式分析
下钻上卷
数据过滤
b.SQL Lab
SQL编辑器
查询历史
结果导出
查询优化
c.Dashboard
仪表板
图表组合
过滤器
自动刷新
d.权限管理
行级安全
列级安全
角色权限
数据源权限
03.数据源配置
a.数据库连接
SQLAlchemy URI
连接池配置
SSL配置
测试连接
b.支持数据库
MySQL、PostgreSQL
Hive、Presto
ClickHouse、Druid
Elasticsearch
c.数据集Dataset
表或查询
列定义
指标定义
维度定义
04.图表类型
a.基础图表
Table表格
Line折线图
Bar柱状图
Pie饼图
Area面积图
b.高级图表
Heatmap热力图
Treemap树图
Sunburst旭日图
Sankey桑基图
Funnel漏斗图
c.地图图表
World Map世界地图
Country Map国家地图
Deck.gl地图
Mapbox地图
d.时间序列
Time Series时间序列
Compare对比图
Horizon地平线图
05.SQL Lab
a.查询编辑
SQL编辑器
语法高亮
自动补全
格式化
b.查询执行
异步执行
查询限制
超时设置
结果缓存
c.结果处理
结果预览
CSV导出
可视化
保存查询
06.Dashboard创建
a.添加图表
拖拽布局
调整大小
图表配置
交互设置
b.过滤器
全局过滤
图表过滤
时间过滤
级联过滤
c.样式设置
主题配置
颜色方案
字体设置
布局优化
07.权限管理
a.角色管理
Admin：管理员
Alpha：高级用户
Gamma：普通用户
自定义角色
b.数据源权限
数据库权限
Schema权限
表权限
细粒度控制
c.行级安全
RLS规则
SQL过滤
用户绑定
动态过滤
08.缓存策略
a.查询缓存
结果缓存
TTL设置
缓存键
缓存后端
b.Dashboard缓存
整体缓存
图表缓存
预加载
缓存预热
c.缓存后端
Redis
Memcached
数据库
文件系统
09.性能优化
a.查询优化
SQL优化
分页查询
异步查询
查询限制
b.缓存优化
合理TTL
缓存预热
缓存清理
缓存监控
c.数据库优化
连接池
索引优化
分区表
物化视图
10.最佳实践
a.数据建模
合理设计Dataset
定义指标维度
计算列
虚拟数据集
b.Dashboard设计
合理布局
性能考虑
用户体验
移动端适配
c.权限设计
最小权限
角色规划
行级安全
审计日志
01.介绍
Metabase是简单易用的开源BI工具。
无需SQL即可查询数据。
自动生成图表。
适合非技术人员使用。
02.核心功能
a.问题查询
可视化查询构建器
无需SQL
拖拽操作
自动生成图表
b.SQL查询
原生SQL编辑器
参数化查询
查询片段
结果可视化
c.Dashboard
仪表板
图表组合
过滤器
自动刷新
d.数据探索
自动分析
X-ray功能
数据洞察
趋势发现
03.数据源配置
a.数据库连接
连接配置
SSH隧道
SSL连接
连接测试
b.支持数据库
MySQL、PostgreSQL
MongoDB
Google BigQuery
Snowflake
Presto、Druid
c.数据同步
Schema同步
元数据缓存
定期刷新
手动同步
04.问题构建
a.Simple Question
选择表
选择字段
添加过滤
分组聚合
自动图表
b.Custom Question
多表JOIN
子查询
复杂过滤
自定义表达式
c.Native Query
原生SQL
参数化
变量支持
模板查询
05.可视化类型
a.基础图表
Table表格
Number数字
Line折线图
Bar柱状图
Pie饼图
b.高级图表
Funnel漏斗图
Map地图
Scatter散点图
Combo组合图
Gauge仪表盘
c.智能可视化
自动选择图表类型
根据数据特征
最佳实践推荐
一键切换
06.Dashboard创建
a.添加卡片
问题卡片
文本卡片
链接卡片
拖拽布局
b.过滤器
Dashboard过滤器
字段映射
默认值
级联过滤
c.交互功能
点击行为
跳转链接
参数传递
下钻功能
07.参数化查询
a.参数类型
Text文本
Number数字
Date日期
Dropdown下拉
Location位置
b.参数配置
默认值
必填项
过滤条件
变量引用
c.参数使用
SQL中引用{{param}}
过滤器绑定
Dashboard传递
URL参数
08.权限管理
a.用户组
Administrators管理员
All Users所有用户
自定义组
权限继承
b.数据权限
数据库权限
表权限
行级权限
沙盒模式
c.Collection权限
查看权限
编辑权限
共享权限
文件夹权限
09.自动化功能
a.Pulse脉冲
定时发送
邮件/Slack
订阅Dashboard
数据更新通知
b.Alert告警
条件告警
阈值设置
通知渠道
告警频率
c.X-ray
自动分析
数据洞察
异常检测
趋势发现
10.最佳实践
a.数据建模
合理设计表
添加描述
字段类型
关系定义
b.问题设计
简单明了
合理命名
添加描述
组织Collection
c.性能优化
查询优化
缓存利用
定期清理
监控慢查询
7 机器学习与AI
7.1 mahout：机器学习
01.介绍
Apache Mahout是可扩展的机器学习库。
基于Hadoop和Spark构建。
提供分类、聚类、推荐等算法。
适合大规模数据集。
02.核心算法
a.协同过滤
用户协同过滤
物品协同过滤
推荐系统
评分预测
b.聚类算法
K-Means聚类
Fuzzy K-Means
Canopy聚类
层次聚类
c.分类算法
朴素贝叶斯
随机森林
逻辑回归
决策树
d.降维算法
SVD奇异值分解
PCA主成分分析
LDA主题模型
特征选择
03.推荐系统
a.基于用户
用户相似度
最近邻算法
评分预测
Top-N推荐
b.基于物品
物品相似度
协同过滤
冷启动处理
实时推荐
c.矩阵分解
ALS算法
SVD分解
隐语义模型
大规模数据
04.Spark集成
a.Spark MLlib
分布式算法
DataFrame API
Pipeline
模型持久化
b.算法实现
import org.apache.spark.ml.recommendation.ALS
val als = new ALS()
.setMaxIter(10)
.setRegParam(0.01)
.setUserCol("userId")
.setItemCol("movieId")
.setRatingCol("rating")
val model = als.fit(ratings)
c.模型评估
RMSE均方根误差
MAE平均绝对误差
准确率、召回率
AUC指标
05.聚类分析
a.K-Means
质心初始化
迭代收敛
距离度量
簇数选择
b.Canopy聚类
快速聚类
初始化K-Means
大规模数据
近似算法
c.层次聚类
自底向上
树状结构
距离矩阵
可视化
06.分类任务
a.朴素贝叶斯
文本分类
垃圾邮件过滤
情感分析
概率模型
b.随机森林
集成学习
决策树
特征重要性
过拟合控制
c.逻辑回归
二分类
多分类
正则化
梯度下降
07.特征工程
a.特征提取
TF-IDF
Word2Vec
特征哈希
特征组合
b.特征选择
卡方检验
信息增益
相关系数
递归特征消除
c.特征转换
标准化
归一化
离散化
编码
08.模型评估
a.评估指标
准确率Accuracy
精确率Precision
召回率Recall
F1-Score
AUC-ROC
b.交叉验证
K折交叉验证
留一法
分层采样
时间序列验证
c.模型选择
网格搜索
随机搜索
贝叶斯优化
超参数调优
09.分布式计算
a.MapReduce
Map阶段
Reduce阶段
Combiner优化
分区策略
b.Spark计算
RDD操作
DataFrame
分布式训练
内存计算
c.性能优化
数据分区
缓存策略
并行度
资源配置
10.最佳实践
a.数据准备
数据清洗
特征工程
数据划分
样本平衡
b.模型训练
算法选择
参数调优
交叉验证
模型融合
c.模型部署
模型保存
在线预测
批量预测
模型更新
7.2 mlflow：ML平台
01.介绍
MLflow是开源的机器学习生命周期管理平台。
实验跟踪、模型管理、模型部署。
支持多种ML框架。
简化ML工作流。
02.核心组件
a.MLflow Tracking
实验跟踪
参数记录
指标记录
模型记录
b.MLflow Projects
项目打包
可重现性
环境管理
依赖管理
c.MLflow Models
模型格式
模型注册
模型版本
模型部署
d.MLflow Registry
模型仓库
版本管理
阶段管理
权限控制
03.实验跟踪
a.基本使用
import mlflow
mlflow.start_run()
mlflow.log_param("alpha", 0.5)
mlflow.log_metric("rmse", 0.89)
mlflow.log_artifact("model.pkl")
mlflow.end_run()
b.自动日志
mlflow.autolog()
自动记录参数
自动记录指标
自动记录模型
c.嵌套运行
父运行
子运行
层次结构
批量实验
04.模型管理
a.模型保存
mlflow.sklearn.log_model(model, "model")
mlflow.pytorch.log_model(model, "model")
mlflow.tensorflow.log_model(model, "model")
统一接口
b.模型加载
model = mlflow.sklearn.load_model("runs:/<run_id>/model")
model = mlflow.pyfunc.load_model("models:/<model_name>/<version>")
版本管理
c.模型签名
输入Schema
输出Schema
类型定义
验证
05.模型注册
a.注册模型
mlflow.register_model("runs:/<run_id>/model", "MyModel")
模型名称
版本号
描述信息
b.模型阶段
None：无阶段
Staging：测试阶段
Production：生产阶段
Archived：归档
c.模型转换
client.transition_model_version_stage("MyModel", 1, "Production")
阶段切换
版本管理
06.模型部署
a.本地部署
mlflow models serve -m "models:/<model_name>/<version>" -p 5000
REST API
本地测试
b.Docker部署
mlflow models build-docker -m "models:/<model_name>/<version>" -n my-model
容器化
可移植
c.云部署
AWS SageMaker
Azure ML
Google AI Platform
一键部署
07.Projects管理
a.项目结构
MLproject文件
conda.yaml环境
代码文件
数据文件
b.运行项目
mlflow run <project_uri> -P alpha=0.5
参数传递
环境隔离
可重现
c.项目模板
标准模板
最佳实践
快速开始
自定义模板
08.UI界面
a.实验查看
运行列表
参数对比
指标对比
可视化图表
b.模型查看
模型列表
版本历史
阶段管理
模型详情
c.搜索过滤
参数过滤
指标过滤
标签过滤
时间过滤
09.集成框架
a.Scikit-learn
mlflow.sklearn
自动日志
模型保存
模型加载
b.PyTorch
mlflow.pytorch
模型保存
自定义模型
推理函数
c.TensorFlow
mlflow.tensorflow
Keras支持
SavedModel
自动日志
d.XGBoost
mlflow.xgboost
模型保存
特征重要性
预测接口
10.最佳实践
a.实验管理
合理命名
标签使用
参数记录
指标记录
b.模型管理
版本控制
阶段管理
模型文档
模型监控
c.团队协作
共享实验
权限管理
代码审查
知识沉淀
7.3 tensorflow：深度学习
01.介绍
TensorFlow是Google开源的深度学习框架。
支持多种平台和设备。
丰富的API和工具。
广泛应用于工业界和学术界。
02.核心概念
a.Tensor张量
多维数组
数据类型
形状Shape
运算操作
b.Graph计算图
节点Node
边Edge
静态图
动态图
c.Session会话
执行环境
资源管理
设备分配
TF 2.x默认Eager
d.Variable变量
可训练参数
持久化
初始化
更新操作
03.Keras API
a.Sequential模型
from tensorflow import keras
model = keras.Sequential([
keras.layers.Dense(128, activation='relu'),
keras.layers.Dropout(0.2),
keras.layers.Dense(10, activation='softmax')
])
顺序堆叠
b.Functional API
inputs = keras.Input(shape=(784,))
x = keras.layers.Dense(128, activation='relu')(inputs)
outputs = keras.layers.Dense(10, activation='softmax')(x)
model = keras.Model(inputs=inputs, outputs=outputs)
灵活构建
c.Model子类化
class MyModel(keras.Model):
def __init__(self):
super().__init__()
self.dense1 = keras.layers.Dense(128, activation='relu')
self.dense2 = keras.layers.Dense(10, activation='softmax')
def call(self, inputs):
x = self.dense1(inputs)
return self.dense2(x)
自定义模型
04.模型训练
a.编译模型
model.compile(
optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy']
)
优化器、损失函数、指标
b.训练模型
model.fit(
x_train, y_train,
epochs=10,
batch_size=32,
validation_split=0.2
)
训练数据、验证数据
c.评估模型
model.evaluate(x_test, y_test)
测试集评估
性能指标
05.数据处理
a.tf.data API
dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))
dataset = dataset.shuffle(1000).batch(32).prefetch(1)
高效数据管道
b.数据增强
data_augmentation = keras.Sequential([
keras.layers.RandomFlip("horizontal"),
keras.layers.RandomRotation(0.1),
])
图像增强
c.预处理层
Normalization
Rescaling
CenterCrop
内置预处理
06.模型保存
a.SavedModel格式
model.save('my_model')
完整模型保存
跨平台
TensorFlow Serving
b.HDF5格式
model.save('my_model.h5')
Keras格式
权重和架构
c.Checkpoint
checkpoint = tf.train.Checkpoint(model=model)
checkpoint.save('checkpoint')
训练中断恢复
07.分布式训练
a.数据并行
strategy = tf.distribute.MirroredStrategy()
with strategy.scope():
model = create_model()
model.compile(...)
多GPU训练
b.模型并行
大模型分割
跨设备
Pipeline并行
c.TPU训练
resolver = tf.distribute.cluster_resolver.TPUClusterResolver()
tf.config.experimental_connect_to_cluster(resolver)
strategy = tf.distribute.TPUStrategy(resolver)
TPU加速
08.TensorBoard
a.可视化
tensorboard_callback = keras.callbacks.TensorBoard(log_dir='./logs')
model.fit(..., callbacks=[tensorboard_callback])
训练可视化
b.监控指标
损失曲线
准确率曲线
学习率
梯度分布
c.模型图
计算图可视化
层结构
参数统计
09.模型部署
a.TensorFlow Serving
Docker部署
REST API
gRPC接口
批量预测
b.TensorFlow Lite
移动端部署
模型量化
边缘计算
低延迟
c.TensorFlow.js
浏览器部署
Node.js部署
实时推理
隐私保护
10.最佳实践
a.模型设计
合理网络结构
正则化
Batch Normalization
Dropout
b.训练优化
学习率调度
Early Stopping
数据增强
混合精度训练
c.性能优化
数据管道优化
GPU利用率
分布式训练
模型压缩
7.4 pytorch：深度学习
01.介绍
PyTorch是Facebook开源的深度学习框架。
动态计算图，灵活易用。
强大的GPU加速。
广泛应用于研究和生产。
02.核心概念
a.Tensor张量
import torch
x = torch.tensor([[1, 2], [3, 4]])
多维数组
GPU加速
自动求导
b.Autograd自动求导
x = torch.tensor([1.0, 2.0], requires_grad=True)
y = x ** 2
y.backward(torch.tensor([1.0, 1.0]))
print(x.grad)
梯度计算
c.Module模块
nn.Module基类
forward方法
参数管理
层组合
d.Dataset数据集
torch.utils.data.Dataset
__len__和__getitem__
数据加载
批处理
03.模型定义
a.Sequential
model = nn.Sequential(
nn.Linear(784, 128),
nn.ReLU(),
nn.Dropout(0.2),
nn.Linear(128, 10)
)
顺序堆叠
b.自定义Module
class MyModel(nn.Module):
def __init__(self):
super().__init__()
self.fc1 = nn.Linear(784, 128)
self.fc2 = nn.Linear(128, 10)
def forward(self, x):
x = F.relu(self.fc1(x))
return self.fc2(x)
灵活定义
04.模型训练
a.训练循环
for epoch in range(num_epochs):
for batch_idx, (data, target) in enumerate(train_loader):
optimizer.zero_grad()
output = model(data)
loss = criterion(output, target)
loss.backward()
optimizer.step()
标准训练流程
b.优化器
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
optimizer = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.9)
参数更新
c.损失函数
criterion = nn.CrossEntropyLoss()
criterion = nn.MSELoss()
criterion = nn.BCELoss()
损失计算
05.数据加载
a.Dataset
class CustomDataset(torch.utils.data.Dataset):
def __init__(self, data, labels):
self.data = data
self.labels = labels
def __len__(self):
return len(self.data)
def __getitem__(self, idx):
return self.data[idx], self.labels[idx]
自定义数据集
b.DataLoader
train_loader = torch.utils.data.DataLoader(
dataset, batch_size=32, shuffle=True, num_workers=4
)
批量加载
多进程
c.数据增强
from torchvision import transforms
transform = transforms.Compose([
transforms.RandomHorizontalFlip(),
transforms.RandomCrop(32, padding=4),
transforms.ToTensor(),
])
图像增强
06.模型保存
a.保存整个模型
torch.save(model, 'model.pth')
model = torch.load('model.pth')
完整保存
b.保存状态字典
torch.save(model.state_dict(), 'model_weights.pth')
model.load_state_dict(torch.load('model_weights.pth'))
只保存参数
c.Checkpoint
torch.save({
'epoch': epoch,
'model_state_dict': model.state_dict(),
'optimizer_state_dict': optimizer.state_dict(),
'loss': loss,
}, 'checkpoint.pth')
训练状态
07.分布式训练
a.DataParallel
model = nn.DataParallel(model)
多GPU并行
简单易用
单机多卡
b.DistributedDataParallel
torch.distributed.init_process_group(backend='nccl')
model = nn.parallel.DistributedDataParallel(model)
多机多卡
高性能
c.混合精度训练
from torch.cuda.amp import autocast, GradScaler
scaler = GradScaler()
with autocast():
output = model(input)
loss = criterion(output, target)
scaler.scale(loss).backward()
scaler.step(optimizer)
scaler.update()
加速训练
08.TensorBoard集成
a.记录标量
from torch.utils.tensorboard import SummaryWriter
writer = SummaryWriter('runs/experiment')
writer.add_scalar('Loss/train', loss, epoch)
writer.add_scalar('Accuracy/train', acc, epoch)
可视化训练
b.记录图像
writer.add_image('images', img_grid, epoch)
writer.add_figure('matplotlib', fig, epoch)
图像可视化
c.记录模型
writer.add_graph(model, input_sample)
模型结构
09.模型部署
a.TorchScript
traced_model = torch.jit.trace(model, example_input)
traced_model.save('model_traced.pt')
模型序列化
C++部署
b.ONNX导出
torch.onnx.export(model, dummy_input, "model.onnx")
跨框架
推理优化
c.TorchServe
torch-model-archiver --model-name mymodel --version 1.0 --serialized-file model.pt --handler image_classifier
torchserve --start --model-store model_store --models mymodel=mymodel.mar
生产部署
10.最佳实践
a.模型设计
合理网络结构
Batch Normalization
Residual连接
注意力机制
b.训练技巧
学习率调度
梯度裁剪
权重初始化
数据增强
c.性能优化
GPU利用率
混合精度
分布式训练
模型压缩
8 分布式数据库
8.1 greenplum：MPP数据库
01.介绍
Greenplum是开源的MPP（大规模并行处理）数据库。
基于PostgreSQL构建。
支持PB级数据分析。
列式存储，高性能查询。
02.核心架构
a.Master节点
接收查询请求
SQL解析优化
生成执行计划
协调Segment
元数据管理
b.Segment节点
存储数据
执行查询
并行处理
结果返回
c.Interconnect
节点间通信
数据交换
高速网络
UDP协议
d.分布策略
Hash分布
Random分布
Replicated分布
数据均衡
03.表分布
a.Hash分布
CREATE TABLE sales (id INT, amount DECIMAL)
DISTRIBUTED BY (id);
根据列Hash
数据均匀分布
b.Random分布
CREATE TABLE logs (id INT, message TEXT)
DISTRIBUTED RANDOMLY;
随机分布
适合临时表
c.Replicated分布
CREATE TABLE dim_date (date_key INT, date_value DATE)
DISTRIBUTED REPLICATED;
全节点复制
适合维度表
04.列式存储
a.AO表
CREATE TABLE sales_ao (id INT, amount DECIMAL)
WITH (appendonly=true);
追加优化
压缩存储
批量加载
b.列存储
CREATE TABLE sales_col (id INT, amount DECIMAL)
WITH (appendonly=true, orientation=column);
列式存储
高压缩比
OLAP优化
c.压缩算法
zlib：通用压缩
quicklz：快速压缩
zstd：高压缩比
RLE：游程编码
05.分区表
a.Range分区
CREATE TABLE sales (id INT, sale_date DATE, amount DECIMAL)
PARTITION BY RANGE (sale_date)
(
START ('2024-01-01') END ('2024-12-31') EVERY (INTERVAL '1 month')
);
按范围分区
b.List分区
CREATE TABLE sales (id INT, region TEXT, amount DECIMAL)
PARTITION BY LIST (region)
(
PARTITION east VALUES ('NY', 'MA'),
PARTITION west VALUES ('CA', 'WA')
);
按列表分区
c.分区裁剪
查询自动裁剪
只扫描相关分区
提高性能
06.查询优化
a.ORCA优化器
基于成本优化
动态分区消除
JOIN重排序
子查询优化
b.执行计划
EXPLAIN查看计划
EXPLAIN ANALYZE执行分析
Motion操作
Gather/Redistribute
c.统计信息
ANALYZE table_name;
收集统计信息
优化执行计划
定期更新
07.数据加载
a.COPY命令
COPY sales FROM '/data/sales.csv' WITH CSV HEADER;
批量加载
高性能
并行加载
b.gpfdist
gpfdist -d /data -p 8080 &
COPY sales FROM 'gpfdist://host:8080/sales.csv' WITH CSV;
并行文件服务
高速加载
c.外部表
CREATE EXTERNAL TABLE ext_sales (id INT, amount DECIMAL)
LOCATION ('gpfdist://host:8080/*.csv')
FORMAT 'CSV';
SELECT * FROM ext_sales;
查询外部数据
08.资源管理
a.资源队列
CREATE RESOURCE QUEUE adhoc WITH (ACTIVE_STATEMENTS=5, MEMORY_LIMIT='2GB');
ALTER ROLE analyst RESOURCE QUEUE adhoc;
并发控制
内存限制
b.资源组
CREATE RESOURCE GROUP rg_adhoc WITH (CPU_RATE_LIMIT=20, MEMORY_LIMIT=20);
ALTER ROLE analyst RESOURCE GROUP rg_adhoc;
CPU限制
内存限制
09.高可用
a.Master镜像
主Master
备Master
自动故障转移
元数据同步
b.Segment镜像
主Segment
镜像Segment
数据同步
故障恢复
c.备份恢复
gpbackup备份
gprestore恢复
增量备份
并行备份
10.最佳实践
a.表设计
合理分布键
使用列存储
合理分区
压缩策略
b.查询优化
分区裁剪
统计信息
避免数据倾斜
合理JOIN
c.运维管理
定期VACUUM
定期ANALYZE
监控资源
日志分析
8.2 tidb：分布式数据库
01.介绍
TiDB是PingCAP开源的分布式NewSQL数据库。
兼容MySQL协议。
水平扩展，高可用。
HTAP混合负载。
02.核心架构
a.TiDB Server
无状态SQL层
MySQL协议
SQL解析优化
分布式执行
b.TiKV存储
分布式KV存储
Raft协议
MVCC多版本
事务支持
c.PD调度
集群元数据
时间戳分配
数据调度
负载均衡
d.TiFlash列存
列式存储
实时同步
OLAP加速
HTAP支持
03.分布式事务
a.Percolator模型
两阶段提交
乐观锁
MVCC
分布式事务
b.隔离级别
Read Committed
Repeatable Read
Serializable
快照隔离
c.事务冲突
乐观锁冲突
自动重试
悲观锁模式
冲突检测
04.数据分片
a.Region
数据分片单元
默认96MB
自动分裂
动态调度
b.分布策略
Range分片
Hash分片
按主键分布
负载均衡
c.副本机制
Raft协议
多副本
自动故障转移
数据一致性
05.SQL兼容
a.MySQL兼容
MySQL协议
大部分语法
函数兼容
工具兼容
b.扩展语法
SPLIT TABLE：手动分裂
SHOW TABLE REGIONS：查看Region
ADMIN CHECK TABLE：一致性检查
分布式SQL
c.不兼容特性
触发器
存储过程
外键约束
部分函数
06.HTAP能力
a.TiFlash
列式副本
实时同步
OLAP查询
智能选择
b.混合负载
OLTP事务
OLAP分析
同一集群
资源隔离
c.查询路由
自动选择
行存或列存
基于成本
透明切换
07.性能优化
a.索引优化
主键索引
二级索引
覆盖索引
索引提示
b.执行计划
EXPLAIN查看
EXPLAIN ANALYZE分析
统计信息
Hint优化
c.批量操作
批量插入
批量更新
事务批处理
提高吞吐
08.高可用
a.自动故障转移
Raft选举
秒级切换
无数据丢失
自动恢复
b.在线扩容
动态添加节点
自动数据迁移
无需停机
负载均衡
c.备份恢复
BR备份工具
全量备份
增量备份
PITR恢复
09.监控管理
a.Prometheus监控
集群指标
查询性能
资源使用
告警规则
b.Grafana可视化
Dashboard
实时监控
历史趋势
自定义图表
c.慢查询日志
慢查询记录
执行计划
优化建议
性能分析
10.最佳实践
a.表设计
合理主键
避免热点
使用自增ID
分区表
b.查询优化
使用索引
避免全表扫描
批量操作
连接池
c.运维管理
定期备份
监控告警
容量规划
版本升级
8.3 oceanbase：分布式数据库
01.介绍
OceanBase是阿里开源的分布式关系数据库。
金融级高可用。
支持OLTP和OLAP。
兼容MySQL和Oracle。
02.核心架构
a.OBServer
SQL引擎
存储引擎
事务引擎
分布式执行
b.RootService
集群管理
负载均衡
故障转移
资源调度
c.分区管理
数据分区
副本管理
日志同步
Paxos协议
03.多租户
a.租户隔离
资源隔离
数据隔离
性能隔离
安全隔离
b.资源配置
CPU配额
内存配额
IOPS配额
动态调整
c.租户管理
创建租户
删除租户
资源分配
权限管理
04.分布式事务
a.Paxos协议
多数派协议
强一致性
高可用
自动故障转移
b.事务模型
两阶段提交
分布式事务
MVCC
快照隔离
c.性能优化
本地事务优化
批量提交
并行回放
日志压缩
05.数据分区
a.分区策略
Range分区
Hash分区
List分区
组合分区
b.分区管理
自动分裂
分区合并
分区迁移
负载均衡
c.副本机制
多副本
Paxos同步
自动故障转移
数据一致性
06.兼容性
a.MySQL兼容
MySQL协议
SQL语法
函数兼容
工具兼容
b.Oracle兼容
PL/SQL
包和存储过程
触发器
序列
c.扩展功能
全局索引
分区表
物化视图
并行查询
07.HTAP能力
a.行列混存
行存储
列存储
自动选择
混合查询
b.实时分析
OLTP实时写入
OLAP实时查询
无需ETL
统一存储
c.查询优化
向量化执行
并行查询
智能路由
代价优化
08.高可用
a.多副本
Paxos协议
强一致性
RPO=0
RTO<30s
b.故障恢复
自动故障检测
自动Leader切换
自动数据修复
无人工介入
c.容灾方案
同城双活
两地三中心
异地多活
灾备切换
09.性能优化
a.SQL优化
执行计划
索引优化
统计信息
Hint提示
b.参数调优
内存配置
并发配置
缓存配置
日志配置
c.硬件优化
SSD存储
高速网络
充足内存
多核CPU
10.最佳实践
a.表设计
合理分区
主键设计
索引设计
数据类型
b.查询优化
使用绑定变量
批量操作
避免全表扫描
合理JOIN
c.运维管理
监控告警
定期备份
容量规划
版本升级
8.4 cassandra：NoSQL数据库
01.介绍
Apache Cassandra是分布式NoSQL数据库。
高可用，无单点故障。
线性扩展，写入性能强。
最终一致性。
02.核心概念
a.Keyspace
类似数据库
副本策略
数据中心
命名空间
b.Table表
列族
主键
分区键
聚簇键
c.Partition分区
数据分片
Hash分布
Token环
虚拟节点
d.Replication副本
副本因子
副本策略
一致性级别
数据冗余
03.数据模型
a.主键设计
Partition Key：分区键
Clustering Key：聚簇键
复合主键
数据分布
b.列族
静态列
动态列
集合类型
UDT类型
c.数据类型
基本类型：int、text、timestamp
集合类型：set、list、map
UDT：用户定义类型
Counter：计数器
04.CQL查询
a.创建Keyspace
CREATE KEYSPACE mykeyspace
WITH replication = {
'class': 'SimpleStrategy',
'replication_factor': 3
};
b.创建表
CREATE TABLE users (
user_id UUID PRIMARY KEY,
name text,
email text,
created_at timestamp
);
c.插入数据
INSERT INTO users (user_id, name, email, created_at)
VALUES (uuid(), 'Alice', 'alice@example.com', toTimestamp(now()));
d.查询数据
SELECT * FROM users WHERE user_id = ?;
必须包含分区键
05.一致性级别
a.写一致性
ONE：一个副本确认
QUORUM：多数副本确认
ALL：所有副本确认
LOCAL_QUORUM：本地多数
b.读一致性
ONE：读一个副本
QUORUM：读多数副本
ALL：读所有副本
LOCAL_QUORUM：本地多数
c.调优策略
强一致性：QUORUM读写
最终一致性：ONE读写
平衡性能和一致性
06.数据分布
a.Token环
一致性Hash
虚拟节点
数据分布
负载均衡
b.分区器
Murmur3Partitioner
RandomPartitioner
Hash函数
均匀分布
c.虚拟节点
默认256个
动态分配
简化扩容
负载均衡
07.集群管理
a.节点添加
配置seeds
启动节点
自动加入
数据迁移
b.节点删除
decommission
数据迁移
Token重分配
集群平衡
c.数据修复
nodetool repair
反熵修复
定期执行
数据一致性
08.性能优化
a.数据模型优化
合理分区键
避免大分区
反范式设计
查询驱动建模
b.写入优化
批量写入
异步写入
合理一致性级别
Memtable配置
c.读取优化
使用索引
物化视图
缓存策略
合理一致性级别
09.监控管理
a.nodetool命令
nodetool status：集群状态
nodetool info：节点信息
nodetool tpstats：线程池统计
nodetool cfstats：表统计
b.JMX监控
Prometheus集成
Grafana可视化
自定义指标
告警配置
c.日志管理
system.log：系统日志
debug.log：调试日志
gc.log：GC日志
日志级别配置
10.最佳实践
a.数据建模
查询驱动
反范式
避免JOIN
合理分区
b.集群规划
合理副本数
数据中心规划
网络拓扑
容量规划
c.运维管理
定期repair
监控告警
备份策略
版本升级
8.5 mongodb：文档数据库
01.介绍
MongoDB是流行的文档型NoSQL数据库。
灵活的Schema。
强大的查询能力。
水平扩展，高性能。
02.核心概念
a.Database数据库
数据库集合
命名空间
权限管理
逻辑隔离
b.Collection集合
文档集合
类似表
无固定Schema
动态字段
c.Document文档
BSON格式
嵌套结构
数组支持
灵活Schema
d.Index索引
单字段索引
复合索引
文本索引
地理索引
03.CRUD操作
a.插入文档
db.users.insertOne({name: "Alice", age: 25, email: "alice@example.com"})
db.users.insertMany([{...}, {...}])
单个或批量插入
b.查询文档
db.users.find({age: {$gt: 18}})
db.users.findOne({name: "Alice"})
db.users.find().sort({age: -1}).limit(10)
查询条件、排序、分页
c.更新文档
db.users.updateOne({name: "Alice"}, {$set: {age: 26}})
db.users.updateMany({age: {$lt: 18}}, {$set: {status: "minor"}})
更新操作符
d.删除文档
db.users.deleteOne({name: "Alice"})
db.users.deleteMany({age: {$lt: 18}})
删除条件
04.查询操作符
a.比较操作符
$eq、$ne：等于、不等于
$gt、$gte：大于、大于等于
$lt、$lte：小于、小于等于
$in、$nin：在列表中、不在列表中
b.逻辑操作符
$and：与
$or：或
$not：非
$nor：或非
c.元素操作符
$exists：字段存在
$type：字段类型
d.数组操作符
$all：包含所有
$elemMatch：元素匹配
$size：数组大小
05.聚合框架
a.Pipeline管道
db.orders.aggregate([
{$match: {status: "completed"}},
{$group: {_id: "$customer_id", total: {$sum: "$amount"}}},
{$sort: {total: -1}},
{$limit: 10}
])
多阶段处理
b.常用阶段
$match：过滤
$group：分组
$project：投影
$sort：排序
$limit：限制
$lookup：关联
c.聚合操作符
$sum：求和
$avg：平均
$max、$min：最大最小
$push：数组追加
06.索引优化
a.索引类型
单字段索引：{name: 1}
复合索引：{name: 1, age: -1}
多键索引：数组字段
文本索引：全文搜索
地理索引：位置查询
b.索引创建
db.users.createIndex({name: 1})
db.users.createIndex({name: 1, age: -1})
db.users.createIndex({content: "text"})
索引选项
c.索引优化
覆盖索引
索引前缀
避免索引扫描
explain分析
07.副本集
a.架构
Primary主节点
Secondary从节点
Arbiter仲裁节点
自动故障转移
b.配置
rs.initiate()
rs.add("host:port")
rs.status()
副本集管理
c.读写分离
读偏好设置
primary：主节点
secondary：从节点
nearest：最近节点
08.分片集群
a.架构组件
Mongos：路由
Config Server：配置
Shard：分片
分布式架构
b.分片策略
Range分片：范围
Hash分片：哈希
Zone分片：区域
Shard Key选择
c.数据均衡
自动均衡
Chunk迁移
负载均衡
手动均衡
09.事务支持
a.单文档事务
原子性
自动提交
无需显式事务
b.多文档事务
session = client.startSession()
session.startTransaction()
// 操作
session.commitTransaction()
ACID保证
c.分布式事务
跨分片事务
两阶段提交
性能开销
谨慎使用
10.最佳实践
a.数据建模
嵌入vs引用
反范式设计
合理嵌套
避免大文档
b.查询优化
使用索引
投影字段
分页查询
explain分析
c.运维管理
定期备份
监控告警
容量规划
版本升级
8.6 neo4j：图数据库
01.介绍
Neo4j是流行的图数据库。
原生图存储和处理。
Cypher查询语言。
适合关系复杂的场景。
02.核心概念
a.Node节点
实体对象
Label标签
Properties属性
唯一标识
b.Relationship关系
连接节点
有向关系
关系类型
关系属性
c.Label标签
节点分类
索引基础
查询优化
多标签
d.Property属性
键值对
节点属性
关系属性
多种类型
03.Cypher查询
a.创建节点
CREATE (p:Person {name: "Alice", age: 25})
CREATE (c:Company {name: "TechCorp"})
节点和属性
b.创建关系
MATCH (p:Person {name: "Alice"}), (c:Company {name: "TechCorp"})
CREATE (p)-[:WORKS_FOR {since: 2020}]->(c)
关系和属性
c.查询模式
MATCH (p:Person)-[:WORKS_FOR]->(c:Company)
WHERE p.age > 25
RETURN p.name, c.name
模式匹配
d.路径查询
MATCH path = (p1:Person)-[:KNOWS*1..3]-(p2:Person)
WHERE p1.name = "Alice" AND p2.name = "Bob"
RETURN path
可变长度路径
04.图算法
a.路径查找
最短路径：shortestPath
全部路径：allShortestPaths
Dijkstra算法
A*算法
b.中心性算法
度中心性
接近中心性
中介中心性
PageRank
c.社区检测
Louvain算法
Label Propagation
Connected Components
社区划分
d.相似性算法
Jaccard相似度
余弦相似度
Pearson相关
推荐系统
05.索引优化
a.索引类型
单属性索引
复合索引
全文索引
空间索引
b.创建索引
CREATE INDEX FOR (p:Person) ON (p.name)
CREATE INDEX FOR (p:Person) ON (p.name, p.age)
加速查询
c.约束
CREATE CONSTRAINT ON (p:Person) ASSERT p.id IS UNIQUE
唯一性约束
存在性约束
节点键约束
06.性能优化
a.查询优化
使用索引
PROFILE分析
EXPLAIN查看计划
避免笛卡尔积
b.数据建模
合理标签
属性选择
关系方向
避免超级节点
c.批量操作
UNWIND批量创建
LOAD CSV导入
批量提交
事务大小
07.事务管理
a.自动提交
单语句事务
自动提交
简单操作
b.显式事务
BEGIN
// 操作
COMMIT
ROLLBACK
复杂操作
c.事务隔离
Read Committed
快照隔离
锁机制
并发控制
08.集群部署
a.Causal Cluster
Core Server：核心
Read Replica：只读副本
Raft协议
高可用
b.数据分布
自动分片
副本同步
负载均衡
故障转移
c.读写分离
Core写入
Replica读取
路由策略
负载均衡
09.数据导入
a.LOAD CSV
LOAD CSV WITH HEADERS FROM 'file:///data.csv' AS row
CREATE (p:Person {name: row.name, age: toInteger(row.age)})
CSV导入
b.Neo4j Import
neo4j-admin import --nodes=Person=persons.csv --relationships=KNOWS=knows.csv
批量导入
高性能
c.APOC插件
丰富的导入函数
JSON、XML支持
数据库连接
批量操作
10.最佳实践
a.数据建模
合理标签
关系方向
属性选择
避免反模式
b.查询优化
使用索引
限制返回
分页查询
性能分析
c.运维管理
定期备份
监控指标
容量规划
版本升级