Hive 调优
Hive性能瓶颈
磁盘健康、网络带宽、机器性能、数据倾斜、查找硬件的失效、CPU竞争、内存交换等
网络带宽、机器性能、数据倾斜，前两个很好解决，掏钱加带宽加机器就行了。但数据倾斜需要在计算逻辑上做针对性的优化。
Hive优化层面
查看执行计划
explain extended hql；可以看到扫描数据的hdfs路径
Hive ql层面优化
一、hive表优化
分区（不同文件夹）：
分区是以字段的形式在表结构中存在，通过describe table命令可以查看到字段存在， 但是该字段不存放实际的数据内容，仅仅是分区的表示（伪列）
静态分区（这个不管，管动态分区就可以了）：
create table if not exists tablename(id int,name string,tel string)
partitioned by(dt string)
row format delimited
fields terminated by '\t'
stored as textfile;
使用动态分区前，需要配置以下参数：
hive.exec.dynamic.partition：在DML/DDL中是否支持动态分区，配置为true
hive.exec.dynamic.partition.mode：默认strict，在strict模式下，动态分区的使用必须在一个静态分区确认的情况下，其他分区可以是动态，可以考虑配置成nostrict。
设置动态分区开启：
set hive.exec.dynamic.partition=true;
set hive.exec.dynamic.partition.mode=nonstrict;
默认值：strict
描述：strict是避免全分区字段是动态的，必须有至少一个分区字段是指定有值的， 避免产生大量分区
分桶（不同文件）：
使用分桶前，需要配置以下参数：hive.enforce.bucketing：数据分桶是否被强制执行，默认false，如果开启，则写入table数据时会启动分桶。
hive.enforce.sorting：开启强制排序时，插数据到表中会进行强制排序，默认false；
对于每一个表（table）或者分区， Hive可以进一步组织成桶，也就是说桶是更为细粒度的数据范围划分。Hive也是 针对某一列进行桶的组织。Hive采用对列值哈希，然后除以桶的个数求余的方式决定该条记录存放在哪个桶当中。
设置：
set hive.enforce.bucketing=true;
set hive.enforce.sorting=true;开启强制排序，插数据到表中会进行强制排序，默认false；
二、Hive SQL优化
groupby数据倾斜优化
hive.groupby.skewindata=true;（多起一个job）1.join优化
（1）数据倾斜
hive.optimize.skewjoin：是否优化数据倾斜的 Join，对于倾斜的 Join 会开启新的 Map/Reduce Job 处理，默认值为false。
hive.skewjoin.key 倾斜键数目阈值，超过此值则判定为一个倾斜的 Join 查询。默认值为100000
设置：
hive.optimize.skewjoin=true; // 如果是join 过程出现倾斜，应该设置为 trueset hive.skewjoin.key=100000;
这个是join 的键对应的记录条数超过这个值则会进行优化， 简单说就是一个job 变为两个 job 执行 HQL
（2）Map join(map端执行join）
hive.mapjoin.smalltable.filesize：输入表文件的mapjoin阈值，如果输入文件的大小小于该值，则试图将普通join转化为mapjoin，默认25MB；
上面的两个参数是自动启用mapjoin，也可以手动启动mapjoin。
启动方式一：(自动判断）
set.hive.auto.convert.join=true;
hive.mapjoin.smalltable.filesize 默认值是25mb
小表小于25mb自动启动mapjoin
启动方式二：(手动）
select /*+mapjoin(A)*/ f.a,f.b from A t join B f on (f.a=t.a)
mapjoin支持不等值条件
reducejoin不支持在ON条件中不等值判断
（3）Bucket join(数据访问可以精确到桶级别）
使用条件：1.两个表以相同方式划分桶
2.两个表的桶个数是倍数关系
例子：
create table order(cid int,price float) clustered by(cid) into 32 buckets;
create table customer(id int,first string) clustered by(id) into 32/64 buckets;
select price from order t join customer s on t.cid=s.id;
（4）where条件优化
优化前（关系数据库不用考虑会自动优化）：
select m.cid,u.id from order m join customer u on m.cid =u.id where m.dt='2013-12-12';
优化后(where条件在map端执行而不是在reduce端执行）：
select m.cid,u.id from （select * from order where dt='2013-12-12'） m join customer u on m.cid =u.id;
优化后会在map端通过where语句过滤掉一些数据，提高了效率
（5）group by 优化
hive.groupby.mapaggr.checkinterval：map端做聚合时，group by 的key所允许的数据行数，超过该值则进行分拆，默认是100000；
hive.groupby.skewindata=true; //如果group by过程出现倾斜应该设置为true
set hive.groupby.mapaggr.checkinterval=100000; //这个是group的键对应的记录条数超过这个值则会进行优化
也是一个job变为两个job
（6）count distinct优化
优化前（只有一个reduce，先去重再count负担比较大）：
select count(distinct id) from tablename;
在数据量大时，可以使用如下优化：
select count(1) from (select distinct id from tablename) tmp;
select count(1) from (select id from tablename group by id) tmp;
优化前查询只会启动一个job来完成，完成数据去重和计数时都只在一个reduce端（即便通过mapred.reduce.tasks设置reduce的数目为多个，但实际执行时仍然只有一个）进行，优化后会启动两个job来完成，同时可以通过mapred.reduce.tasks设定更多的reduce数目，所以适合在数据量很大的情况下使用，因为初始化一个job时花费的时间也会很长。
set mapred.reduce.tasks=3;
看一个更复杂的例子：
优化前：
select a,sum(b),count(distinct c),count(distinct d) from test group by a;
优化后：
select a,sum(b) as b,count(c) as c,count(d) as d from
（
select a, 0 as b,c,null as d from test group by a,c
union all
select a,0 as b, null as c,d from test group by a,d
union all
select a, b,null as c ,null as d from test) tmp group by a;
Hive架构层面优化
一、Hive job优化
1. 并行化执行
hive会将一个查询转化为一个或多个阶段，包括：MapReduce阶段、抽样阶段、合并阶段、limit阶段等。默认情况下，一次只执行一个阶段，顺序进行的。 不过，如果某些阶段不是互相依赖，是可以并行执行的。
一个HQL拆分成多个job，job之间无依赖关系也没有相互影响可以并行执行。
set hive.exec.parallel=true,可以开启并发执行。
set hive.exec.parallel.thread.number=16; //同一个sql允许最大并行度，默认为8。
会比较耗系统资源。
set hive.exec.parallel.thread.number=8;
就是控制对于同一个sql来说同时可以运行的job的最大值，该参数默认为8.此时最大可以同时运行8个job
2. 本地化执行（在存放数据的节点上执行）
使用本地化执行前，需要配置以下参数：
hive.exec.mode.local.auto：是否由hive决定自动在local模式下运行，默认是false。
设置：set hive.exec.mode.local.auto=true;
配置了上面参数后，该job还必须满足以下条件，才能真正的使用本地模式：
本地化执行必须满足条件：
（1）job的输入数据大小必须小于参数
hive.exec.mode.local.auto.inputbytes.max(默认128MB）
（2）job的map数必须小于参数：
hive.exec.mode.local.auto.tasks.max(默认为4）太多没有足够的slots
（3）job的reduce数必须为0或1
3. job合并输入小文件
set mapred.max.split.size=256000000; #每个Map最大输入大小
set mapred.min.split.size.per.node=100000000; #一个节点上split的至少的大小
set mapred.min.split.size.per.rack=100000000; #一个交换机下split的至少的大小
set hive.input.format=org.apache.hadoop.hive.ql.io.CombineHiveInputFormat; #执行Map前进行小文件合并
set hive.input.format=org.apache.hadoop.hive.ql.io.CombineHiveInputFormat
多个split合成一个,合并split数由mapred.max.split.size限制的大小决定
4. job合并输出小文件（为后续job优化做准备）
hive.merge.mapfiles：在只有map的作业结束时合并小文件，默认开启true；
hive.merge.mapredfiles：在一个map/reduce作业结束后合并小文件，默认不开启false；
hive.merge.size.per.task： 合并后每个文件的大小，默认256000000
set hive.merge.smallfiles.avgsize=256000000;当输出文件平均大小小于该值，启动新job合并文件
set hive.merge.size.per.task=64000000;合并之后的每个文件大小
5. JVM重利用
Hadoop中有个参数是mapred.job.reuse.jvm.num.tasks(hadoop2 为：mapreduce.job.jvm.numtasks)，默认是1，表示一个JVM上最多可以顺序执行的task数目（属于同一个Job）是1。也就是说一个task启一个JVM。
适当地增大该值对于有较多task的job是分厂有意义的，但是也有个缺点就是：开启JVM重用将会一直占用使用到的task插槽，以便进行重用，直到任务完成后才能释放。如果某个“不平衡“的job中有几个reduce task 执行的时间要比其他reduce task消耗的时间多得多的话，那么保留的插槽就会一直空闲着却无法被其他的job使用，直到所有的task都结束了才会释放。
set mapred.job.reuse.jvm.num.tasks=20;
每个jvm运行多少个task；
JVM重利用可以使job长时间保留slot，直到作业结束。
6. 压缩数据（多个job）
（1）中间压缩处理hive查询的多个job之间的数据，对于中间压缩，最好选择一个节省cpu耗时的压缩方式
hive.exec.compress.intermediate：决定查询的中间 map/reduce job （中间 stage）的输出是否为压缩格式。
hive.intermediate.compression.codec：中间 map/reduce job 的压缩编解码器的类名（一个压缩编解码器可能包含多种压缩类型），该值可能在程序中被自动设置。
hive.intermediate.compression.type：中间 map/reduce job 的压缩类型，如 "BLOCK""RECORD"。
设置：
set hive.exec.compress.intermediate=true;set hive.intermediate.compression.codec=org.apache.hadoop.io.compress.SnappyCodec;
set hive.intermediate.compression.type=BLOCK; 按块压缩，而不是记录
（2）最终输出压缩（选择压缩效果好的，减少储存空间）
hive.exec.compress.output：决定查询中最后一个 map/reduce job 的输出是否为压缩格式。
mapred.output.compression.codec：最后结果的压缩编解码器的类名
mapred.output.compression.type：最后结果的压缩类型
设置：
set hive.exec.compress.output=true;set mapred.output.compression.codec=org.apache.hadoop.io.compress.GzipCodec;
set mapred.output.compression.type=BLOCK;按块压缩，而不是记录
底层MapReduce优化
一、Hive Map优化
1. set mapred.map.tasks=10 无效
（1）默认map个数
default_num=total_size/block_size;
(2)期望大小(手动设置的个数）
goal_num =mapred.map.tasks;
（3）设置处理的文件大小(根据文件分片大小计算的map个数）
split_size=max(block_size,mapred.min.split.size);
split_num=total_size/split_size;
（4）最终计算的map个数（实际map个数）
compute_map_num=min(split_num,max(default_num,goal_num))
总结：
（1）如果想增加map个数，则设置mapred.map.tasks为一个较大的值；
（2）如果想减小map个数，则设置mapred.min.split.size为一个较大的值。
2.map端聚合
set hive.map.aggr=true;相当于map端执行combiner
3.推测执行（默认为true）
mapred.map.tasks.speculative.execution
二、Hive Shuffle优化
Map 端
io.sort.mb
io.sort.spill.percent
min.num.spill.for.combine
io.sort.factor
io.sort.record.percent
reduce端
mapred.reduce.parallel.copies
mapred.reduce.copy.backoff
io.sort.factor
mapred.job.shuffle.input.buffer.percent
三、HIve Reduce优化
3、合理设置map参数
4、合理设置reduce参数
1. 推测执行（默认为true）
mapred.reduce.tasks.speculative.execution(hadoop里面的)
hive.mapred.reduce.tasks.speculative.execution（hive里面相同的参数，效果和hadoop里面的一样）
两个随便哪个都行
2.Reduce优化(reduce个数设置）
set mapred.reduce.tasks=10;直接设置
最大值
hive.exec.reducers.max 默认：999
每个reducer计算的文件量大小
hive.exec.reducers.bytes.per.reducer 默认：1G
计算公式：虽然设了这么多，但不一定用到这么多
numRTasks =min[maxReducers,input.size/perReducer]
maxReducers=hive.exec.reducers.max
perReducer=hive.exec.reducers.bytes.per.reducer
四、队列
set mapred.queue.name=queue3;设置队列queue3
set mapred.job.queue.name=queue3;设置使用queue3
set mapred.job.priority=HIGH；
======================================================================================================
表连接优化
1. 将大表放后头
Hive假定查询中最后的一个表是大表。它会将其它表缓存起来，然后扫描最后那个表。
因此通常需要将小表放前面，或者标记哪张表是大表：/*streamtable(table_name) */
2. 使用相同的连接键
当对3个或者更多个表进行join连接时，如果每个on子句都使用相同的连接键的话，那么只会产生一个MapReduce job。
3. 尽量尽早地过滤数据
减少每个阶段的数据量,对于分区表要加分区，同时只选择需要使用到的字段。
4. 尽量原子化操作
尽量避免一个SQL包含复杂逻辑，可以使用中间表来完成复杂的逻辑
注意：
Hive中小表与大表关联(join)的性能分析：
https://blog.csdn.net/WYpersist/article/details/80001475
用insert into替换union all
如果union all的部分个数大于2，或者每个union部分数据量大，应该拆成多个insert into 语句，实际测试过程中，执行时间能提升50%
如：
insert overwite table tablename partition (dt= ....)
select ..... from ( select ... from A
union all
select ... from B union all select ... from C ) R
where ...;
可以改写为：
insert into table tablename partition (dt= ....) select .... from A WHERE ...; insert into table tablename partition (dt= ....) select .... from B WHERE ...; insert into table tablename partition (dt= ....) select .... from C WHERE ...;
order by & sort by
order by : 对查询结果进行全局排序，消耗时间长。需要 set hive.mapred.mode=nostrict
sort by : 局部排序，并非全局有序，提高效率。
transform+python
一种嵌入在hive取数流程中的自定义函数，通过transform语句可以把在hive中不方便实现的功能在python中实现，然后写入hive表中。
语法：
select transform({column names1})
using '**.py'
as {column names2}
from {table name}
如果除python脚本外还有其它依赖资源，可以使用ADD ARVHIVE
limit 语句快速出结果
一般情况下，Limit语句还是需要执行整个查询语句，然后再返回部分结果。
有一个配置属性可以开启，避免这种情况---对数据源进行抽样
hive.limit.optimize.enable=true --- 开启对数据源进行采样的功能
hive.limit.row.max.size --- 设置最小的采样容量
hive.limit.optimize.limit.file --- 设置最大的采样样本数
缺点：有可能部分数据永远不会被处理到
本地化执行
对于小数据集，为查询触发执行任务消耗的时间>实际执行job的时间，因此可以通过本地模式，在单台机器上（或某些时候在单个进程上）处理所有的任务。
set oldjobtracker=${hiveconf:mapred.job.tracker};
set mapred.job.tracker=local;
set marped.tmp.dir=/home/edward/tmp; sql 语句 set mapred.job.tracker=${oldjobtracker};
-- 可以通过设置属性hive.exec.mode.local.auto的值为true，来让hve在适当的时候自动启动这个优化，也可以将这个配置写在$HOME/.hiverc文件中。
-- 当一个job满足如下条件才能真正使用本地模式：
1.job的输入数据大小必须小于参数：hive.exec.mode.local.auto.inputbytes.max(默认128MB)
2.job的map数必须小于参数：hive.exec.mode.local.auto.tasks.max(默认4)
3.job的reduce数必须为0或者1
可用参数hive.mapred.local.mem(默认0)控制child jvm使用的最大内存数。
并行执行
hive会将一个查询转化为一个或多个阶段，包括：MapReduce阶段、抽样阶段、合并阶段、limit阶段等。默认情况下，一次只执行一个阶段。 不过，如果某些阶段不是互相依赖，是可以并行执行的。
set hive.exec.parallel=true,可以开启并发执行。
set hive.exec.parallel.thread.number=16; //同一个sql允许最大并行度，默认为8。
会比较耗系统资源。
调整mapper和reducer的个数
1 Map阶段优化
map个数的主要的决定因素有： input的文件总个数，input的文件大小，集群设置的文件块大小（默认128M，不可自定义）。
举例：
a) 假设input目录下有1个文件a,大小为780M,那么hadoop会将该文件a分隔成7个块（6个128m的块和1个12m的块），从而产生7个map数
b) 假设input目录下有3个文件a,b,c,大小分别为10m，20m，130m，那么hadoop会分隔成4个块（10m,20m,128m,2m）,从而产生4个map数
即，如果文件大于块大小(128m),那么会拆分，如果小于块大小，则把该文件当成一个块。
map执行时间：map任务启动和初始化的时间+逻辑处理的时间。
1）减少map数
若有大量小文件（小于128M），会产生多个map，处理方法是：
set mapred.max.split.size=100000000; set mapred.min.split.size.per.node=100000000; set mapred.min.split.size.per.rack=100000000;
-- 前面三个参数确定合并文件块的大小，大于文件块大小128m的，按照128m来分隔，小于128m,大于100m的，按照100m来分隔，把那些小于100m的（包括小文件和分隔大文件剩下的）进行合并
set hive.input.format=org.apache.hadoop.hive.ql.io.CombineHiveInputFormat; -- 执行前进行小文件合并 2）增加map数
当input的文件都很大，任务逻辑复杂，map执行非常慢的时候，可以考虑增加Map数，来使得每个map处理的数据量减少，从而提高任务的执行效率。
set mapred.reduce.tasks=?
2 Reduce阶段优化
调整方式：
-- set mapred.reduce.tasks=?
-- set hive.exec.reducers.bytes.per.reducer = ?
一般根据输入文件的总大小,用它的estimation函数来自动计算reduce的个数：reduce个数 = InputFileSize / bytes per reducer
严格模式
set hive.marped.mode=strict ------ 防止用户执行那些可能意想不到的不好的影响的查询
-- 分区表，必须选定分区范围
-- 对于使用order by的查询，要求必须使用limit语句。因为order by为了执行排序过程会将所有的结果数据分发到同一个reducer中进行处理。
-- 限制笛卡尔积查询：两张表join时必须有on语句
数据倾斜
表现：任务进度长时间维持在99%（或100%），查看任务监控页面，发现只有少量（1个或几个）reduce子任务未完成。因为其处理的数据量和其他reduce差异过大。
单一reduce的记录数与平均记录数差异过大，通常可能达到3倍甚至更多。 最长时长远大于平均时长。
原因
1)、key分布不均匀
2)、业务数据本身的特性
3)、建表时考虑不周
4)、某些SQL语句本身就有数据倾斜
关键词 |
情形 |
后果 |
join |
其中一个表较小，但是key集中 |
分发到某一个或几个Reduce上的数据远高于平均值 |
join |
大表与大表，但是分桶的判断字段0值或空值过多 |
这些空值都由一个reduce处理，灰常慢 |
group by |
group by 维度过小，某值的数量过多 |
处理某值的reduce灰常耗时 |
count distinct |
某特殊值过多 |
处理此特殊值reduce耗时 |
解决方案：
参数调节
hive.map.aggr=true
队列参考文章：
http://blog.51cto.com/yaoyinjie/872294
参考：
点滴积累博客：
http://blog.51cto.com/tianxingzhe
http://blog.51cto.com/tianxingzhe/1705565
Hive优化总结 :
http://www.aboutyun.com/thread-17649-1-1.html