hive大小文件合并

hive -e “set tez.queue.name=usershell; 启用哪个队列
set hive.execution.engine=tez; 启用引擎
set hive.merge.tezfiles=true; 开启合并
set hive.merge.smallfiles.avgsize=16000000; 文件合并标准(低于16000000kb进行合并)
set hive.merge.size.per.task=128000000;文件合并大小(最终文件大于128000000后,停止合并,合并到另一个文件)
insert into table hot_words_view.vvv4_hot_words_new_two partition (domain_id, import_date)
select a.hot_words hot_words,a.rank rank_one,a.leng1 leng,a.total total1,b.total total2,a.mysql_id mysql_id,b.hot_words two_word,b.rank rank_two
,a.domain_id domain_id,a.import_date import_date
from (select import_date,domain_id,hot_words,collect_set(search_word)[0] search_word,number,
collect_set(leng)[0] leng1,mysql_id,collect_set(rank)[0] rank,count(1) total
from hot_words_view.vvv4_hot_words_new where leng =2 and domain_id=’$1’ and import_date=’$2’
group by import_date,domain_id,hot_words,number,mysql_id) a
left join
(select import_date,domain_id,hot_words,collect_set(search_word)[0] search_word,number,
mysql_id,collect_set(rank)[0] rank,count(1) total
from hot_words_view.vvv4_hot_words_new where leng >=2 and domain_id=’$1’ and import_date=’$2’ group by import_date,domain_id,hot_words,number,mysql_id) b
on a.number=b.number and a.import_date=b.import_date and a.domain_id=b.domain_id
where a.total <= b.total;”;

hive

1 合并小文件
set hive.merge.mapfile=true;
set hive.merge.mapredfile=true;
set hive.merge.size.pertask=32000…
set hive.merge.smallfiles.avsize=12…
2 压缩文件(结果压缩)
set hive.exec.compression.output=true;
set mapred.output.compression.codec=org.apache.hadoop.io.compress.Gzipcode;
set mapred.output.compression.type=block;
***3***中间压缩
set hive.exec.compress.intermediate=true;
set hive.intermediate.compression.code=org.apache.hadoop.io.compress.snappycodec;
set hive.intermediate.compression.type=block;
***4***动态分区(默认情况下,在 Hive 0.9.0 之前禁用动态分区插入,并在 Hive 0.9.0及更高版本中默认启用。这些是动态分区插入的相关配置属性:)
set hive.mapred.mode=nonstrict;
set hive.exec.dynamic.partition.mode=nonstrict;
set hive.exec.max.dynamic.partition.pernode=10000(默认100)
***5***group by 导致数据倾斜
set hive.groupby.skewindate=true;
6 自动mapjoin
set hive.auto.convert.join=true;
***7***自行本地运行(单节点运行)版本后Hive开始支持任务执行选择本地模式(local mode)。大多数的Hadoop job是需要hadoop提供的完整的可扩展性来处理大数据的。不过,有时hive的输入数据量是非常小的。在这种情况下,为查询出发执行任务的时间消耗可能会比实际job的执行时间要多的多。对于大多数这种情况,hive可以通过本地模式在单台机器上处理所有的任务。对于小数据集,执行时间会明显被缩短。
hive> set hive.exec.mode.local.auto=true;(默认为false);
hive.exec.mode.local.auto.inputbytes.max=134,217,728(默认128MB);
hive.exec.mode.local.auto.tasks.max=2(默认4);
当一个job满足如下条件才能真正使用本地模式:
1.job的输入数据大小必须小于参数2.job的map数必须小于参数3.job的reduce数必须为0或者1;
***8***对reduce个数限定
set mapred.reduce.tasks=-1;
set hive.exec.reduces.bytes.per.reduce=1000…(默认1000M);
set hive.exec.reduces.max=999(默认);
***9***控制reduce个数
set mapred.reduce.tasks=15;
***10***配置map输入合并
set hive.input.format=org.apache.hadoop.hive.ql.io.combineHiveInputFormate;(执行map前小文件合并)
set hive.merge.mapfiles=true; (在map only任务结束时合并小文件)
set hive.merge.mapredfiles=false;(为true时在mapreduce任务结束时合并小文件)
set hive.merge.size.per.task=25600000;(合并文件大小)
set mapred.max.split.size=25600;(每个map最大分割大小)
set mepred.min.split.size.per.node=1;(一个节点上split最小值)
***11***设置引擎
set hive.execution.engine=mr;
set hive.execution.engine=spark;
set hive.execution.engine=tez;
***12***队列
set mapred.queue.names=;
set mapreduce.job.queuename=etl;(使用原生mapreduce)
***13***输入小文件合并
set mapred.max.split.size=256000000;(每个map处理的最大输入文件大小256M)
set mapred.min.split.size.per.node=10000;(一个节点上split文件最小值)
set mapred.min.split.size.per.rack=1000;(一个交换机下split文件最小值)
set hive.input.format=org.apache.hadoop.hive.ql.io.combineHiveInputformat;(在开启format后,一个date node节点上多个小文件进行合并,合并文件数由mapred.max.split.size限制的大小决定)

tez

***1***使用tez队列
set tez.queue.name=user;
***2***大小文件合并
set tez.queue.name=usershell; 启用哪个队列
set hive.execution.engine=tez; 启用引擎
set hive.merge.tezfiles=true; 开启合并
set hive.merge.smallfiles.avgsize=16000000; 文件合并标准(低于16000000kb进行合并)
set hive.merge.size.per.task=128000000;文件合并大小(最终文件大于128000000后,停止合并,合并到另一个文件)

Hive的优化
1、fetch抓取:修改配置文件hive.fetch.task.conversion为more,修改好全局查找和字段查找以及limit都不会触发MR任务。

2、本地模式:大多数的Hadoop Job要求Hadoop提供完整的可扩展性来触发大数据集,不过有时候hive的输入数据量非常的小,这样的情况下可能触发任务的事件比执行的事件还长,我们就可以通过本地模式把小量的数据放到本地上面计算。

3、Group by:默认情况下,map阶段同一key的数据会发给一个reduce,当一个key数据过大就会倾斜,并不是所有的聚合操作都需要reduce端完成,很多聚合操作都可以现在map端进行部分聚合,最后在reduce端得出最终结果。(1)、开启在map端聚合:hive.map.aggr = true。(2)、在map端进行聚合操作的条目数:hive.groupby.mapaggr.checkinterval = 100000。(3)、有数据倾斜的时候进行负载均衡:hive.groupby.skewindata = true。

4、count dinstinc去重:大的数据集先用count distinct查找重复的字段,然后用group by再去重。

5、行列过滤:列处理:只拿自己需要的列,如果有,尽量使用分区过滤。行处理:在分区裁剪的时候,当使用外关联的时候,先完全关联再过滤。

6、动态分区调整:(1)、开启动态分区:hive.exec.dynamic.partition=true。(2)、设置为非严格模式:hive.exec.dynamic.partiton.mode = nostrict。(3)、实操:创建分区表、加载数据到分区表中、创建目标分区、设置动态分区、查看目标分区表的分区情况。

7、小文件进行合并:在map执行之前合并小文件,减少map的数量,设置 set hive.input.format = org.apache.hadoop.hive.ql.io.CombineHiveInputFormat。

8、调整map的数量和reduce的数量。

9、并行执行:在Hive中可能有很多个阶段,不一定是一个阶段,这些阶段并非相互依赖的。然后这些阶段可以并行完成,设置并行:set hive.exec.parallel = true。

10、JVM的重用,缺点是task槽会被占用,一直要等到任务完成才会释放。

大数据-Hive配置参数知多少
任务相关
1.set mapred.job.name=my_job_20180405; // 设置任务名字
2.set mapred.job.queue.name=队列名称; // 设置使用队列
3.set mapred.job.priority=VERY_HIGH; // 设置任务优先级
启用压缩
1.set mapred.output.compress=true; // 启用压缩
2.set hive.exec.compress.output=true; // 输出压缩
3.set mapred.output.compression.codec=org.apache.hadoop.io.compress.GzipCodec; // 压缩格式
4.set mapred.output.compression.type=BLOCK; // 压缩类型
支持的压缩方式:
org.apache.hadoop.io.compress.GzipCodec
org.apache.hadoop.io.compress.SnappyCodec
com.hadoop.compression.lzo.LzopCodec
org.apache.hadoop.io.compress.Lz4Codec
mapreduce内存配置
1.set mapreduce.map.memory.mb=2048; // map可用的最大内存
2.set mapreduce.reduce.memory.mb=2048; // reduce可用最大内存
reduce相关配置
1.set mapred.reduce.tasks=-1 ; // 强制设置Reduce的个数,-1为默认,表示由hive自动分配管理
2.set hive.exec.reducers.max=100; // 设置reducer个数的上限
3.set hive.exec.reducers.bytes.per.reducer = 1000000000; // 也就是每个节点的reduce 默认是处理1G大小的数据
计算reducer数的公式
N=min( hive.exec.reducers.max ,总输入数据量/ hive.exec.reducers.bytes.per.reducer )
输入小文件合并
1.set mapred.max.split.size = 256000000; // map最大的输入大小
2.set mapred.min.split.size=1 ; // 最小分割
3.set mapred.min.split.size.per.node=300; // 一个节点上split的最小大小,这个值决定了多个datanode上文件是否需要合并
4.set mapred.min.split.size.per.rack=100; // 一个交换机下split的最小大小,这个值决定了过个交互及上的文件是否需要合并
5.set hive.input.format=org.apache.hadoop.hive.ql.io.CombineHiveInputFormat; //Map端输入、合并文件之后按照block的大小分割(默认)
输入小文件合并可以减小map的个数
hive.input.format设置:
org.apache.hadoop.hive.ql.io.CombineHiveInputFormat; //Map端输入、合并文件之后按照block的大小分割(默认)
org.apache.hadoop.hive.ql.io.HiveInputFormat; //Map端输入,不合并 一个文件起一个Map
新版本配置
1.set mapreduce.input.fileinputformat.split.minsize=134217728
2.set mapreduce.input.fileinputformat.split.maxsize=134217728;
3.set mapreduce.input.fileinputformat.split.minsize.per.node=134217728;
4.set mapreduce.input.fileinputformat.split.minsize.per.rack=134217728;
输出小文件合并
1.set hive.merge.mapfiles=true; // 是否开启合并 Map 端输出小文件
2.set hive.merge.mapredfiles=true; // 是否开启合并 Map/Reduce 端输出小文件
3.set hive.merge.size.per.task=268435456; // 合并文件大小
4.set hive.merge.smallfiles.avgsize=16000000; // 当输出文件的平均大小小于该值时,启动一个独立的map-reduce任务进行文件merge
并行计算参数
1.set hive.exec.parallel=true; // 无关的计算可以并行调起JOB
2.set hive.exec.parallel.thread.number=8 ; // 并发提交时的并发线程的个数
map聚合
1.set hive.map.aggr=true; // 是否在map端进行聚合,默认为true
2.set hive.groupby.mapaggr.checkinterval=100000; // 在map端聚合操作记录的数目
Group By相关
1.set hive.optimize.groupby=true; // 是否优化group by。默认true
2.set hive.groupby.skewindata=false ; // 决定 group by 操作是否支持倾斜的数据。只能对单个字段聚合
分区相关
1.set hive.exec.dynamic.partition = false ; // 是否打开动态分区,默认false
2.set hive.exec.dynamic.partition.mode = strict; // 打开动态分区后,动态分区的模式,有 strict 和 nonstrict 两个值可选,strict 要求至少包含一个静态分区列,nonstrict 则无此要求。
3.set hive.exec.max.dynamic.partitions = 1000; // 所允许的最大的动态分区的个数。
4.set hive.exec.max.dynamic.partitions.pernode = 100; // 单个reduce结点所允许的最大的动态分区的个数。
5.set hive.exec.default.partition.name = ‘HIVE_DEFAULT_PARTITION’; //默认的动态分区的名称,当动态分区列为’'或者null时,使用此名称。
本地模式相关
1.set hive.exec.mode.local.auto=true; // 决定hive是否应该自动的根据输入文件大小,在本地运行
2.set hive.exec.mode.local.auto.inputbytes.max=134217728; // 当输入文件大小小于词阈值的时可以自动在本地模式运行,默认128M。
3.set hive.exec.mode.local.auto.tasks.max=4; // 当任务数小于此阈值时,可以自动在本地模式运行
4.set hive.mapred.local.mem=0; // 本地模式启动JVM内存大小
Strict Mode
1.set hive.mapred.mode = strict; // 严格模式
2.set hive.mapred.mode = nostrict; // 非严格模式
严格模式不允许执行以下操作:
分区表没有指定分区
没有limit限制的order by
笛卡尔积join时没有on语句

Map-Side Join
1.set hive.auto.convert.join = true ; // 是否根据输入小表的大小,自动将reduce端的common join 转化为map join,将小表刷入内存中。
2.set hive.mapjoin.smalltable.filesize = 2500000 ; // 刷入内存表的大小(字节)
3.set hive.mapjoin.maxsize=1000000; // Map Join所处理的最大的行数。超过此行数,Map Join进程会异常退出
Map Join 的计算步骤分两步,将小表的数据变成hashtable广播到所有的map 端,将大表的数据进行合理的切分,然后在map 阶段的时候用大表的数据一行一行的去探测(probe) 小表的hashtable. 如果join key 相等,就写入HDFS.
map join 之所以叫做map join 是因为它所有的工作都在map 端进行计算.
hive 在map join 上做了几个优化: hive 0.6 的时候默认认为写在select 后面的是大表,前面的是小表, 或者使用 /*+mapjoin(map_table) */ 提示进行设定. hive 0.7 的时候这个计算是自动化的,它首先会自动判断哪个是小表,哪个是大表,这个参数由(hive.auto.convert.join=true)来控制. 然后控制小表的大小由(hive.smalltable.filesize=25000000L)参数控制(默认是25M),当小表超过这个大小,hive 会默认转化成common join. 你可以查看HIVE-1642.首先小表的Map 阶段它会将自己转化成MapReduce Local Task ,然后从HDFS 取小表的所有数据,将自己转化成Hashtable file 并压缩打包放入DistributedCache 里面. 目前hive 的map join 有几个限制,一个是它打算用BloomFilter 来实现hashtable , BloomFilter 大概比hashtable 省8-10倍的内存, 但是BloomFilter 的大小比较难控制. 现在DistributedCache 里面hashtable默认的复制是3份,对于一个有1000个map 的大表来说,这个数字太小,大多数map 操作都等着DistributedCache 复制.
Skew Join
1.set hive.exec.reducers.bytes.per.reducer = 1000000000; // 也就是每个节点的reduce 默认是处理1G大小的数据
2.set hive.optimize.skewjoin = true; // 是否优化数据倾斜的join,对于倾斜的join会开启新的MR job处理,默认false
3.set hive.skewjoin.key=100000; // 倾斜数目阈值,超过此值则判定为一个倾斜的Join查询,默认100000。
4.set hive.skewjoin.mapjoin.map.tasks=10000; // 处理数据倾斜的Map join的Map数上限
5.set hive.skewjoin.mapjoin.min.split=33554432; // 处理数据倾斜Map Join的最小数据切分大小,以字节为单位,默认32M。
hive 在运行的时候没有办法判断哪个key 会产生多大的倾斜,所以使用这个参数控制倾斜的阈值,如果超过这个值,新的值会发送给那些还没有达到的reduce, 一般可以设置成你(处理的总记录数/reduce个数)的2-4倍都可以接受.
倾斜是经常会存在的,一般select 的层数超过2层,翻译成执行计划多于3个以上的mapreduce job 都很容易产生倾斜,建议每次运行比较复杂的sql 之前都可以设一下这个参数. 如果你不知道设置多少,可以就按官方默认的1个reduce 只处理1G 的算法,那么 skewkeythreshold = 1G/平均行长. 或者默认直接设成250000000 (差不多算平均行长4个字节)
推测执行
1.set mapred.map.tasks.speculative.execution=true;
2.set mapred.reduce.tasks.speculative.execution=true;
3.set hive.mapred.reduce.tasks.speculative.execution=true;
推测执行(Speculative Execution)是指在集群环境下运行MapReduce,可能是程序Bug,负载不均或者其他的一些问题,导致在一个JOB下的多个TASK速度不一致,比如有的任务已经完成,但是有些任务可能只跑了10%,根据木桶原理,这些任务将成为整个JOB的短板,如果集群启动了推测执行,这时为了最大限度的提高短板,Hadoop会为该task启动备份任务,让speculative task与原始task同时处理一份数据,哪个先运行完,则将谁的结果作为最终结果,并且在运行完成后Kill掉另外一个任务。
推测执行的目的是减少作业执行时间,但这是以集群效率为代价的,在一个繁忙的集群中,推测执行会减少整体的吞吐量,因为冗余的任务执行时会减少作业的执行时间,因此一些集群管理员倾向于在集群上关闭这个选项,而让用户根据个别的作业需要而开启该功能。
不建议开启推测执行机制的场景:
Task之间存在固有的不均衡特点,比如有的Reduce Task处理的数据量远大于其他几个
不允许一个任务存在多个实例,比如将MapReduce结果写到Mysql数据库中,不允许一条数据写多分产生冗余
hive使用spark引擎
1.set spark.master=yarn;
2.set hive.execution.engine=spark;
3.set spark.serializer=org.apache.spark.serializer.KryoSerializer;
4.set spark.executor.memory=5g;
5.set spark.executor.cores=4;
6.set spark.executor.instances=10;
其他
1.set hive.optimize.cp=true; // 列裁剪
2.set hive.optimize.prunner; // 分区裁剪
3.set hive.limit.optimize.enable=true; // 优化LIMIT n语句
4.set hive.limit.row.max.size=1000000;
5.set hive.limit.optimize.limit.file=10; // 最大文件数

hive执行计划查看
explain extended:查看最详细的内容
explain dependency :查看依赖关系
explain authorization :查看权限

hive 查找函数并查看函数使用方法

  1. 查看month 相关的函数
    show functions like ‘month
    输出如下:
    add_months
    dayofmonth
    month
    months_between
    2.查看 add_months 函数的用法
    desc function add_months;
    add_months(start_date, num_months) - Returns the date that is num_months after start_date.
  2. 查看 add_months 函数的详细说明并举例
    desc function extended add_months;
    SELECT add_months(‘2009-08-31’, 1) FROM src LIMIT 1;
    ‘2009-09-30’;
参与评论 您还未登录,请先 登录 后发表或查看评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
©️2022 CSDN 皮肤主题:游动-白 设计师:我叫白小胖 返回首页

打赏作者

KANGBboy

你的鼓励将是我创作的最大动力

¥2 ¥4 ¥6 ¥10 ¥20
输入1-500的整数
余额支付 (余额:-- )
扫码支付
扫码支付:¥2
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值