精华内容
下载资源
问答
  • Hive 优化

    2020-03-18 22:43:43
    Hive 优化 - Fetch抓取 Hive 优化 - 小表Join大表 Hive 优化 - 空Key处理 Hive 优化 - MapJoin Hive 优化 - GroupBy Hive 优化 - 去重统计 Hive 优化 - 行列过滤 Hive 优化 - 动态分区 Hive 优化 - 数据倾斜...
    1. Hive 优化 -  Fetch抓取
    2. Hive 优化 - 小表Join大表
    3. Hive 优化 - 空Key处理
    4. Hive 优化 -  MapJoin
    5. Hive 优化 - GroupBy
    6. Hive 优化 - 去重统计
    7. Hive 优化 -  行列过滤
    8. Hive 优化 - 动态分区
    9. Hive 优化 - 数据倾斜
    10. Hive 优化 -  并行执行
    11. Hive 优化 - 严格模式
    12. Hive 优化 - JVM重用
    13. Hive 优化 -  推测执行&压缩
    14. Hive 优化 - Explain
    展开全文
  • HIVE 优化

    2021-01-08 16:45:38
    优化思路HIVE 优化HIVE优化核心思想:以下SQL不会转为Mapreduce来执行:Explain 显示执行计划HIVE运行方式本地模式并行计算严格模式hive排序hive join合并小文件去重统计 HIVE优化 核心思想: 把Hive SQL 当做...

    HIVE 优化

    HIVE优化

    核心思想:

    把Hive SQL 当做Mapreduce程序去优化

    以下SQL不会转为Mapreduce来执行:

    select仅查询本表字段

    where仅对本表字段做条件过滤

    Explain 显示执行计划

    EXPLAIN [EXTENDED] query
    

    HIVE运行方式

    -本地模式

    -集群模式

    本地模式

    开启本地模式:

    set hive.exec.mode.local.auto=true;

    注意:

    • hive.exec.mode.local.auto.inputbytes.max默认值为128M

    • 表示加载文件的最大值,若大于该配置仍会以集群方式来运行!

    并行计算

    通过设置以下参数开启并行模式:

    set hive.exec.parallel=true;

    注意:hive.exec.parallel.thread.number

    (一次SQL计算中允许并行执行的job个数的最大值)

    严格模式

    通过设置以下参数开启严格模式:

    set hive.mapred.mode=strict;

    (默认为:nonstrict非严格模式)

    查询限制:

    1、对于分区表,必须添加where对于分区字段的条件过滤;

    2、order by语句必须包含limit输出限制;

    3、限制执行笛卡尔积的查询。

    hive排序

    • Order By - 对于查询结果做全排序,只允许有一个reduce处理

    ​ 当数据量较大时,应慎用。严格模式下,必须结合limit来使用

    • Sort By - 对于单个reduce的数据进行排序

    • Distribute By - 分区排序,经常和Sort By结合使用

    • Cluster By - 相当于 Sort By + Distribute By

    ​ (Cluster By不能通过asc、desc的方式指定排序规则,只能是升序;

    ​ 可通过 distribute by column sort by column asc|desc 的方式)

    hive join

    • 自动的mapjoin

    ​ 通过修改以下配置启用自动的mapjoin:

    ​ set hive.auto.convert.join = true;

    ​ (该参数为true时,Hive自动对左边的表统计量,如果是小表就加入内存,即对小表使用Map join)

    相关配置参数

    hive.mapjoin.smalltable.filesize;

    (大表小表判断的阈值,如果表的大小小于该值则会被加载到内存中运行)

    hive.ignore.mapjoin.hint;

    (默认值:true;是否忽略mapjoin hint 即mapjoin标记)

    hive.auto.convert.join.noconditionaltask;

    (默认值:true;将普通的join转化为普通的mapjoin时,是否将多个mapjoin转化为一个mapjoin)

    hive.auto.convert.join.noconditionaltask.size;

    (将多个mapjoin转化为一个mapjoin时,其表的最大值)

    合并小文件

    文件数目小,容易在文件存储端造成压力,给hdfs造成压力,影响效率

    设置合并属性

    • 是否合并map输出文件:hive.merge.mapfiles=true

    • 是否合并reduce输出文件:hive.merge.mapredfiles=true;

    • 合并文件的大小:hive.merge.size.per.task=25610001000

    去重统计

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

    展开全文
  • Hive优化

    2020-12-22 21:29:37
    HIVE优化(设置合理的map reduce的task数) 这里写目录标题HIVE优化(设置合理的map reduce的task数)1 map阶段优化1.1 map参数1.2 map切分情况1.3 主要的解决方式2.reduce阶段优化2.1 Reduce的个数2.2 Hive自己如何确定...

    HIVE优化(设置合理的map reduce的task数)

    1 map阶段优化

    1.1 map参数

    1.2 map切分情况

    1.3 主要的解决方式

    2.reduce阶段优化

    2.1 Reduce的个数

    2.2 Hive自己如何确定reduce数

    2.3 调整reduce个数方法一

    2.4 调整reduce个数方法二

    2.5 reduce个数并不是越多越好

    2.6 什么情况下只有一个reduce

    3.小文件合并优化

    Hive优化之小文件问题及其解决方案:

    小文件是如何产生的

    小文件问题的影响

    小文件问题的解决方案

    map/reduce端的相关参数

    1 map阶段优化
    1.1 map参数
    mapred.min.split.size:数据的最小分割单元;min值默认是1KB。
    mapred.max.split.size:数据的最大分割单元;max值默认是256M。
    通过调整max可以起到调整map数的作用,减小max可以增加map数;增加min可以减少map数。
    注意:直接调整 mapred.map.task 这个参数是没有效果的。
    1.2 map切分情况

    • 假设input目录下有1个文件a,大小是780M,那么map默认参数会把a分成7块(6个128M和1个 12M),从而产生7个map。

    • 假设input目录下有3个文件a,b,c,大小分别为10M,20M,130M,那么hadoop会把文件分成4块(10M,20M,128M,2M),从而产生4个map数。

      注意:如果文件大于块大小(128M),那么会拆分,如果小于块大小,则把该文件当成一个块。
      这就涉及到小文件的问题:如果一个任务有很多小文件(远远小于块大小128M),则每个小文件也会当做一个块,用一个map任务来完成。
      而一个map任务启动和初始化的时间远远大于逻辑处理的时间,就会造成很大的资源浪费。而且,同时可执行的map数是受限的。那么,是不是保证每个map处理接近128M的文件块,就高枕无忧了?答案也是不一定。比如有一个127M的文件,正常会用一个map去完成,但这个文件只有一个或者两个小字段,却有几千万的记录,如果map处理的逻辑比较复杂,用一个map任务去做,肯定也比较耗时。

    1.3 主要的解决方式

    • 减少map的数量
    假设一个SQL任务:
    Select count(1) from popt_tbaccountcopy_meswhere pt = '2012-07-04';
    该任务的inputdir :  /group/p_sdo_data/p_sdo_data_etl/pt/popt_tbaccountcopy_mes/pt=2012-07-04
    共有194个文件,其中很多事远远小于128M的小文件,总大小9G,正常执行会用194map任务。
    Map总共消耗的计算资源:SLOTS_MILLIS_MAPS= 623,020
    
    通过以下方法来在map执行前合并小文件,减少map数:
    set mapred.max.split.size=128000000;  			// 能分割块的最大块大小
    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;	// 合并文件
    再执行上面的语句,用了74map任务,map消耗的计算资源:SLOTS_MILLIS_MAPS= 333,500
    对于这个简单SQL任务,执行时间上可能差不多,但节省了一半的计算资源。
    大概解释一下,100000000表示100M, 
    set hive.input.format=org.apache.hadoop.hive.ql.io.CombineHiveInputFormat;这个参数表示执行前进行小文件合并,
    前面三个参数确定合并文件块的大小,大于文件块大小128m的,按照128m来分隔,
    小于128m,大于100m的,按照100m来分隔,把那些小于100m的(包括小文件和分隔大文件剩下的),
    进行合并,最终生成了74个块。
    
    • 增加map的数量
    如何适当的增加map数?
    当input的文件都很大,任务逻辑复杂,map执行非常慢的时候,可以考虑增加Map数,
    来使得每个map处理的数据量减少,从而提高任务的执行效率。
    
     假设有这样一个任务:
        Select data_desc,
                   count(1),
                   count(distinct id),
                   sum(case when ...),
                   sum(case when ...),
                   sum(...)
        from a group by data_desc
    
    如果表a只有一个文件,大小为120M,但包含几千万的记录,如果用1map去完成这个任务,肯定是比较耗时的,
    这种情况下,我们要考虑将这一个文件合理的拆分成多个,
    这样就可以用多个map任务去完成。
        set mapred.reduce.tasks=10;
          create table a_1 as 
          select * from a 
          distribute by rand(123);
    
    这样会将a表的记录,随机的分散到包含10个文件的a_1表中,再用a_1代替上面sql中的a表,则会用10map任务去完成。
    每个map任务处理大于12M(几百万记录)的数据,效率肯定会好很多。
    
    • 注意:看上去,貌似这两种有些矛盾,一个是要合并小文件,一个是要把大文件拆成小文件,这点正是重点需要关注的地方,使单个map任务处理合适的数据量;

    2.reduce阶段优化
    2.1 Reduce的个数
    Reduce的个数对整个作业的运行性能有很大影响。如果Reduce设置的过大,那么将会产生很多小文件,对NameNode会产生一定的影响,而且整个作业的运行时间未必会减少;如果Reduce设置的过小,那么单个Reduce处理的数据将会加大,很可能会引起OOM异常。
    如果设置了mapred.reduce.tasks/mapreduce.job.reduces参数,那么Hive会直接使用它的值作为Reduce的个数;如果mapred.reduce.tasks/mapreduce.job.reduces的值没有设置(也就是-1),那么Hive会根据输入文件的大小估算出Reduce的个数。根据输入文件估算Reduce的个数可能未必很准确,因为Reduce的输入是Map的输出,而Map的输出可能会比输入要小,所以最准确的数根据Map的输出估算Reduce的个数。

    2.2 Hive自己如何确定reduce数:
    reduce个数的设定极大影响任务执行效率,不指定reduce个数的情况下,Hive会猜测确定一个reduce个数,基于以下两个设定:

      hive.exec.reducers.bytes.per.reducer(每个reduce任务处理的数据量,默认为1000^3=1G)
      hive.exec.reducers.max(每个任务最大的reduce数,默认为999)
      计算reducer数的公式很简单N=min(参数2,总输入数据量/参数1)
      即,如果reduce的输入(map的输出)总大小不超过1G,那么只会有一个reduce任务;
      
    如:select pt,count(1) from popt_tbaccountcopy_mes where pt = '2012-07-04' group by pt; 
                /group/p_sdo_data/p_sdo_data_etl/pt/popt_tbaccountcopy_mes/pt=2012-07-04 总大小为9G多,因此这句有10reduce
    

    2.3 调整reduce个数方法一:

      调整hive.exec.reducers.bytes.per.reducer参数的值;
      set hive.exec.reducers.bytes.per.reducer=500000000; (500M)
      select pt, count(1) from popt_tbaccountcopy_mes where pt = '2012-07-04' group by pt;
      这次有20reduce
    

    2.4 调整reduce个数方法二

      set mapred.reduce.tasks=15;
      select pt,count(1) from popt_tbaccountcopy_mes where pt = '2012-07-04' group by pt;
      这次有15reduce
    

    2.5 reduce个数并不是越多越好

      同map一样,启动和初始化reduce也会消耗时间和资源;
      另外,有多少个reduce,就会有个多少个输出文件,如果生成了很多个小文件,那么如果这些小文件作为下一个任务的输入,则也会出现小文件过多的问题;
    

    2.6 什么情况下只有一个reduce;
    很多时候你会发现任务中不管数据量多大,不管你有没有调整reduce个数的参数,任务中一直都只有一个reduce任务;其实只有一个reduce任务的情况,除了数据量小于hive.exec.reducers.bytes.per.reducer参数值的情况外,还有以下原因

    1. 没有group by的汇总,比如把select pt,count(1) from popt_tbaccountcopy_mes where pt =2012-07-04’  group by pt; 写成select count(1) from popt_tbaccountcopy_mes where pt =2012-07-04; 这点非常常3. 见,希望大家尽量改写。
    2.用了Order by
    3.有笛卡尔积。
    

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

    3.小文件合并优化
    我们知道文件数目小,容易在文件存储端造成瓶颈,给HDFS带来压力,影响处理效率。对此,可以通过合并Map和Reduce的结果文件来消除这样的影响。

    用于设置合并的参数有:

    • 是否合并Map输出文件:hive.merge.mapfiles=true(默认值为true)
    • 是否合并Reduce端输出文件:hive.merge.mapredfiles=false(默认值为false)
    • 合并文件的大小:hive.merge.size.per.task=25610001000(默认值为256000000)

    3.1 Hive优化之小文件问题及其解决方案:
    小文件是如何产生的:

    • 动态分区插入数据,产生大量的小文件,从而导致map数量剧增;
    • reduce数量越多,小文件也越多(reduce的个数和输出文件是对应的);
    • 数据源本身就包含大量的小文件。
      小文件问题的影响:
    • 从Hive的角度看,小文件会开很多map,一个map开一个JVM去执行,所以这些任务的初始化,启动,执行会浪费大量的资源,严重影响性能。
    • 在HDFS中,每个小文件对象约占150byte,如果小文件过多会占用大量内存。这样NameNode内存容量严重制约了集群的扩展。

    小文件问题的解决方案:
    从小文件产生的途径就可以从源头上控制小文件数量,方法如下:

    • 使用Sequencefile作为表存储格式,不要用textfile,在一定程度上可以减少小文件;
    • 减少reduce的数量(可以使用参数进行控制);
    • 少用动态分区,用时记得按distribute by分区;

    对于已有的小文件,我们可以通过以下几种方案解决:

    • 使用hadoop archive命令把小文件进行归档;
    • 重建表,建表时减少reduce数量;

    通过参数进行调节,设置map/reduce端的相关参数,如下

    //每个Map最大输入大小(这个值决定了合并后文件的数量)  
    set mapred.max.split.size=256000000;    
    //一个节点上split的至少的大小(这个值决定了多个DataNode上的文件是否需要合并)  
    set mapred.min.split.size.per.node=100000000;  
    //一个交换机下split的至少的大小(这个值决定了多个交换机上的文件是否需要合并)    
    set mapred.min.split.size.per.rack=100000000;  
    //执行Map前进行小文件合并  
    set hive.input.format=org.apache.hadoop.hive.ql.io.CombineHiveInputFormat;   
    
    设置map输出和reduce输出进行合并的相关参数:
    [java] view plain copy
    //设置map端输出进行合并,默认为true  
    set hive.merge.mapfiles = true  
    //设置reduce端输出进行合并,默认为false  
    set hive.merge.mapredfiles = true  
    //设置合并文件的大小  
    set hive.merge.size.per.task = 256*1000*1000  
    //当输出文件的平均大小小于该值时,启动一个独立的MapReduce任务进行文件merge。  
    set hive.merge.smallfiles.avgsize=16000000
    
    展开全文
  • hive优化

    2020-11-04 14:39:41
    hive优化 1 Fetch抓取 Fetch抓取是指,Hive中对某些情况的查询可以不必使用MapReduce计算。例如:SELECT * FROM employees;在这种情况下,Hive可以简单地读取employee对应的存储目录下的文件,然后输出查询结果到...

    hive优化


    1 Fetch抓取

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

    在hive-default.xml.template文件中hive.fetch.task.conversion默认是more,老版本hive默认是minimal,该属性修改为more以后,在全局查找、字段查找、limit查找等都不走mapreduce。

    2 小表、大表Join

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

    实际测试发现:新版的hive已经对小表JOIN大表和大表JOIN小表进行了优化。小表放在左边和右边已经没有明显区别。

    3 大表Join大表空KEY过滤

    有时join超时是因为某些key对应的数据太多,而相同key对应的数据都会发送到相同的reducer上,从而导致内存不够。此时我们应该仔细分析这些异常的key,很多情况下,这些key对应的数据是异常数据,我们需要在SQL语句中进行过滤。

    4 合理设置Map及Reduce数(MR引擎)

    (1)通常情况下,作业会通过input的目录产生一个或者多个map任务。

    主要的决定因素有:input的文件总个数,input的文件大小,集群设置的文件块大小。

    (2)是不是map数越多越好?

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

    (3)是不是保证每个map处理接近128m的文件块,就高枕无忧了?

    答案也是不一定。比如有一个127m的文件,正常会用一个map去完成,但这个文件只有一个或者两个小字段,却有几千万的记录,如果map处理的逻辑比较复杂,用一个map任务去做,肯定也比较耗时。

    针对上面的问题2和3,我们需要采取两种方式来解决:即减少map数和增加map数;

    5 严格模式

    Hive可以通过设置防止一些危险操作:

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

    (2)将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并不会执行这种优化,因此,如果表足够大,那么这个查询就会出现不可控的情况。

    6 JVM重用

    JVM重用是Hadoop调优参数的内容,其对Hive的性能具有非常大的影响,特别是对于很难避免小文件的场景或task特别多的场景,这类场景大多数执行时间都很短。

    Hadoop的默认配置通常是使用派生JVM来执行map和Reduce任务的。这时JVM的启动过程可能会造成相当大的开销,尤其是执行的job包含有成百上千task任务的情况。JVM重用可以使得JVM实例在同一个job中重新使用N次。N的值可以在Hadoop的mapred-site.xml文件中进行配置。通常在10-20之间,具体多少需要根据具体业务场景测试得出。

    展开全文
  • hive 优化

    2020-03-31 22:41:51
    Hive优化 Fetch抓取 Fetch抓取是指,**Hive中对某些情况的查询可以不必使用MapReduce计算。**例如:SELECT * FROM employees;在这种情况下,Hive可以简单地读取employee对应的存储目录下的文件,然后输出查询结果到...
  • HIVE优化

    2020-01-21 17:03:32
    HIVE优化Fetch抓取本地模式小表、大表JOIN大表JOIN大表MapJoin(小表join大表)Group ByCOUNT(distinct)去重统计笛卡尔积行列过滤 Fetch抓取 Hive中某些情况查询可以不必使用MapReduce计算。 例子:select * from ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,069
精华内容 2,427
关键字:

hive优化