Hive 调优

Hive 调优

      • 一、SQL语句分析——EXPLAIN
      • 二、Fetch抓取
      • 三、本地模式
      • 四、表的优化
        • 1、小表大表JOIN
        • 2、大表JOIN大表
        • 3、Group by
        • 4、Count(Distinct) 去重统计
        • 5、笛卡尔积
        • 6、行列过滤
        • 7、分区分桶
      • 五、合理设置Map及Reduce数
        • 1、复杂文件增加Map数
        • 2、小文件进行合并
        • 3、合理设置Reduce数
      • 六、并行执行
      • 七、严格模式
      • 八、JVM重用
      • 九、压缩

一、SQL语句分析——EXPLAIN

EXPLAIN不会执行该SQL,会分析出该SQL执行的步骤。

EXPLAIN [EXTENDED | DEPENDENCY | AUTHORIZATION] query 

示例:

hive (default)> explain select deptno, avg(sal) avg_sal from emp group by deptno;
Explain
STAGE DEPENDENCIES:
  Stage-1 is a root stage
  Stage-0 depends on stages: Stage-1

STAGE PLANS:
  Stage: Stage-1 
    Map Reduce
      Map Operator Tree:
          TableScan
            alias: emp
            Statistics: Num rows: 1 Data size: 7020 Basic stats: COMPLETE Column stats: NONE
            Select Operator
              expressions: sal (type: double), deptno (type: int)
              outputColumnNames: sal, deptno
              Statistics: Num rows: 1 Data size: 7020 Basic stats: COMPLETE Column stats: NONE
              Group By Operator
                aggregations: sum(sal), count(sal)
                keys: deptno (type: int)
                mode: hash
                outputColumnNames: _col0, _col1, _col2
                Statistics: Num rows: 1 Data size: 7020 Basic stats: COMPLETE Column stats: NONE
                Reduce Output Operator
                  key expressions: _col0 (type: int)
                  sort order: +
                  Map-reduce partition columns: _col0 (type: int)
                  Statistics: Num rows: 1 Data size: 7020 Basic stats: COMPLETE Column stats: NONE
                  value expressions: _col1 (type: double), _col2 (type: bigint)
      Execution mode: vectorized
      Reduce Operator Tree:
        Group By Operator
          aggregations: sum(VALUE._col0), count(VALUE._col1)
          keys: KEY._col0 (type: int)
          mode: mergepartial
          outputColumnNames: _col0, _col1, _col2
          Statistics: Num rows: 1 Data size: 7020 Basic stats: COMPLETE Column stats: NONE
          Select Operator
            expressions: _col0 (type: int), (_col1 / _col2) (type: double)
            outputColumnNames: _col0, _col1
            Statistics: Num rows: 1 Data size: 7020 Basic stats: COMPLETE Column stats: NONE
            File Output Operator
              compressed: false
              Statistics: Num rows: 1 Data size: 7020 Basic stats: COMPLETE Column stats: NONE
              table:
                  input format: org.apache.hadoop.mapred.SequenceFileInputFormat
                  output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat
                  serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe

  Stage: Stage-0
    Fetch Operator
      limit: -1
      Processor Tree:
        ListSink

二、Fetch抓取

对于某些查询可以不用MapReduce计算。例如:SELECT * FROM employees;在这种情况下,Hive可以简单地读取employee对应的存储目录下的文件,然后输出查询结果到控制台。

默认:set hive.fetch.task.conversion = more;
  • none : disable hive.fetch.task.conversion
  • minimal : SELECT STAR, FILTER on partition columns, LIMIT only
  • more : SELECT, FILTER, LIMIT only (support TABLESAMPLE and virtual columns)

把hive.fetch.task.conversion设置成more,以下都不会执行mapreduce程序。

hive (default)> set hive.fetch.task.conversion=more;
hive (default)> select * from emp;
hive (default)> select ename from emp;
hive (default)> select ename from emp limit 3;

把hive.fetch.task.conversion设置成none,以下查询都会执行mapreduce程序。

hive (default)> set hive.fetch.task.conversion=none;
hive (default)> select * from emp;
hive (default)> select ename from emp;
hive (default)> select ename from emp limit 3;

三、本地模式

有时Hive的输入数据量比较小,此时触发执行任务消耗的时间可能会比实际job的执行时间要多的多。对于这种情况,Hive可以通过本地模式在单台机器上处理所有的任务。对于小数据集,执行时间可以明显被缩短。

用户可以通过设置hive.exec.mode.local.auto的值为true,让Hive在适当的时候自动启动这个优化。

set hive.exec.mode.local.auto=true;  //开启本地mr
//设置local mr的最大输入数据量,当输入数据量小于这个值时采用local  mr的方式,默认为134217728,即128M
set hive.exec.mode.local.auto.inputbytes.max=50000000;
//设置local mr的最大输入文件个数,当输入文件个数小于这个值时采用local mr的方式,默认为4
set hive.exec.mode.local.auto.input.files.max=10;

四、表的优化

1、小表大表JOIN

将key相对分散,并且数据量小的表放在join的左边,这样可以有效减少内存溢出错误发生的几率;再进一步,可以使用map join让小的维度表(1000条以下的记录条数)先进内存,在map端完成join(MapJoin)。

开启MapJoin参数设置
(1)设置自动选择Mapjoin (默认为true)

set hive.auto.convert.join = true; 

(2)大表小表的阈值设置(默认25M以下认为是小表):

set hive.mapjoin.smalltable.filesize = 25000000;

MapJoin的工作机制:小表直接进内存,只对大表进行MAP操作,省去了REDUCE操作。

注意:

  • 小表大表JOIN主要影响的是内连接的情况;
  • 新版的hive已经对小表JOIN大表和大表JOIN小表进行了优化。小表放在左边和右边已经没有明显区别。
  • map:做数据处理,(连表也是一种数据处理
  • reduce:根据业务,对数据进行计算,获得我们想要的结果,比如统计,求和等。
  • MapJoin:利用cachefile接入数据 与map端接入的数据进行逻辑连接,不需要写reduce
  • ReduceJoin:map端只完成文件合并,利用相同的关联条件id作为key输出到reduce端,reduce端根据key聚合达到关联的效果
2、大表JOIN大表

(1)空KEY过滤
有时join超时是因为某些key对应的数据太多,而相同key对应的数据都会发送到相同的reducer上,从而导致内存不够,发生数据倾斜。此时我们应该仔细分析这些异常的key,如果这些key对应的数据是异常数据,那就需要进行过滤。例如key为空时,表示的是异常数据,需要进行剔除:

hive (default)> insert overwrite table jointable 
select n.* from 
(select * from nullidtable where id is not null ) n  
left join bigtable o on n.id = o.id;

(2)空KEY转换
有时虽然某个key为空对应的数据很多,但是相应的数据不是异常数据,必须要包含在join的结果中,此时我们可以表a中key为空的字段赋一个随机的值,使得数据随机均匀地分不到不同的reducer上。例如:

随机分布空null值
1)设置5个reduce个数

set mapreduce.job.reduces = 5;

2)JOIN两张表

insert overwrite table jointable
select n.* from nullidtable n full join bigtable o on 
nvl(n.id,rand()) = o.id;

(3)SMB(Sort Merge Bucket join) 桶JOIN
先将每个表,进行分桶,分桶键相同,桶数相同。两个表分别针对ID(关联字段)进行分桶。
Hive 调优_第1张图片

设置参数:

set hive.optimize.bucketmapjoin = true;
set hive.optimize.bucketmapjoin.sortedmerge = true;
set hive.input.format=org.apache.hadoop.hive.ql.io.BucketizedHiveInputFormat;

注意:
创建分桶表1,桶的个数不要超过可用CPU的核数。

3、Group by

默认情况下,Map阶段同一Key数据分发给一个reduce,当一个key数据过大时就倾斜了。
Hive 调优_第2张图片
并不是所有的聚合操作都需要在Reduce端完成,很多聚合操作都可以先在Map端进行部分聚合,最后在Reduce端得出最终结果。

(1)开启Map端聚合参数设置
1)是否在Map端进行聚合,默认为True

set hive.map.aggr = true

2)在Map端进行聚合操作的条目数目

set hive.groupby.mapaggr.checkinterval = 100000

3)有数据倾斜的时候进行负载均衡(默认是false)

set hive.groupby.skewindata = true

负载均衡:
当选项设定为 true,生成的查询计划会有两个MR Job。第一个MR Job中,Map的输出结果会随机分布到Reduce中,每个Reduce做部分聚合操作,并输出结果,这样处理的结果是相同的Group By Key有可能被分发到不同的Reduce中,从而达到负载均衡的目的;第二个MR Job再根据预处理的数据结果按照Group By Key分布到Reduce中(这个过程可以保证相同的Group By Key被分布到同一个Reduce中),最后完成最终的聚合操作。

先在第一个MR中局部汇总,再在一个MR中整体汇总,启用两个MR,耗时增长,但是,解决了数据倾斜问题。

4、Count(Distinct) 去重统计

数据量小的时候无所谓,数据量大的情况下,由于COUNT DISTINCT操作需要用一个Reduce Task来完成,这一个Reduce需要处理的数据量太大,就会导致整个Job很难完成,一般COUNT DISTINCT使用先GROUP BY再COUNT的方式替换,但是需要注意group by造成的数据倾斜问题.

虽然会多用一个Job来完成,但在数据量大的情况下,这个绝对是值得的。

5、笛卡尔积

尽量避免笛卡尔积,join的时候不加on条件,或者无效的on条件,Hive只能使用1个reducer来完成笛卡尔积。

6、行列过滤

列处理:在SELECT中,只拿需要的列,如果有分区,尽量使用分区过滤,少用SELECT *
行处理:在分区剪裁中,当使用外关联时,如果将副表的过滤条件写在Where后面,那么就会先全表关联,之后再过滤。

通过子查询后,再关联表:

select b.id 
from bigtable b
join (select id from bigtable where id <= 10 ) o 
on b.id = o.id;
7、分区分桶

五、合理设置Map及Reduce数

1)通常情况下,作业会通过input的目录产生一个或者多个map任务。
主要的决定因素有:input的文件总个数,input的文件大小,集群设置的文件块大小。

2)是不是map数越多越好?
答案是否定的。如果一个任务有很多小文件(远远小于块大小128m),则每个小文件也会被当做一个块,用一个map任务来完成,而一个map任务启动和初始化的时间远远大于逻辑处理的时间,就会造成很大的资源浪费。而且,同时可执行的map数是受限的。

3)是不是保证每个map处理接近128m的文件块,就高枕无忧了?
答案也是不一定。比如有一个127m的文件,正常会用一个map去完成,但这个文件只有一个或者两个小字段,却有几千万的记录,如果map处理的逻辑比较复杂,用一个map任务去做,肯定也比较耗时。
针对上面的问题2和3,我们需要采取两种方式来解决:即减少map数和增加map数;

1、复杂文件增加Map数

当input的文件都很大,任务逻辑复杂,map执行非常慢的时候,可以考虑增加Map数,来使得每个map处理的数据量减少,从而提高任务的执行效率。

增加map的方法为:根据
computeSliteSize(Math.max(minSize,Math.min(maxSize,blocksize)))=blocksize=128M公式,调整maxSize最大值。让maxSize最大值低于blocksize就可以增加map的个数。

设置最大切片值为100个字节:

set mapreduce.input.fileinputformat.split.maxsize=100;
2、小文件进行合并

1)在map执行前合并小文件,减少map数
CombineHiveInputFormat具有对小文件进行合并的功能(系统默认的格式)。HiveInputFormat没有对小文件合并功能。

set hive.input.format= org.apache.hadoop.hive.ql.io.CombineHiveInputFormat;

2)在Map-Reduce的任务结束时合并小文件的设置
在map-only任务结束时合并小文件,默认true

SET hive.merge.mapfiles = true;

在map-reduce任务结束时合并小文件,默认false

SET hive.merge.mapredfiles = true;

合并文件的大小,默认256M

SET hive.merge.size.per.task = 268435456;

当输出文件的平均大小小于该值时,启动一个独立的map-reduce任务进行文件merge

SET hive.merge.smallfiles.avgsize = 16777216;
3、合理设置Reduce数

(1)调整reduce个数方法一
1)每个Reduce处理的数据量默认是256MB

hive.exec.reducers.bytes.per.reducer=256000000

2)每个任务最大的reduce数,默认为1009

hive.exec.reducers.max=1009

3)计算reducer数的公式

N=min(参数2,总输入数据量/参数1)

(2)调整reduce个数方法二
在hadoop的mapred-default.xml文件中修改
设置每个job的Reduce个数

set mapreduce.job.reduces = 15;

(3)reduce个数并不是越多越好
1)过多的启动和初始化reduce也会消耗时间和资源;

2)另外,有多少个reduce,就会有多少个输出文件,如果生成了很多个小文件,那么如果这些小文件作为下一个任务的输入,则也会出现小文件过多的问题;

在设置reduce个数的时候也需要考虑这两个原则:处理大数据量利用合适的reduce数;使单个reduce任务处理数据量大小要合适;

六、并行执行

  • 并行:真正意义上的并发执行;多线程同时执行;
  • 并发: 多线程执行,但不是同时;多个线程抢占几个CPU资源;

执行SQL会分多个阶段,通过EXPLAIN可以查看具体阶段;各个阶段间有的有依赖关系,有的是比较独立的。互相独立的阶段,可以拿出来并行执行。

Hive会将一个查询转化成一个或者多个阶段。这样的阶段可以是MapReduce阶段、抽样阶段、合并阶段、limit阶段。默认情况下,Hive一次只会执行一个阶段。不过,某个特定的job可能包含众多的阶段,而这些阶段可能并非完全互相依赖的,也就是说有些阶段是可以并行执行的,这样可能使得整个job的执行时间缩短。不过,如果有更多的阶段可以并行执行,那么job可能就越快完成。
通过设置参数hive.exec.parallel = true,就可以开启并发执行。不过,在共享集群中,需要注意下,如果job中并行阶段增多,那么集群利用率就会增加。

set hive.exec.parallel=true;              //打开任务并行执行
set hive.exec.parallel.thread.number=16;  //同一个sql允许最大并行度,默认为8。

当然,得是在系统资源比较空闲的时候才有优势,否则,没资源,并行也起不来。

七、严格模式

Hive可以通过设置防止一些危险操作(大数据量查询等耗费资源的操作)。

1、分区表不使用分区过滤
hive.strict.checks.no.partition.filter = true时,对于分区表,如果过滤条件中不包含分区字段,就不允许执行。换句话说,就是用户不允许扫描所有分区。进行这个限制的原因是,通常分区表都拥有非常大的数据集,而且数据增加迅速。没有进行分区限制的查询可能会消耗令人不可接受的巨大资源来处理这个表。

2、使用order by没有limit过滤
hive.strict.checks.orderby.no.limit = true时,对于使用了order by语句的查询,要求必须使用limit语句。因为order by为了执行排序过程会将所有的结果数据分发到同一个Reducer中进行处理,强制要求用户增加这个LIMIT语句可以防止Reducer额外执行很长一段时间。

3、笛卡尔积
hive.strict.checks.cartesian.product = true时,会限制笛卡尔积的查询。对关系型数据库非常了解的用户可能期望在 执行JOIN查询的时候不使用ON语句而是使用where语句,这样关系数据库的执行优化器就可以高效地将WHERE语句转化成那个ON语句。不幸的是,Hive并不会执行这种优化,因此,如果表足够大,那么这个查询就会出现不可控的情况。

八、JVM重用

主要用在小文件场景,频繁建容器,销毁容器,占用时间超过计算时间。可以让多个TASK(MAP或REDUCE),在同一个容器(JVM环境)中执行。

九、压缩

减少磁盘使用空间;IO传输的数据量减低,传输速度就会变快;

你可能感兴趣的:(大数据,hive,大数据,hadoop)