大数据篇：Hive
大数据篇：Hive
hive.apache.orgjava
Hive是什么?node
Hive是Facebook开源的用于解决海量结构化日志的数据统计，是基于Hadoop的一个数据仓库工具，能够将结构化的数据文件映射为一张表，而且提供类SQL查询功能，本质是将HQL转化成MapReduce程序。mysql
数据存储在HDFS，分析数据底层实现默认是MapReduce，执行程序运行在Yarn上。sql
若是没有Hiveshell
想象一下数据统计的时候写大量的MapReduce程序，那会是多么痛苦。若是是写SQL就开心多了，尤为是离线数据仓库方面普遍应用。数据库
1 Hive和数据库的区别
因为 Hive 采用了相似SQL 的查询语言 HQL(hive query language)，所以很容易将 Hive 理解为数据库。其实从结构上来看，Hive 和数据库除了拥有相似的查询语言，再无相似之处。express
- 1 查询语言
- 因为SQL被普遍的应用在数据仓库中，所以，专门针对Hive的特性设计了类SQL的查询语言HQL。熟悉SQL开发的开发者能够很方便的使用Hive进行开发。
- 2 数据存储位置
- Hive 是创建在 Hadoop 之上的，全部 Hive 的数据都是存储在 HDFS 中的。而数据库则能够将数据保存在块设备或者本地文件系统中。
- 3 数据更新
- 因为Hive是针对数据仓库应用设计的，而数据仓库的内容是读多写少的。所以，Hive中不支持对数据的改写和添加，全部的数据都是在加载的时候中肯定好的。而数据库中的数据一般是须要常常进行修改的，所以可使用 INSERT INTO … VALUES 添加数据，使用 UPDATE … SET修改数据。
- 4 索引
- Hive在加载数据的过程当中不会对数据进行任何处理，甚至不会对数据进行扫描，所以也没有对数据中的某些Key创建索引。Hive要访问数据中知足条件的特定值时，须要暴力扫描整个数据，所以访问延迟较高。因为 MapReduce 的引入， Hive 能够并行访问数据，所以即便没有索引，对于大数据量的访问，Hive 仍然能够体现出优点。数据库中，一般会针对一个或者几个列创建索引，所以对于少许的特定条件的数据的访问，数据库能够有很高的效率，较低的延迟。因为数据的访问延迟较高，决定了 Hive 不适合在线数据查询。
- 5 执行
- Hive中大多数查询的执行是经过 Hadoop 提供的 MapReduce 来实现的。而数据库一般有本身的执行引擎。
- 6 执行延迟
- Hive 在查询数据的时候，因为没有索引，须要扫描整个表，所以延迟较高。另一个致使 Hive 执行延迟高的因素是 MapReduce框架。因为MapReduce 自己具备较高的延迟，所以在利用MapReduce 执行Hive查询时，也会有较高的延迟。相对的，数据库的执行延迟较低。固然，这个低是有条件的，即数据规模较小，当数据规模大到超过数据库的处理能力的时候，Hive的并行计算显然能体现出优点。
- 7 可扩展性
- 因为Hive是创建在Hadoop之上的，所以Hive的可扩展性是和Hadoop的可扩展性是一致的（世界上最大的Hadoop 集群在 Yahoo!，2009年的规模在4000 台节点左右）。而数据库因为 ACID 语义的严格限制，扩展行很是有限。目前最早进的并行数据库 Oracle 在理论上的扩展能力也只有100台左右。
- 8 数据规模
- 因为Hive创建在集群上并能够利用MapReduce进行并行计算，所以能够支持很大规模的数据；对应的，数据库能够支持的数据规模较小。
2 Hive架构
Hive经过给用户提供的一系列交互接口，接收到用户的指令(SQL)，使用本身的Driver，结合元数据(MetaStore)，将这些指令翻译成MapReduce，提交到Hadoop中执行，最后，将执行返回的结果输出到用户交互接口。apache
- 1）用户接口：Client
- CLI（hive shell）、JDBC/ODBC(java访问hive)、WEBUI（浏览器访问hive，如：Hue）
- 2）元数据：Metastore
- 元数据包括：表名、表所属的数据库（默认是default）、表的拥有者、列/分区字段、表的类型（是不是外部表）、表的数据所在目录等；
- 默认存储在自带的derby数据库中，推荐使用MySQL存储Metastore
- 3）Hadoop
- 使用HDFS进行存储，使用MapReduce进行计算。
- 4）驱动器：Driver
- （1）解析器（SQL Parser）：将SQL字符串转换成抽象语法树AST，这一步通常都用第三方工具库完成，好比antlr；对AST进行语法分析，好比表是否存在、字段是否存在、SQL语义是否有误。
- （2）编译器（Physical Plan）：将AST编译生成逻辑执行计划。
- （3）优化器（Query Optimizer）：对逻辑执行计划进行优化。
- （4）执行器（Execution）：把逻辑执行计划转换成能够运行的物理计划。对于Hive来讲，就是MR/TEZ/Spark。
3 hive经常使用数据类型
| mysql字段类型 | hive:ods字段类型 | hive:dwd字段类型 |
|---|---|---|
| tinyint | tinyint | tinyint |
| int | int | int |
| bigint | bigint | bigint |
| varchar | string | string |
| datetime | bigint | string |
| bit | boolean | int |
| double | double | double |
4 Hive经常使用命令
- 连接hive的三种经常使用方式
- 使用hive脚本能够进入客户端。我这里使用Hue进行演示。
- 使用hue直接操做hive
- hiveserver2 beeline连接方式
- 启动hiveserver2服务
hiveserver2
- 启动beeline
beeline
- beeline连接hiveserver2，输入用户名密码
!connect jdbc:hive2://cdh01.cm:10000
4.1 数据库操做
- 建立数据库
CREATE DATABASE 数据库名字
- 查询数据库
show databases
- 删除数据库
drop database 数据库名字 drop database 数据库名字 cascade
- 显示数据库信息
desc database 数据库名字 desc database extended 数据库名字
- 切换数据库
use 数据库名字
- 查询数据库拥有表
show tables
- 查询表信息
desc formatted 表名
4.2 建立删除表
-
建表语法浏览器
-
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] [LOCATION hdfs_path]
-
-
建表经常使用参数安全
-
EXTERNAL：外部表关键字，Hive份内部表（元数据和数据会被一块儿删除，通常不过重要的表如：中间临时表）和外部表（只删除元数据，不删除数据，通常而言都采用外部表，由于数据安全些），通常而言采用外部表。
-
PARTITIONED BY：分区指定字段为'dt'。
PARTITIONED BY ( `dt` String COMMENT 'partition' )
-
row format delimited fields terminated by '\t' ：数据使用什么作切分，这里使用制表符。
-
stored as parquet：文件存储格式，推荐parquet(spark自然支持parquet)。
-
location '/warehouse/层名/库名/表名' ：文件存储位置。
-
tblproperties ("parquet.compression"="snappy") ：文件压缩策略，推荐snappy。
-
CLUSTERED BY建立分桶表(抽样场景使用)
-
SORTED BY排序(通常状况查询语句都有排序，故不经常使用)
-
-
建表例子
#删除表
drop table if exists dwd.student
#建立表(库名.表名)
CREATE EXTERNAL TABLE `dwd.student`(
`ID` bigint COMMENT '',
`CreatedBy` string COMMENT '建立人',
`CreatedTime` string COMMENT '建立时间',
`UpdatedBy` string COMMENT '更新人',
`UpdatedTime` string COMMENT '更新时间',
`Version` int COMMENT '版本号',
`name` string COMMENT '姓名'
) COMMENT '学生表'
PARTITIONED BY (
`dt` String COMMENT 'partition'
)
row format delimited fields terminated by '\t'
location '/warehouse/dwd/test/student/'
stored as parquet
tblproperties ("parquet.compression"="snappy")
建立内部表就是去掉EXTERNAL关键字，使用插入数据案例测试一下删除表后从新创建的效果吧。
4.3 插入数据
INSERT INTO TABLE dwd.student partition(dt='2020-04-05') VALUES(1,"heaton","2020-04-05","","","1","zhangsan") INSERT INTO TABLE dwd.student partition(dt='2020-04-06') VALUES(2,"heaton","2020-04-06","","","1","lisi")
4.4 查询数据
SELECT * FROM dwd.student SELECT * FROM dwd.student WHERE dt="2020-04-05" SELECT * FROM dwd.student WHERE dt="2020-04-06"
4.4.1 分区解释
- 如上图，2个不一样的分区对应的都是HDFS上的独立文件夹，该文件夹下是该分区全部的数据文件。Hive中的分区就是分目录，把一个大的数据集根据业务须要分割成小的数据集。在查询时经过WHERE字句中的表达式查询指定的分区（如上面的WHERE dt="2020-04-05"），这样的查询效率会提升不少。
- 多级分区，就是继续分文件夹，在PARTITIONED BY 中用“,”号隔开分区字段便可，不建议超过2级分区。
4.5 本地load到hive
- 根据上面建表语句创建student1表
- 将student表2020-04-05分区中的数据加载到student1表2020-04-05分区中
LOAD DATA INPATH '/warehouse/dwd/test/student/dt=2020-04-05/000000_0' INTO TABLE dwd.student1 partition(dt='2020-04-05')
4.6 清除表数据
- 注意：Truncate只能删除内部表，不能删除外部表数据
- 注意：hive不支持delete，update(须要经过配置文件修改支持)
- Truncate不通过事务，delete通过事务
TRUNCATE TABLE dwd.student1
4.7 将查询结果插入到表中
- INSERT INTO追加到表中
insert into table dwd.student1 partition(dt='2020-04-05') select id,createdby,createdtime,updatedby,updatedtime,version,name from dwd.student where dt="2020-04-06"
因为student1表2020-04-05分区中已经有一条张三数据，这时插入李四数据，查询结果为2条数据
- INSERT OVERWRITE复写表数据
insert overwrite table dwd.student1 partition(dt='2020-04-05') select id,createdby,createdtime,updatedby,updatedtime,version,name from dwd.student where dt="2020-04-06"
由上面的例子使student1表2020-04-05分区中有2条数据，这时候在插入一条，发现只有一条，由于数据被复写。
4.8 经过临时表插入数据
- with 临时表名 as 查询语句，以下例子为查询两张表数据，字段缺失能够补"0"或者""，插入结果表中
with s1 as ( select id,createdby,createdtime,version,name from dwd.student where dt="2020-04-05" ), s2 as ( select id,updatedby,updatedtime,version,name from dwd.student where dt="2020-04-06" ) insert overwrite table dwd.student1 partition(dt='2020-04-06') select s1.id as id, s1.createdby as createdby, s1.createdtime as createdtime, "" as updatedby, "0" as updatedtime, s1.version as version, s1.name as name from s1 union all select s2.id as id, "" as createdby, "0" as createdtime, s2.updatedby as updatedby, s2.updatedtime as updatedtime, s2.version as version, s2.name as name from s2
4.9 Hive经常使用交互命令
-
hive -e “select * from xx”：hive命令行SQL语句
-
hive -f xx.hql：hive执行sql文件
4.10 分桶及抽样查询
- 分区针对的是数据的存储路径，分桶针对的是数据文件，分桶是将数据集分解成更容易管理的若干部分的一个技术。
- 建立表时使用
CLUSTERED BY(字段名) into 分桶数 buckets指定分桶条件。 - load命令导入分桶表，数据不会分桶。
- 使用分桶功能须要设置hive属性：
set hive.enforce.bucketing=true; set mapreduce.job.reduces=-1; - 对于很是大的数据集，有时用户须要使用的是一个具备表明性的查询结果，而不是所有结果，这时可使用分桶来进行抽样。抽样语句：TABLESAMPLE(BUCKET x OUT OF y ON 分桶字段)
y必须是table总bucket数的倍数或者因子，根据Y值决定抽样的比例，如：table共4个桶，当y=2时，抽取4/2=2个桶数据，等y=8时，抽取4/8=1/2的bucket数据。
x是从哪一个桶开始抽，而后依次抽取x+y的桶数据，如：table共4个桶，当y=2，x=1时，抽取4/2=2个桶数据，桶数为1号,1+2=3号。
- 案例
#建表sql
CREATE EXTERNAL TABLE `dwd.student_buck`(
`ID` bigint COMMENT '',
`name` string COMMENT '姓名'
) COMMENT '学生表'
CLUSTERED BY(ID) into 4 buckets
row format delimited fields terminated by '\t'
stored as parquet
location '/warehouse/dwd/test/student_buck/'
tblproperties ("parquet.compression"="snappy")
#插入数据
INSERT INTO TABLE dwd.student_buck VALUES(1,"zhangsan"),(2,"lisi") ,(3,"wangwu") ,(4,"zhaoliu") ,(5,"haqi") ,(6,"xiba") ,(7,"heijiu") ,(8,"washi")
#抽样查询
SELECT * from dwd.student_buck TABLESAMPLE(BUCKET 1 OUT OF 4 ON id)
5 Hive 查询操做特殊解释
https://cwiki.apache.org/confluence/display/Hive/LanguageManual+Select
5.1 join解释
- Join语句只支持等值连接，不支持非等值连接。
- 除左、右、内连接外还支持全链接full join，可是效率较差，通常使用union all
5.2 排序分组操做
Order By 全局排序（全局一个Reducer）
Group By 分组（会根据跟的字段，发到不一样的Reducer中）
Distribute By 相似MR中的partition进行分区，需结合Sort By使用，并且要写在前面，如：根据日期分区，在根据年龄排序
#多reduce才有效果 select * from student distribute by createtime sort by age descSort By每一个Reducer内部排序，对全局结果来讲不是排序，结合Distribute By使用。(多Reducer区内排序)
Cluster By 当分区字段和区内排序字段相同，也就是distribute by和sort by须要字段相同可使用其代替，可是只能升序排列。
5.3 空字段赋值函数
NVL(string，替换值)，若是string为NULL，则返回替换值，不然返回string值
5.4 时间转换
# 1 格式化时间-> 2020-04-05 00:00:00
SELECT date_format("2020-04-05","yyyy-MM-dd HH:mm:ss")
# 2 时间天数相加-> 2020-04-05 ->2020-04-01
SELECT date_add("2020-04-05",4)
SELECT date_add("2020-04-05",-4)
# 3 时间天数相减->2020-04-01(通常直接用date_add了，这个不怎么用)
SELECT date_sub("2020-04-05",4)
# 4 两个时间相减-> 4
SELECT datediff("2020-04-09","2020-04-05")
# 5 时间转时间戳-> 1586016000
SELECT unix_timestamp("2020-04-05","yyyy-MM-dd")
# 6 时间戳转时间-> 2020-04-05
SELECT from_unixtime(cast("1586016000" as BIGINT),"yyyy-MM-dd")
# 7 将日期转为星期-> 1 (星期一)
SELECT pmod(datediff("2020-04-06","1920-01-01")-3,7)
5.5 CASE WHEN 和 IF
| 财务部 | 男 |
|---|---|
| 财务部 | 男 |
| 财务部 | 女 |
| 科技部 | 女 |
| 人事部 | 女 |
| 人事部 | 男 |
如上图假设表 emp 中有6我的，求每一个部门下面的男女个数。
#使用CASE WHEN select department, sum(case sex when '男' then 1 else 0 end) man_count, sum(case sex when '女' then 1 else 0 end) woman_count, from emp group by department #还可使用IF select department, sum(if(sex='男',1,0)) man_count, sum(if(sex='女',1,0)) woman_count, from emp group by department
5.6 聚合拼接
# 1 concat拼接-> 2020-04-05
SELECT concat("2020","-","04","-","05")
# 2 concat_ws拼接-> 2020-04-05 注意 concat_ws能够传collect_set，须要字段为string
SELECT concat_ws("-","2020","04","05")
# 3 汇总成Array类型字段-> [8,4,5,1,6,2,7,3]
SELECT collect_set(id) from dwd.student_buck
5.7 炸裂
EXPLODE(字段名)：将一列复杂的array或者map结构拆分红多行
炸裂函数必须配合侧写视图函数：LATERAL VIEW udtf(expression) 侧写视图别名 AS 侧写结果列别名
- 例子
# 建表
CREATE EXTERNAL TABLE `dwd.hobby`(
`id` bigint COMMENT '',
`name` string COMMENT '姓名',
`hobby_name` array<string> COMMENT '爱好名字'
) COMMENT '爱好表'
PARTITIONED BY (
`dt` String COMMENT 'partition'
)
row format delimited fields terminated by '\t'
collection items terminated by ','
stored as parquet
location '/warehouse/dwd/test/hobby/'
tblproperties ("parquet.compression"="snappy")
# 插入3条数据
INSERT INTO TABLE dwd.hobby partition(dt='2020-04-05')
SELECT 1,"zhangsan",array("篮球","足球","羽毛球","恶做剧")
INSERT INTO TABLE dwd.hobby partition(dt='2020-04-05')
SELECT 2,"lisi",array("足球","恶做剧")
INSERT INTO TABLE dwd.hobby partition(dt='2020-04-05')
SELECT 3,"wangwu",array("羽毛球","恶做剧")
# 使用侧写视图将炸裂结果做为临时视图，聚合须要的结果
select
name,hobby_name_col
from
dwd.hobby
lateral view explode(hobby_name) hobby_tmp as hobby_name_col
5.8 窗口函数
主要解决1行和n行数据没法聚合在一块儿展现的问题。
- OVER（）：指定分析函数工做的数据窗口大小，这个数据窗口大小会随着行的变化而变化
- CURRENT ROW：当前行
- n PRECEDING：往前n行数据
- n FOLLOWING：日后n行数据
- UNBOUNDED：起点，UNBOUNDED PRECEDING表示从前面的起点，UNBOUNDED FOLLOWING表示到后面的终点。
- Partition By：分区
- Order By：排序
- Distribute By：区内分组
- Sort By：区内排序
- Group By：不可以使用
- LAG(col，n，默认值)：往前第n行数据
- LEAD(col，n，默认值)：日后第n行数据
- NTILE(n)：相似于分桶，把数据有序分到n个桶里，序号从1开始。
- RANK()：排序相同时会重复，总数不会变
- DENSE_RANK()：排序相同时会重复，总数会减少
- ROW_NUMBER()：会根据顺序计算
5.8.0 案例数据准备
#建表
CREATE EXTERNAL TABLE `dwd.order`(
`name` string COMMENT '姓名',
`order_date` string COMMENT '购买日期',
`price` bigint COMMENT '消费金额'
) COMMENT '订单表'
PARTITIONED BY (
`dt` String COMMENT 'partition'
)
row format delimited fields terminated by '\t'
stored as parquet
location '/warehouse/dwd/test/order/'
tblproperties ("parquet.compression"="snappy")
#插入数据
INSERT INTO TABLE `dwd.order` partition(dt='2020-04-05') VALUES("zhangsan","2020-01-01",15),("lisi","2020-01-02",22),("zhangsan","2020-04-01",34),("lisi","2020-04-01",15),("zhangsan","2020-04-04",42),("zhangsan","2020-03-01",24),("lisi","2020-02-01",65),("wangwu","2020-04-01",33),("zhangsan","2020-05-01",43),("zhangsan","2020-07-01",12),("wangwu","2020-02-05",32),("zhangsan","2020-03-06",22),("lisi","2020-04-07",14)
5.8.1 OVER()无参数
- 查询在2020年4月购买过的顾客名字及总人数
SELECT name,count(*) OVER() FROM dwd.`order` WHERE order_date BETWEEN "2020-04-01" AND "2020-04-30" GROUP BY name
5.8.2 OVER()无参数
- 查询顾客的购买明细及购买总额
SELECT *,sum(price) OVER() FROM dwd.`order`
5.8.3 OVER()排序参数
- 查询顾客的购买明细及购买总额并按月累加展现
SELECT *,sum(price) OVER(ORDER BY order_date) FROM dwd.`order` SELECT *,sum(price) OVER(ORDER BY order_date DESC) FROM dwd.`order`
over函数传参，仍是给全部结果集进行开窗，可是根据参数限定窗口大小，上面sql的意思为：
1号zhangsan数据窗口内只含有 1号张三
2号lisi数据窗口内含有 1号张三，2号李四
3号lisi数据窗口内含有 1号张三，2号李四，3号李四
依次类推
5.8.4 OVER()分组参数
- 查询顾客的购买明细及每一个顾客的购买总额
SELECT *,sum(price) OVER(distribute by name) FROM dwd.`order`
5.8.5 OVER()分组排序参数
- 查询顾客的购买明细及每一个顾客的购买总额并按月累加展现
SELECT *,sum(price) OVER(distribute by name sort by order_date) FROM dwd.`order`
5.8.6 CURRENT ROW->UNBOUNDED->PRECEDING->FOLLOWING窗口大小指定
- 查询顾客的购买明细及每一个顾客的购买总额并直接累加展现
SELECT *,sum(price) OVER(distribute by name rows between UNBOUNDED PRECEDING and CURRENT ROW) FROM dwd.`order`
5.8.7 LAG->LEAD 窗口值指定
- 查询顾客的购买明细而且追加客户上次购买日期
SELECT *,lag(order_date,1,"1970-01-01") OVER(distribute by name sort by order_date) FROM dwd.`order`
5.8.8 NTILE 分桶
SELECT *,ntile(5) OVER() FROM dwd.`order`
- 查询当前20%的订单信息
SELECT * FROM (SELECT *,ntile(5) OVER(ORDER BY order_date) ntile_5 FROM dwd.`order`) t1 WHERE t1.ntile_5=1
5.8.9 ROW_NUMBER 排名
SELECT *,row_number() OVER(order by order_date) FROM dwd.`order`
5.8.10 RANK 排名
SELECT *,rank() OVER(order by order_date) FROM dwd.`order`
5.8.11 DENSE_RANK 排名
SELECT *,dense_rank() OVER(order by order_date) FROM dwd.`order`
6 自定义函数
- 用户自定义函数类别能够分为三种：
- UDF(一行进一行出)，如：concat，split
- UDAF(多行进一行出)，如：count，sum，max
- UDTF(一行进多行出)，如：explode
https://cwiki.apache.org/confluence/display/Hive/HivePlugins
- 添加jar包及函数的方式请参考6.1案例
6.1 自建UDF
必须有返回值，能够返回null，可是类型不能是void。
须要继承UDF类，而且方法名为evaluate
- maven-pom.xml
<dependency>
<groupId>org.apache.hive</groupId>
<artifactId>hive-exec</artifactId>
<version>2.1.1</version>
</dependency>
- java代码
import org.apache.hadoop.hive.ql.exec.UDF;
//模拟concat
public class MyUDF extends UDF {
public String evaluate(String... args) {
StringBuilder s = new StringBuilder();
for (String arg : args) {
s.append(arg);
}
return s.toString();
}
}
- 打包上传服务器，进入hive命令行
# 1 添加jar包，注意服务器本地路径(hive客户端关闭则消失，须要从新添加，若是不想从新添加，能够直接使用4将jar包放入hive/lib下) add jar /root/test/function-1.0-SNAPSHOT.jar # 2 添加函数，注意hive中的函数别名，还有jar包全类名，以下为永久建立和临时建立temporary(hive客户端关闭则消失) create function myconcat as "com.hive.function.udf.MyUDF" create temporary function myconcat as "com.hive.function.udf.MyUDF" # 3 加载jar包的第二种方式，上传jar包至hdfs集群 # create temporary function myconcat as "com.hive.function.udf.MyUDF" using jar 'hdfs:///hive_jar/function-1.0-SNAPSHOT.jar'; # 4 加载jar包的第三种方式，直接放在hive的lib目录下，启动hive，使用2添加函数便可。下面是cdh环境的jars包路径，配置软链接到hive/lib下 # ln -s /opt/cloudera/parcels/CDH-6.2.0-1.cdh6.2.0.p0.967373/jars/function-1.0-SNAPSHOT.jar /opt/cloudera/parcels/CDH-6.2.0-1.cdh6.2.0.p0.967373/lib/hive/lib # 5 删除函数 # drop function myconcat
- 能够在hive中使用自建函数
SELECT myconcat("a","-","b","-","c")
6.2 自建UDAF
用户自定义UDAF必须继承UDAF，必须提供一个实现了UDAFEvaluator接口的内部类
- java代码
import org.apache.hadoop.hive.ql.exec.UDAF;
import org.apache.hadoop.hive.ql.exec.UDAFEvaluator;
//模拟avg
public class MyUDAF extends UDAF {
public static class AvgState {
private long mCount;
private double mSum;
}
public static class AvgEvaluator implements UDAFEvaluator {
AvgState state;
public AvgEvaluator() {
super();
state = new AvgState();
init();
}
/**
* init函数相似于构造函数，用于UDAF的初始化
*/
public void init() {
state.mSum = 0;
state.mCount = 0;
}
/**
* iterate接收传入的参数，并进行内部的轮转。其返回类型为boolean * * @param o * @return
*/
public boolean iterate(Double o) {
if (o != null) {
state.mSum += o;
state.mCount++;
}
return true;
}
/**
* terminatePartial无参数，其为iterate函数遍历结束后，返回轮转数据， * terminatePartial相似于hadoop的Combiner * * @return
*/
public AvgState terminatePartial() {
// combiner
return state.mCount == 0 ? null : state;
}
/**
* merge接收terminatePartial的返回结果，进行数据merge操做，其返回类型为boolean * * @param o * @return
*/
public boolean merge(AvgState avgState) {
if (avgState != null) {
state.mCount += avgState.mCount;
state.mSum += avgState.mSum;
}
return true;
}
/**
* terminate返回最终的汇集函数结果 * * @return
*/
public Double terminate() {
return state.mCount == 0 ? null : Double.valueOf(state.mSum / state.mCount);
}
}
}
- 根据6.1建立函数进行函数建立，并使用
6.3 自建UDTF
用户自定义UDAF必须继承GenericUDTF，重写initialize()，process()，close()方法。
- java代码
import org.apache.hadoop.hive.ql.exec.UDFArgumentException;
import org.apache.hadoop.hive.ql.metadata.HiveException;
import org.apache.hadoop.hive.ql.udf.generic.GenericUDTF;
import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector;
import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspectorFactory;
import org.apache.hadoop.hive.serde2.objectinspector.StructObjectInspector;
import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorFactory;
import java.util.ArrayList;
import java.util.List;
//模拟EXPLODE和split
public class MyUDTF extends GenericUDTF {
private List<String> dataList = new ArrayList<>();
//初始化方法，返回对象结构校验器
@Override
public StructObjectInspector initialize(StructObjectInspector argOIs) throws UDFArgumentException {
//列名，会被用户传递的覆盖
List<String> fieldNames = new ArrayList<>();
fieldNames.add("word1");
//返回列以什么格式输出，这里是string，添加几个就是几个列，和上面的名字个数对应个数。
List<ObjectInspector> fieldOIs = new ArrayList<>();
fieldOIs.add(PrimitiveObjectInspectorFactory.javaStringObjectInspector);
return ObjectInspectorFactory.getStandardStructObjectInspector(fieldNames, fieldOIs);
}
@Override
public void process(Object[] objects) throws HiveException {
//获取数据
String data = objects[0].toString();
//获取分隔符
String splitKey = objects[1].toString();
//切分数据
String[] words = data.split(splitKey);
//遍历写出
for (String word : words) {
//将数据放入集合
dataList.clear();
dataList.add(word);
//写出数据到缓冲区
forward(dataList);
}
}
@Override
public void close() throws HiveException {
//没有流操做
}
}
- 根据6.1建立函数进行函数建立，并使用
7 优化
7.1 调整hive执行引擎
hive.execution.engine配置为spark
7.2 Fetch抓取
Fetch抓取修改成more，可使全局查找，字段查找，limit查找等都不走计算引擎，而是直接读取表对应储存目录下的文件，大大普通查询速度。
hive.fetch.task.conversion配置为more
7.3 开启本地模式
hive能够经过本地模式在单台机器上处理全部的任务，对于小的数据集，执行时间能够明显被缩短。
hive-site.xml调整下面3个参数，开启本地模式，文件不超过50M，个数不超过10个。
hive.exec.mode.local.auto=true
hive.exec.mode.local.auto.inputbytes.max=50000000 （50M左右，默认128M->134217728，机器资源足建议使用默认值）
hive.exec.mode.local.auto.input.files.max=10 (模式4个)
<property><name>hive.exec.mode.local.auto</name><value>true</value></property> <property><name>hive.exec.mode.local.auto.inputbytes.max</name><value>50000000</value></property> <property><name>hive.exec.mode.local.auto.input.files.max</name><value>10</value></property>
7.4 join优化
在join问题上，让小表放在左边 去左连接（left join）大表，这样能够有效的减小内存溢出错误发生的概率。
hive.auto.convert.join开启。（默认开启）
hive.mapjoin.smalltable.filesize(默认25000000->接近24M，若是机器内存足能够适当调大，需在hive-site.xml中设置，如7.3)
大表和大表join，空key会打到同一个reduce上，形成数据倾斜，任务缓慢，内存泄漏。(reduce任务某个很是慢，其余很快，及发生数据倾斜)
- 空key过滤：使用子查询过滤掉空key，能够有效的提高查询速率。
- 空key转换：附随机值，使其能够随机均匀的分布在不一样的reduce上，使用case when then或if判断null值，赋予rand()函数。
7.5 Group By优化
默认状况下map阶段同一个key发送给一个reduce，当一个key数据过大时就发生数据倾斜。
那么把某些聚合操做提到Map端进行部分聚合，最后在reduce端得出最终结果，也能够有效的提高执行效率。
hive.map.aggr开启。（默认开启）
hive.groupby.mapaggr.checkinterval=100000(默认100000条，在map端进行聚合操做的条目数目，需在hive-site.xml中设置，如7.3)
hive.groupby.skewindata=true（默认false，有数据倾斜时进行负载均衡，需在hive-site.xml中设置，如7.3）
hive.groupby.skewindata当选项设置为true时，生成的查询计划会有两个MR Job，第一个MR Job会将key加随机数均匀的分布到Reduce中，作部分聚合操做（预处理），第二个MR Job在根据预处理结果还原原始key，按照Group By Key分布到Reduce中进行聚合运算，完成最终操做。
7.6 Count(Distinct)去重统计
数据量小的时候不要紧，大数据量下，因为Count Distinct操做须要用一个Reduce任务来完成，这一个Reduce须要处理的数据量太大，会致使Job缓慢，可使用子查询Group By再Count的方式替换。
7.7 行列过滤
列处理：不使用Select *，使用什么字段就写什么字段，就算是全部字段，也要一一列出，养成好习惯。
行处理：在join操做中，不要直接关联表后使用where条件，这样会使全表关联后在过滤，使用子查询过滤后在join来替换，使查询效率提升。以下
#错误写法 select id from student s left join class c on s.cid=c.id where c.id<=10 #正确写法 select id from student s left join (select id from class where id<=10 ) c on s.cid=c.id
7.8 动态分区
当数据会根据状况变化的时候，先有数据，再想分区的状况。
设计表时尽可能避免动态分区，速度比静态分区（也就是直接指定分区慢不少）。
-
开启动态分区参数
-
必要参数
- hive.exec.dynamic.partition=true; 默认：true。
- hive.exec.dynamic.partition.mode=nostrict; 默认：strict至少有一个分区列是静态分区，nostrict全部分区均可以是动态分区。
-
相关参数
- hive.exec.max.dynamic.partitions.pernode=100; 默认100，每个执行mr节点上，容许建立的动态分区的最大数量
- hive.exec.max.dynamic.partitions=1000; 默认1000，全部执行mr节点上，容许建立的全部动态分区的最大数量
- hive.exec.max.created.files=100000; 默认100000，全部的mr job容许建立的文件的最大数量
- hive.error.on.empty.partition=false; 默认false，当有空分区生成时，是否抛出异常。
-
建表方式同静态分区，插入方式要注意，查询结果最后一个字段即为分区字段（无论名字是否同样，会将最后一个字段的值，直接拿来分区）
#错误写法：会将name值直接插入dt分区字段。 insert into table dwd.student1 partition(dt) select id,createdby,createdtime,updatedby,updatedtime,version,name from dwd.student #正确写法 insert into table dwd.student1 partition(dt) select id,createdby,createdtime,updatedby,updatedtime,version,name,dt from dwd.student
7.9 开启并行计算
hive.exec.parallel=true；默认false。需在hive-site.xml中设置，如7.3
hive.exec.parallel.thread.number=16；默认8，同一个sql容许的最大并行度，针对集群资源适当增长。需在hive-site.xml中设置，如7.3
7.10 多用Explain
在执行的查询sql前加上Explain指令，查询分析sql执行过程。
相关文章
- 1. 大数据-Hive
- 2. 大数据开发技术hive篇
- 3. 大数据学习之 Hive篇
- 4. 大数据010——Hive
- 5. 【大数据】Hive SQL
- 6. 大数据中hive
- 7. 大数据-Hive（二）
- 8. 大数据之HIVE
- 9. 大数据之Hive
- 10. 大数据(九) - Hive
- 更多相关文章...
- • Docker 命令大全 - Docker教程
- • PHP PDO 大对象 (LOBs) - PHP参考手册
- • Flink 数据传输及反压详解
- • TiDB 在摩拜单车在线数据业务的应用和实践
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
欢迎关注本站公众号,获取更多信息
相关文章
- 1. 大数据-Hive
- 2. 大数据开发技术hive篇
- 3. 大数据学习之 Hive篇
- 4. 大数据010——Hive
- 5. 【大数据】Hive SQL
- 6. 大数据中hive
- 7. 大数据-Hive（二）
- 8. 大数据之HIVE
- 9. 大数据之Hive
- 10. 大数据(九) - Hive