hive小文件调优实践

已于 2023-05-19 18:15:24 修改
阅读量2.1k 收藏 20
点赞数 3
分类专栏： hive 文章标签： hive hadoop 数据仓库
于 2022-02-17 22:27:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38251332/article/details/122992889
版权
本文详细介绍了Hive处理大量小文件的调优方法，包括使用distributeby分区函数、输入端小文件合并、map-only和mapReducejob输出小文件合并、减少Reduce数量、以及输出结果和中间过程小文件调优。通过实例展示了不同策略的效果，如数据重分区、合并小文件、设置reduce数量等，以优化Hive查询性能和HDFS存储效率。
摘要由CSDN通过智能技术生成

以最详细，生产实例的方式展现hive大量小文件的调优过程，包括：

小文件产生的原因

  • 动态分区使用不合理，动态分区插入的时候，误判导致产生大量分区，大量分区自然就产生大量小文件

  • reduce的数量设置的较多，到reduce处理时，会分配到不同的reduce中，会产生大量的小文件

  • 源数据文件本身就存在大量的小文件

小文件过多产生的影响

  • 首先从底层存储HDFS文件系统来讲，HDFS本身就不适合存储大量小文件，小文件过多会致使namenode元数据特别大, 占用太多内存，严重影响HDFS的性能

  • 对 hive 来讲，在进行查询时，每一个小文件都会当成一个块，启动一个Map task来完成，而一个Map task启动和初始化的时间远远大于逻辑处理的时间，就会形成很大的资源浪费。并且，同时可执行的Map task数量也是受限的。

hive distribute by分区函数应用调优

distribute by类似MR中partition（自定义分区），分区规则是根据分区字段的hash码与reduce的个数进行取余操作后，余数相同的分到一个区。

以表中字段分区

set hive.auto.convert.join=true;
set hive.auto.convert.join.noconditionaltask=true;
set hive.auto.convert.join.noconditionaltask.size=10000000;
set hive.mapjoin.smalltable.filesize=200000000;

set hive.merge.mapfiles = true;
set hive.merge.mapredfiles = true; 
set hive.merge.size.per.task = 256000000;
set hive.merge.smallfiles.avgsize = 256000000;
set hive.merge.orcfile.stripe.level=false;
set hive.merge.rcfile.block.level=false;

--指定tmp.tmp_01的文件存储格式，默认为textfile
set hive.default.fileformat = orc;

drop table if exists tmp.tmp_01;
create table tmp.tmp_01 
--STORED AS orc
as
SELECT
      a.item_sku_id 
FROM  (
            SELECT
                    item_sku_id,sku_name,brandname_cn,data_type
            FROM big_table 
            WHERE dt = '2022-02-15' AND brandname_cn = '汾酒'
            distribute by item_sku_id -- 大表以表中字段分组
      ) a --数据量远远大于10M
LEFT OUTER JOIN
      (     SELECT item_sku_id 
            FROM small_table 
            WHERE version = '1' AND normal_brandname_en = 'fenjiu' AND dt = '2022-02-15'
      ) b --数据量大小小于10M
ON a.item_sku_id = b.item_sku_id
WHERE b.item_sku_id IS NULL;

结果：

2022-02-16 23:03:47 INFO Table tmp.tmp_ljjtest02 stats: [numFiles=23, numRows=23, totalSize=5894, rawDataSize=2252]
2022-02-16 23:03:47 INFO Stage-1: Map: 18024  Reduce: 1009   Cumulative CPU: 377078.2 sec   HDFS Read: 193.287 GB HDFS Write: 0.000 GB SUCCESS  Elapsed : 4m18s539ms job_5690061100801_32622232
2022-02-16 23:03:47 INFO Stage-10: Map: 920   Cumulative CPU: 5431.21 sec   HDFS Read: 0.008 GB HDFS Write: 0.000 GB SUCCESS  Elapsed : 52s336ms job_5690061100801_32622707
2022-02-16 23:03:47 INFO Stage-4: Map: 832   Cumulative CPU: 1078.67 sec   HDFS Read: 0.001 GB HDFS Write: 0.000 GB SUCCESS  Elapsed : 31s273ms job_8766029101801_36250210
2022-02-16 23:03:47 INFO Total MapReduce CPU Time Spent: 4d10h33m8s80ms
2022-02-16 23:03:47 INFO Total Map: 19776  Total Reduce: 1009
2022-02-16 23:03:47 INFO Total HDFS Read: 193.296 GB  Written: 0.000 GB

结果分析：

以表中字段分区，如果数据不均匀，可能会造成数据倾斜。

以随机数分区

set hive.auto.convert.join=true;
set hive.auto.convert.join.noconditionaltask=true;
set hive.auto.convert.join.noconditionaltask.size=10000000;
set hive.mapjoin.smalltable.filesize=200000000;

set hive.merge.mapfiles = true;
set hive.merge.mapredfiles = true; 
set hive.merge.size.per.task = 256000000;
set hive.merge.smallfiles.avgsize = 256000000;
set hive.merge.orcfile.stripe.level=false;
set hive.merge.rcfile.block.level=false;

--指定tmp.tmp_01的文件存储格式，默认为textfile
set hive.default.fileformat = orc;

drop table if exists tmp.tmp_01;
create table tmp.tmp_01 
--STORED AS orc
as
SELECT
      a.item_sku_id 
FROM  (
            SELECT
                    item_sku_id,sku_name,brandname_cn,data_type
            FROM big_table 
            WHERE dt = '2022-02-15' AND brandname_cn = '汾酒'
            distribute by rand(100)-- 大表以随机数分组
      ) a --数据量远远大于10M
LEFT OUTER JOIN
      (     SELECT item_sku_id 
            FROM small_table 
            WHERE version = '1' AND normal_brandname_en = 'fenjiu' AND dt = '2022-02-15'
      ) b --数据量大小小于10M
ON a.item_sku_id = b.item_sku_id
WHERE b.item_sku_id IS NULL;

结果：

2022-02-16 22:53:00 INFO Table tmp.tmp_01 stats: [numFiles=3, numRows=23, totalSize=958, rawDataSize=2235]
2022-02-16 22:53:00 INFO Stage-1: Map: 18024  Reduce: 1009   Cumulative CPU: 372613.35 sec   HDFS Read: 193.289 GB HDFS Write: 0.000 GB SUCCESS  Elapsed : 5m32s865ms job_5690061100801_32621522
2022-02-16 22:53:00 INFO Stage-10: Map: 924   Cumulative CPU: 5424.53 sec   HDFS Read: 0.008 GB HDFS Write: 0.000 GB SUCCESS  Elapsed : 41s846ms job_5690061100801_32621870
2022-02-16 22:53:00 INFO Stage-4: Map: 858   Cumulative CPU: 1374.95 sec   HDFS Read: 0.001 GB HDFS Write: 0.000 GB SUCCESS  Elapsed : 43s592ms job_5690061100801_32621913
2022-02-16 22:53:00 INFO Total MapReduce CPU Time Spent: 4d9h23m32s830ms
2022-02-16 22:53:00 INFO Total Map: 19806  Total Reduce: 1009
2022-02-16 22:53:00 INFO Total HDFS Read: 193.298 GB  Written: 0.000 GB

结果分析：

以随机数分区，可以把数据从map端随机均匀的拆分给reduce端

总结

数据重分区（触发一个mr job），控制在map端如何拆分数据给reduce端，默认hash
distribute by item_sku_id 会导致数据倾斜
distribute by rand() 如果执行过程中其中一个reduce任务失败，可能会导致数据丢失或重复
distribute by rand(int seed) 指定随机种子，会得到一个稳定的随机数序列，可以避免数据不准确的问题

distribute by rand()的风险具体原理如下：

  • 部分reduce shuffle失败导致上游个别map task重新生成数据，如果shuffle分片逻辑不包含随机因子，会导致新生成的数据shuffle分片与之前不完全一致，进而导致部分数据重复读取或者数据丢失

  • reduce task从每个map task的结果文件中拉取对应分区的数据。数据在map阶段已经是分好区了，并且会有一个额外的索引文件记录每个分区的起始偏移量。所以reducetask取数的时候直接根据偏移量去拉取数据。

  • 新生成的shuffle分片内数据会丢数据，同时也可能包含已经分发到其他reducer的map阶段数据，导致数据重复分发。

    注意：
    rand(int seed) 是个稳定的随机数序列而不是固定的数值，从table列的角度来说，每一列都是不一样
    可以通过【select *,rand(1) as rand from t1】去验证

hive输入端小文件合并调优方式

输入端小文件合并设置:

--输入小文件合并，若读取小文件较多，则设置在map端进行小文件合并参数
set hive.input.format = org.apache.hadoop.hive.ql.io.CombineHiveInputFormat;-- 执行Map前进行小文件合并
set hive.hadoop.supports.splittable.combineinputformat = true;
--其中一种方版本
set mapreduce.input.fileinputformat.split.maxsize = 256000000;
set mapreduce.input.fileinputformat.split.minsize =256000000;
set mapreduce.input.fileinputformat.split.minsize.per.node=256000000;
set mapreduce.input.fileinputformat.split.minsize.per.rack=256000000;
--另一种版本
SET mapred.max.split.size = 256000000; //设置mapper拆分大小
SET mapred.min.split.size = 256000000;
SET mapred.min.split.size.per.node = 256000000;
SET mapred.min.split.size.per.rack = 256000000;

根据hive的版本不同，不同的版本可能有些配置不一样，然后根据自己的实际集群情况进行设置。

map-only 和 mapReduce job输出小文件合并调优方式

开启输出结果小文件合并:
rcfile和orc需要特殊设置才能进行文级别的合并，parquet、textfile、sequencefile默认进行文件级别的合并

set hive.merge.mapfiles = true;--开启只有map（map-only）操作结束时小文件输出合并
set hive.merge.mapredfiles = true;--开启有map和reduce操作结束时小文件输出合并
set hive.merge.size.per.task = 256000000;--合并后每个文件的大小
set hive.merge.smallfiles.avgsize=256000000;--当输出文件的平均大小小于256000000时，启动一个独立的MR任务进行文件合并，触发小文件合并的阀值
set hive.merge.orcfile.stripe.level=false; --当这个参数设置为true,orc文件进行stripe Level级别的合并,当设置为false,orc文件进行文件级别的合并，默认为true。
set hive.merge.rcfile.block.level=false;--当这个参数设置为true,rcfile文件进行block Level级别的合并,当设置为false,rcfile文件进行文件级别的合并，默认为true。

map-only操作结束时小文件合并

set hive.auto.convert.join=true;
set hive.auto.convert.join.noconditionaltask=true;
set hive.auto.convert.join.noconditionaltask.size=10000000;
set hive.mapjoin.smalltable.filesize=200000000;

set hive.merge.mapfiles = true; -- map-only结束时小文件合并
set hive.merge.mapredfiles = false; -- MR操作结束时，不合并小文件
set hive.merge.size.per.task = 256000000;
set hive.merge.smallfiles.avgsize = 256000000;
set hive.merge.orcfile.stripe.level=false;
set hive.merge.rcfile.block.level=false;

--指定tmp.tmp_01的文件存储格式，默认为textfile
set hive.default.fileformat = orc;

drop table if exists tmp.tmp_01;
create table tmp.tmp_01 
--STORED AS orc
as
create table tmp.tmp_01 as
SELECT
      item_sku_id
FROM
      cdm.cdm_goods_360buy_act_basic_da
WHERE
      dt = '2022-02-15'
      AND barndname_cn = '汾酒'

结果：

2022-02-17 14:45:37 INFO Table tmp.tmp_ljjtest021 stats: [numFiles=1, numRows=18415, totalSize=110953, rawDataSize=1762456]

结果分析：

【set hive.merge.mapfiles = true;】控制map-only操作结束时的小文件合并

mapReduce操作结束时小文件合并

set hive.auto.convert.join=true;
set hive.auto.convert.join.noconditionaltask=true;
set hive.auto.convert.join.noconditionaltask.size=10000000;
set hive.mapjoin.smalltable.filesize=200000000;

set hive.merge.mapfiles = false; -- map-only结束时小文件不合并
set hive.merge.mapredfiles = true; -- MR操作结束时，合并小文件
set hive.merge.size.per.task = 256000000;
set hive.merge.smallfiles.avgsize = 256000000;
set hive.merge.orcfile.stripe.level=false;
set hive.merge.rcfile.block.level=false;

--指定tmp.tmp_01的文件存储格式，默认为textfile
set hive.default.fileformat = orc;

drop table if exists tmp.tmp_01;
create table tmp.tmp_01 
--STORED AS orc
as
SELECT
      a.item_sku_id 
FROM  (
            SELECT
                    item_sku_id,sku_name,brandname_cn,data_type
            FROM big_table 
            WHERE dt = '2022-02-15' AND brandname_cn = '汾酒'
      ) a --数据量远远大于10M
LEFT OUTER JOIN
      (     SELECT item_sku_id 
            FROM small_table 
            WHERE version = '1' AND normal_brandname_en = 'fenjiu' AND dt = '2022-02-15'
      ) b --数据量大小小于10M
ON a.item_sku_id = b.item_sku_id
WHERE b.item_sku_id IS NULL;

结果：

2022-02-16 23:12:45 INFO Table tmp.tmp_01 stats: [numFiles=1, numRows=23, totalSize=426, rawDataSize=2235]

结果分析：

【set hive.merge.mapredfiles = true;】控制mapReduce和mapjoin操作结束时的小文件合并

总结

这里需要注意mapjoin操作，虽然只触发了map操作，而没有触发reduce操作。
但这是优化的结果，本质上还是mapReduce任务，因此被【set hive.merge.mapredfiles = true;】参数控制。

减少Reduce数量小文件的调优方式

reduce 的个数决定了输出的文件的个数，因此能够调整reduce的个数控制hive表的文件数量，
hive中的分区函数 distribute by 控制MR中partition分区，即reduce的数量，结合分区函数让数据更加均衡的分配到每一个reduce。

  • 设置reduce的数量有两种方式，第一种是直接设置reduce个数
    set mapreduce.job.reduces=10;

  • 第二种是设置每一个reduce的大小，Hive会根据shuffle后数据量总的大小确定reducer个数
    set hive.exec.reducers.bytes.per.reducer=5120000000; – 默认是1G，设置为5G

输出结果减少小文件的数量

set mapreduce.job.reduces=10;
insert overwrite table A partition(dt)
select * from B
distribute by rand(1);

解释： 如设置reduce数量为10，则使用 rand(1)， 随机生成一个数 x % 10 ，
这样数据就会随机进入 reduce task中，防止出现有的文件太大或太小

中间过程减少小文件的数量

set hive.exec.reducers.bytes.per.reducer=5120000000; -- 默认是1G，设置为5G
SELECT
      a.* 
FROM  (
            SELECT
                    item_sku_id,sku_name,brandname_cn,data_type
            FROM big_table 
            WHERE dt = '2022-02-15' AND brandname_cn = '汾酒'
            distribute by rand(1) -- 分组
      ) a --数据量远远大于10M
LEFT OUTER JOIN
      (     SELECT item_sku_id 
            FROM small_table 
            WHERE version = '1' AND normal_brandname_en = 'fenjiu' AND dt = '2022-02-15'
      ) b --数据量大小小于10M
ON a.item_sku_id = b.item_sku_id
WHERE b.item_sku_id IS NULL

解释： 如果map 到reduce端中间过程shuffle后总的数据量大小为50G，则分区数为10，则使用 rand(1)， 随机生成一个数 x % 10 ，这样数据就会随机进入 reduce task中，防止中间过程的文件太大或太小

hive输出结果小文件问题调优思路

执行mapjoin，不合并小文件，不重分区

set hive.auto.convert.join=true;
set hive.auto.convert.join.noconditionaltask=true;
set hive.auto.convert.join.noconditionaltask.size=10000000;
set hive.mapjoin.smalltable.filesize=200000000;

set hive.merge.mapfiles = false;
set hive.merge.mapredfiles = false; --MR操作结束时，不合并小文件
set hive.merge.size.per.task = 256000000;
set hive.merge.smallfiles.avgsize = 256000000;
set hive.merge.orcfile.stripe.level=false;
set hive.merge.rcfile.block.level=false;

--指定tmp.tmp_01的文件存储格式，默认为textfile
set hive.default.fileformat = orc;

drop table if exists tmp.tmp_01;
create table tmp.tmp_01 
--STORED AS orc
as
SELECT
      a.item_sku_id 
FROM  (
            SELECT
                    item_sku_id,sku_name,brandname_cn,data_type
            FROM big_table 
            WHERE dt = '2022-02-15' AND brandname_cn = '汾酒'
            --distribute by rand(1) -- 不分组
      ) a --数据量远远大于10M
LEFT OUTER JOIN
      (     SELECT item_sku_id 
            FROM small_table 
            WHERE version = '1' AND normal_brandname_en = 'fenjiu' AND dt = '2022-02-15'
      ) b --数据量大小小于10M
ON a.item_sku_id = b.item_sku_id
WHERE b.item_sku_id IS NULL;

结果：

2022-02-17 16:53:18 INFO Table tmp.tmp_01 stats: [numFiles=18020, numRows=23, totalSize=887747, rawDataSize=2252]
2022-02-17 16:53:18 INFO MapReduce Jobs Launched:
2022-02-17 16:53:19 INFO Stage-4: Map: 18020   Cumulative CPU: 205038.93 sec   HDFS Read: 193.386 GB HDFS Write: 0.000 GB SUCCESS  Elapsed : 3m28s419ms job_8766029101801_36451400
2022-02-17 16:53:19 INFO 
2022-02-17 16:53:19 INFO Total MapReduce CPU Time Spent: 2d8h57m18s930ms
2022-02-17 16:53:19 INFO Total Map: 18020  Total Reduce: 0
2022-02-17 16:53:19 INFO Total HDFS Read: 193.386 GB  Written: 0.000 GB

结果分析：

执行mapjoin（在map端关联聚合），不合并小文件，每一个map对应一个输出文件。输出结果出现大量小文件。

执行mapjoin,不合并小文件,大表重分区

set hive.auto.convert.join=true;
set hive.auto.convert.join.noconditionaltask=true;
set hive.auto.convert.join.noconditionaltask.size=10000000;
set hive.mapjoin.smalltable.filesize=200000000;

set hive.merge.mapfiles = true;
set hive.merge.mapredfiles = false; --MR操作结束时，不合并小文件
set hive.merge.size.per.task = 256000000;
set hive.merge.smallfiles.avgsize = 256000000;
set hive.merge.orcfile.stripe.level=false;
set hive.merge.rcfile.block.level=false;

--指定tmp.tmp_01的文件存储格式，默认为textfile
set hive.default.fileformat = orc;

drop table if exists tmp.tmp_01;
create table tmp.tmp_01 
--STORED AS orc
as
SELECT
      a.item_sku_id 
FROM  (
            SELECT
                    item_sku_id,sku_name,brandname_cn,data_type
            FROM big_table 
            WHERE dt = '2022-02-15' AND brandname_cn = '汾酒'
            --distribute by rand(1) -- 大表分组
      ) a --数据量远远大于10M
LEFT OUTER JOIN
      (     SELECT item_sku_id 
            FROM small_table 
            WHERE version = '1' AND normal_brandname_en = 'fenjiu' AND dt = '2022-02-15'
      ) b --数据量大小小于10M
ON a.item_sku_id = b.item_sku_id
WHERE b.item_sku_id IS NULL;

结果：

2022-02-16 22:53:00 INFO Table tmp.tmp_01 stats: [numFiles=3, numRows=23, totalSize=958, rawDataSize=2235]
2022-02-16 22:53:00 INFO Stage-1: Map: 18024  Reduce: 1009   Cumulative CPU: 372613.35 sec   HDFS Read: 193.289 GB HDFS Write: 0.000 GB SUCCESS  Elapsed : 5m32s865ms job_5690061100801_32621522
2022-02-16 22:53:00 INFO Stage-10: Map: 924   Cumulative CPU: 5424.53 sec   HDFS Read: 0.008 GB HDFS Write: 0.000 GB SUCCESS  Elapsed : 41s846ms job_5690061100801_32621870
2022-02-16 22:53:00 INFO Stage-4: Map: 858   Cumulative CPU: 1374.95 sec   HDFS Read: 0.001 GB HDFS Write: 0.000 GB SUCCESS  Elapsed : 43s592ms job_5690061100801_32621913
2022-02-16 22:53:00 INFO Total MapReduce CPU Time Spent: 4d9h23m32s830ms
2022-02-16 22:53:00 INFO Total Map: 19806  Total Reduce: 1009
2022-02-16 22:53:00 INFO Total HDFS Read: 193.298 GB  Written: 0.000 GB

结果分析：

执行mapjoin（在map端关联聚合），不合并小文件，大表预先分组，触发MR，减少mapjoin阶段输出的map数量（即当前job执行完成产生的中间结果文件数量）。由于输入map tasks少了， 输出结果小文件也大大减少。

执行mapjoin,合并小文件

set hive.auto.convert.join=true;
set hive.auto.convert.join.noconditionaltask=true;
set hive.auto.convert.join.noconditionaltask.size=10000000;
set hive.mapjoin.smalltable.filesize=200000000;

set hive.merge.mapfiles = true;
set hive.merge.mapredfiles = true; --MR操作结束时，合并小文件
set hive.merge.size.per.task = 256000000;
set hive.merge.smallfiles.avgsize = 256000000;
set hive.merge.orcfile.stripe.level=false;
set hive.merge.rcfile.block.level=false;

--指定tmp.tmp_01的文件存储格式，默认为textfile
set hive.default.fileformat = orc;

drop table if exists tmp.tmp_01;
create table tmp.tmp_01 
--STORED AS orc
as
SELECT
      a.item_sku_id 
FROM  (
            SELECT
                    item_sku_id,sku_name,brandname_cn,data_type
            FROM big_table 
            WHERE dt = '2022-02-15' AND brandname_cn = '汾酒'
            --distribute by rand(1) -- 不分组,因为此时分组毫无意义，只会徒增任务开销
      ) a --数据量远远大于10M
LEFT OUTER JOIN
      (     SELECT item_sku_id 
            FROM small_table 
            WHERE version = '1' AND normal_brandname_en = 'fenjiu' AND dt = '2022-02-15'
      ) b --数据量大小小于10M
ON a.item_sku_id = b.item_sku_id
WHERE b.item_sku_id IS NULL;

结果：

2022-02-16 23:12:45 INFO Table tmp.tmp_01 stats: [numFiles=1, numRows=23, totalSize=426, rawDataSize=2235]
2022-02-16 23:12:45 INFO Stage-1: Map: 18024  Reduce: 1009   Cumulative CPU: 365693.05 sec   HDFS Read: 193.289 GB HDFS Write: 0.000 GB SUCCESS  Elapsed : 3m21s803ms job_5690061100801_32623163
2022-02-16 23:12:45 INFO Stage-10: Map: 918   Cumulative CPU: 5232.29 sec   HDFS Read: 0.008 GB HDFS Write: 0.000 GB SUCCESS  Elapsed : 40s544ms job_8766029101801_36250732
2022-02-16 23:12:45 INFO Stage-4: Map: 1   Cumulative CPU: 13.95 sec   HDFS Read: 0.000 GB HDFS Write: 0.000 GB SUCCESS  Elapsed : 43s762ms job_8766029101801_36250769
2022-02-16 23:12:45 INFO Total MapReduce CPU Time Spent: 4d7h2m19s290ms
2022-02-16 23:12:45 INFO Total Map: 18943  Total Reduce: 1009
2022-02-16 23:12:45 INFO Total HDFS Read: 193.297 GB  Written: 0.000 GB

结果分析：

执行mapjoin（在map端关联聚合），合并小文件。输出结果小文件数量同样也大大减少。

总结

mapjoin会在小表与大表join时的优化提升还是很明显的，但使用时有一些问题需要注意。
上例中执行mapjoin, 有18020个map，就对应输出18020个小文件（执行mapReduce会在大大减少输出的小文件数，测试集群默认最大的reduce数量1009个）。
因此就需要考虑后期小文件的合并，在大量小文件的场景下，需要考虑的处理方式是开启小文件合并或者大表重分区

hive中间过程(两个job之间)大量小文件的调优思路

不重分区，不合并小文件

set hive.auto.convert.join=true;
set hive.auto.convert.join.noconditionaltask=true;
set hive.auto.convert.join.noconditionaltask.size=10000000;
set hive.mapjoin.smalltable.filesize=200000000;

set hive.merge.mapfiles = false;
set hive.merge.mapredfiles = false; --MR操作结束时，不合并小文件
set hive.merge.size.per.task = 256000000;
set hive.merge.smallfiles.avgsize = 256000000;
set hive.merge.orcfile.stripe.level=false;
set hive.merge.rcfile.block.level=false;

WITH tmp as 
(
SELECT
      a.* 
FROM  (
            SELECT
                    item_sku_id,sku_name,brandname_cn,data_type
            FROM big_table 
            WHERE dt = '2022-02-15' AND brandname_cn = '汾酒'
            --distribute by rand(1) -- 不分组
      ) a --数据量远远大于10M
LEFT OUTER JOIN
      (     SELECT item_sku_id 
            FROM small_table 
            WHERE version = '1' AND normal_brandname_en = 'fenjiu' AND dt = '2022-02-15'
      ) b --数据量大小小于10M
ON a.item_sku_id = b.item_sku_id
WHERE b.item_sku_id IS NULL
)
create table tmp.tmp_01 
as
SELECT
c.item_sku_id
FROM tmp c
join small_table d
on c.item_sku_id=d.item_sku_id

结果：

2022-02-17 20:49:21 INFO Stage-8: Map: 18026   Cumulative CPU: 210204.23 sec   HDFS Read: 193.388 GB HDFS Write: 0.001 GB SUCCESS  Elapsed : 2m55s772ms job_5690061100801_32863650
2022-02-17 20:49:21 INFO Stage-6: Map: 472   Cumulative CPU: 3330.08 sec   HDFS Read: 0.334 GB HDFS Write: 0.000 GB SUCCESS  Elapsed : 50s42ms job_5690061100801_32865433
2022-02-17 20:49:21 INFO Total MapReduce CPU Time Spent: 2d11h18m54s310ms
2022-02-17 20:49:21 INFO Total Map: 18498  Total Reduce: 0
2022-02-17 20:49:21 INFO Total HDFS Read: 193.722 GB  Written: 0.001 GB

2022-02-17 20:49:22 INFO Time taken: 1045.892 seconds, Fetched: 46 row(s)
2022-02-17 20:49:23 INFO 任务结束! sql执行耗时 0 hour 17 mins 38 s

结果分析：

不重分区，不合并小文件的情况下用时1045秒

不重分区，合并小文件

set hive.auto.convert.join=true;
set hive.auto.convert.join.noconditionaltask=true;
set hive.auto.convert.join.noconditionaltask.size=10000000;
set hive.mapjoin.smalltable.filesize=200000000;

set hive.merge.mapfiles = true;
set hive.merge.mapredfiles = true; --MR操作结束时，合并小文件
set hive.merge.size.per.task = 256000000;
set hive.merge.smallfiles.avgsize = 256000000;
set hive.merge.orcfile.stripe.level=false;
set hive.merge.rcfile.block.level=false;

WITH tmp as 
(
SELECT
      a.* 
FROM  (
            SELECT
                    item_sku_id,sku_name,brandname_cn,data_type
            FROM big_table 
            WHERE dt = '2022-02-15' AND brandname_cn = '汾酒'
            --distribute by rand(1) -- 不分组
      ) a --数据量远远大于10M
LEFT OUTER JOIN
      (     SELECT item_sku_id 
            FROM small_table 
            WHERE version = '1' AND normal_brandname_en = 'fenjiu' AND dt = '2022-02-15'
      ) b --数据量大小小于10M
ON a.item_sku_id = b.item_sku_id
WHERE b.item_sku_id IS NULL
)
create table tmp.tmp_01 
as
SELECT
c.item_sku_id
FROM tmp c
join small_table d
on c.item_sku_id=d.item_sku_id

结果：

2022-02-17 20:45:25 INFO Stage-8: Map: 18026   Cumulative CPU: 214628.08 sec   HDFS Read: 193.388 GB HDFS Write: 0.001 GB SUCCESS  Elapsed : 3m41s147ms job_8766029101801_36477823
2022-02-17 20:45:25 INFO Stage-6: Map: 472   Cumulative CPU: 3995.4 sec   HDFS Read: 0.334 GB HDFS Write: 0.000 GB SUCCESS  Elapsed : 59s677ms job_5690061100801_32865009
2022-02-17 20:45:25 INFO Total MapReduce CPU Time Spent: 2d12h43m43s480ms
2022-02-17 20:45:25 INFO Total Map: 18498  Total Reduce: 0
2022-02-17 20:45:25 INFO Total HDFS Read: 193.722 GB  Written: 0.001 GB

2022-02-17 20:45:27 INFO Time taken: 1074.534 seconds, Fetched: 46 row(s)
2022-02-17 20:45:27 INFO 任务结束! sql执行耗时 0 hour 18 mins 10 s

结果分析：

不重分区，合并小文件的情况下用时1074秒

重分区，合并小文件

set hive.auto.convert.join=true;
set hive.auto.convert.join.noconditionaltask=true;
set hive.auto.convert.join.noconditionaltask.size=10000000;
set hive.mapjoin.smalltable.filesize=200000000;

set hive.merge.mapfiles = true;
set hive.merge.mapredfiles = true; --MR操作结束时，合并小文件
set hive.merge.size.per.task = 256000000;
set hive.merge.smallfiles.avgsize = 256000000;
set hive.merge.orcfile.stripe.level=false;
set hive.merge.rcfile.block.level=false;

WITH tmp as 
(
SELECT
      a.* 
FROM  (
            SELECT
                    item_sku_id,sku_name,brandname_cn,data_type
            FROM big_table 
            WHERE dt = '2022-02-15' AND brandname_cn = '汾酒'
            distribute by rand(1) -- 分组
      ) a --数据量远远大于10M
LEFT OUTER JOIN
      (     SELECT item_sku_id 
            FROM small_table 
            WHERE version = '1' AND normal_brandname_en = 'fenjiu' AND dt = '2022-02-15'
      ) b --数据量大小小于10M
ON a.item_sku_id = b.item_sku_id
WHERE b.item_sku_id IS NULL
)
create table tmp.tmp_01 
as
SELECT
c.item_sku_id
FROM tmp c
join small_table d
on c.item_sku_id=d.item_sku_id

结果：

2022-02-17 19:57:57 INFO Stage-1: Map: 18026  Reduce: 1009   Cumulative CPU: 362544.56 sec   HDFS Read: 193.290 GB HDFS Write: 0.000 GB SUCCESS  Elapsed : 4m55s871ms job_5690061100801_32857972
2022-02-17 19:57:57 INFO Stage-9: Map: 928   Cumulative CPU: 5520.28 sec   HDFS Read: 0.008 GB HDFS Write: 0.000 GB SUCCESS  Elapsed : 2m33s752ms job_5690061100801_32858541
2022-02-17 19:57:57 INFO Stage-7: Map: 472   Cumulative CPU: 3638.63 sec   HDFS Read: 0.334 GB HDFS Write: 0.000 GB SUCCESS  Elapsed : 1m42s589ms job_5690061100801_32858927
2022-02-17 19:57:57 INFO Total MapReduce CPU Time Spent: 4d7h15m3s470ms
2022-02-17 19:57:57 INFO Total Map: 19426  Total Reduce: 1009
2022-02-17 19:57:57 INFO Total HDFS Read: 193.634 GB  Written: 0.000 GB

2022-02-17 19:57:58 INFO Time taken: 690.782 seconds, Fetched: 46 row(s)
2022-02-17 19:57:58 INFO 任务结束! sql执行耗时 0 hour 11 mins 44 s

结果分析：

重分区，合并小文件的情况下用时690秒

总结

在hive任务中间结果产生大量小文件的情况下，合并小文件设置对中间结果几乎没有影响；
但触发大表重分区，减少mapjoin阶段的map数量，会大大减少计算任务的用时

其他调优方式

压缩文件的处理

对于输出结果为压缩文件形式存储的状况，要解决小文件问题。若是在map输入前合并，对输出的文件存储格式并无限制;可是若是使用输出合并，则必须配合SequenceFile来存储，不然没法进行合并。

如下是实例：

set hive.exec.compress.output=true;  --开启hive最终输出数据压缩功能
set mapred.output.compression.type=BLOCK;
set mapred.output.compression.codec=org.apache.hadoop.io.compress.SnappyCodec;

drop table if exists tmp.tmp_02;
create table tmp.tmp_02
STORED AS SEQUENCEFILE
AS 
select *
from tmp.tmp_01

使用HAR归档文件

Hadoop的归档文件格式也是解决小文件问题的方式之一，并且hive提供了原生支持。

set hive.archive.enabled= true;
set hive.archive.har.parentdir.settable= true;
set har.partfile.size=1099511627776;
ALTER TABLE tmp_01 tARCHIVE PARTITION(ds='2008-04-08', hr='12' );
ALTER TABLE tmp_01UNARCHIVE PARTITION(ds='2008-04-08', hr='12' );
PONY LEE
关注
  • 3
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
hive小文件优化
Xlucas的博客
06-29 524
小文件产生的原因 直接向表里面插入数据 比如我们要往一张表里面写入几行特定的数据，如下，每次运行都会往表里写入一个文件，这种一般生产很少见，因为这种操作一般说在位置的时候采用，如果有也是建议先将所有数据放在一个文件再做batch load的方式，这样就只有一个文件了。 insert into table A values('201','2','北京') 通过load方式加载数据 这种操作一般是将某一个或者一批文件上传到一个表里面，本地的多少个文件映射到hive就有多少个文件，运行语句如下 load
hive小文件问题
花花公子
08-13 860
输入小文件： 设置map输入合并小文件的相关参数： //每个Map最大输入大小(这个值决定了合并后文件的数量) set mapred.max.split.size=256000000; //一个节点上split的至少的大小(这个值决定了多个DataNode上的文件是否需要合并) set mapred.min.split.size.per.node=100000000; //一个交换机下s...
Hive的小文件处理
最新发布
早拾碗吧的博客
05-21 803
Hive的小文件处理。
hive-小文件优化
一定要努力努力再努力的博客
05-07 546
（一）小文件产生的原因 1.动态分区插入数据，产生大量的小文件，从而导致map数量剧增。 2.reduce数量越多，小文件也越多(reduce的个数和输出文件是对应的)。 3.数据源本身就包含大量的小文件。 （二）小文件产生的影响 1、首先对底层存储HDFS来说，HDFS本身就不适合存储大量小文件，小文件过多会导致namenode元数据特别大,占用太多内存，严重影响HDFS的性能 2、对 hive 来说，在进行查询时，每个小文件都会当成一个块，启动一个Map任务来完成，而一个Map任务启动和初始化的时
hive中orc小文件优化
Mr.Zheng的博客
11-07 2115
小文件的缺陷我们就不说了，直接进入到正题. HIVE自动合并输出的小文件的主要优化手段为： set hive.merge.mapfiles = true：在只有map的作业结束时合并小文件， set hive.merge.mapredfiles = true：在Map-Reduce的任务结束时合并小文件，默认为False； set hive.merge.size.per.task = 256000000; 合并后每个文件的大小，默认256000000 set hive.merge.smallfiles.av
Hive小文件优化
月苍的博客
09-06 648
hive优化 参考文档 参考文档 参考文档 小文件优化 小文件产生的原因 动态分区插入数据，产生大量小文件，从而导致map数量剧增 reduce数量越多，小文件也可能越多（reduce的数量等于输出文件的数量） 数据源本身包含大量的小文件 小文件的影响 从hive的角度，小文件过多会启动很多map，一个map就是一个JVM进程，这些任务初始化，启动，执行会浪费大量的资源，严重影响性能 在hdfs中，每个小文件对象的元数据信息大约150byt。如果小文件过多会占用大量内存。这样NameNode内存容量严
尚硅谷Hive企业级调优的资料
04-13
在大数据处理领域，Hive作为一个基于Hadoop的数据仓库工具，被广泛用于数据查询、分析以及存储。...通过对这些方面的深入理解和实践，可以显著提升Hive在处理大规模数据时的效率，从而更好地服务于企业的数据分析需求。
大公司大数据量hive调优实践
11-26
- **hive.merge.tezfiles**：合并小文件，减少HDFS上的文件数量，提高读取效率。 6. **运维监控**： - 使用Hive的Explain命令分析执行计划，找出瓶颈。 - 配置日志监控，定期分析Job运行情况，及时发现并解决...
hive工作调优小结
11-16
### Hive工作调优小结 #### 一、Map阶段的优化（Map Phase） 在Hive中，Map任务的数量直接影响到整个Hive作业的性能。Map任务的数量由以下公式计算得出： \[ \text{num_Map_tasks} = \max[\text{Mapred.min.split...
hive调优策略
09-28
- **解决**：除了上述提到的合并小文件外，还可以使用Hive的动态分区、桶排序等功能进一步优化。 #### 五、小结 Hive调优是一项综合性的技术工作，涉及Hive内部机制的理解、MapReduce任务的控制、大小表Join策略的...
Hive 动态分区小文件过多问题优化
h494411的博客
04-14 824
一、问题描述为了支撑相应的业务需求，本次生产环境通过Hive SQL来完成动态插入分区表数据的脚本开发。但是，动态分区的插入往往会伴随产生大量的小文件的发生。而小文件产生过多的影响主要分为以下两种情况：（1） 从Hive的角度看，小文件会开很多map，一个map开一个JVM去执行，所以这些任务的初始化，启动，执行会浪费大量的资源，严重影响性能。（2）在HDFS中，每个小文件对象约占150byte，如果小文件过多会占用大量内存。这样NameNode内存容量严重制约了集群的扩展。
Hive实战系列调优之小文件优化
qq_30003943的博客
10-30 504
小文件来源有哪些？ 常见的小文件来源于有：数据源本事就包含大量的小文件；动态分区插入的数据；reduce个数越多产生的小文件就越多。 大量小文件会有哪些影响？ 小文件会开很多map,一个map开一个JVM去执行，所以这些任务的初始化，启动，执行会浪费大量的资源，严重影响性能。 在Hdfs中，每个小文件对象约占150byte,如果小文件多会占用大量内存。 如何解决？ 少用动态分区，使用时记得按distribute by分区；减少reduce的数量；从数据源头解决； 案例1：按天将原始数据层进行动
【Hive】 HDFS小文件优化三重奏
a13555856912的专栏
07-31 263
小文件指的是hdfs文件远远小于hdfs block块的大小，比如默认的block大小是128m，文件size只有几k。当这种类型的文件又很多的情况下，就会造成在spark任务处理过程中map的任务数过多（我们都知道map数量的决定因素之一是一个hdfs文件对应一个map）。一个map任务启动和初始化的时间远远大于逻辑处理的时间，就会造成很大的资源浪费。 如果小文件从业务上无法从源头减少，那么可以参考如下几类优化方式： 1、设置JVM重用次数 hadoop 通常默...
Hive解决小文件
qq_43597431的博客
08-29 227
一、小文件的产生源头 1.数据源本身就是有很多小文件 2.动态分区插入数据产生大量小文件，导致map数据剧增 3.reduce个数越多小文件的个数越多 4.insert插入数据时也会产生过多小文件：ReduceTask数量*分区数=文件数或MapTask*分区数=文件数 二、小文件产生的影响 1.对于它的存储底层Hdfs来说，HDFS本身就不适合存储小文件，每一个小文件就是150Byte如果大量的小文件产生会导致NameNode元数据增多，占用大量内存 2.对于hive来说，每一个小文.
Hive小文件问题及处理
Deepexi_Date的博客
11-29 5732
作者：张建 第一章 小文件过多带来的三个影响 Hive是一个建立在Apache Hadoop之上建立的一个数仓系统，Hive使用Hadoop中的HDFS组件存储数据文件。在使用hive时通常会遇到小文件问题，即存储在HDFS上的数据文件是明显小于HDFS文件块大小的。小文件问题通常会带来以下影响。 1.1 HDFS内存资源消耗过大，并限制了数据存储规模 在HDFS中，具体的文件保存在datanode节点中，在namenode节点中会有一个内存对象与之对应，用于存储文件的元信息，如位置、大小、分块等，每个对象
Hive教程（09）- 彻底解决小文件的问题
阿甘兄
02-25 3435
文章目录01 引言02 小文件概述2.1 小文件的缘由2.1 小文件的危害03 小文件解决方案3.1 方式一：处理已有的小文件3.1.1 distribute by 命令3.1.2 concatenate 命令3.1.3 定时方案3.1.3.1 Linux crontab 控制3.1.3.2 Java代码控制（推荐）3.2 方式二：预防小文件3.3 方式三：使用HAR归档文件04 案例讲解4.1 模拟插入大量小文件4.2 使用distribute by 命令控制 01 引言 在前面的教程，我们知道了HDFS
Hive小文件问题：如何产生、造成影响、解决办法
hzp666的博客
05-28 4549
一、小文件是如何产生的 1.动态分区插入数据，产生大量的小文件，从而导致map数量剧增。 2.reduce数量越多，小文件也越多(reduce的个数和输出文件是对应的)。 3.数据源本身就包含大量的小文件。 二、小文件问题的影响 1.从Hive的角度看，小文件会开很多map，一个map开一个JVM去执行，所以这些任务的初始化，启动，执行会浪费大量的资源，严重影响性能。 2.在HDFS中，每个小文件对象约占150byte，如果小文件过多会占用大量内存。这样NameNode内存容量严重制约了集.
Hive小文件过多
someInNeed的博客
04-12 798
小文件产生原因 hive 中的小文件肯定是向 hive 表中导入数据时产生，所以先看下向 hive 中导入数据的几种方式 直接向表中插入数据 insertintotableAvalues(1,'zhangsan',88),(2,'lisi',61); 这种方式每次插入时都会产生一个文件，多次插入少量数据就会出现多个小文件，但是这种方式生产环境很少使用，可以说基本没有使用的 通过load方式加载数据 loaddatalocalinpath'/export/sco...
Hive企业级调优：Fetch抓取与性能优化实践
在`hive-default.xml.template`文件中，可以通过调整`hive.fetch.task.conversion`的值来控制这一行为。将其设为`more`，能进一步扩大优化范围，包括全局查找、字段查找和LIMIT操作等。但需要注意，某些复杂的查询，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值