hive join vs mapjoin 的原理对比

最新推荐文章于 2022-03-21 17:15:33 发布
最新推荐文章于 2022-03-21 17:15:33 发布
阅读量1.2k 收藏 7
点赞数
分类专栏： 大数据 hive hadoop hive
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35744460/article/details/89401536
版权
大数据 同时被 3 个专栏收录
45 篇文章 0 订阅
订阅专栏
hive
18 篇文章 0 订阅
订阅专栏
hive
16 篇文章 0 订阅
订阅专栏

hive join vs mapjoin 的原理对比

join

例如下面一个普通join的sql语句

select u.id,d.name from user u join dept d on u.detp_id=d.dept_id;
  • 中间的过程
  1. 2个map分别处理 user ,dept ，得到关联条件的key 以及<flag,value> ,通过falg区分2个表
  2. shuffle 把key相同的拉到一起给reduce作业
  3. reduce 这个阶段逻辑复杂需要先将vale中的数据迭代遍历，根据flag区分2个表，得到 一个deptinfo，一个userList，
    再次遍历userList 把dept Set 进去得到结果集
  4. out到磁盘
  • 示例图
    普通join图解

mapjoin

  1. 通过MapReduce Local Task，将小表读入内存，生成HashTableFiles上传至Distributed Cache中，这里会对HashTableFiles进行压缩。

  2. MapReduce Job在Map阶段，每个Mapper从Distributed Cache读取HashTableFiles到内存中，顺序扫描大表，在Map阶段直接进行Join，将数据传递给下一个MapReduce任务。
    mapjoin图例

  • 准备测试数据
    创建 user表
    hive> create table  user(uid string,username string,dept_id string); 
    创建的dept表
    hive> create table  dept(dept_id string,deptname string); 
    向里面插入数据
    hive> select * from user;
    OK
    1	aaa	1001
    2	bbb	1001
    3	ccc	1002
    4	ccc	1002
    5	eee	1003
    
    hive> select * from dept;
    OK
    1001	ppp
    1002	lll
    1003	mmm
  • 默认是ture 会开启小表mapjoin
    hive> set hive.auto.convert.join;
    
    hive.auto.convert.join=true


hive> select u.uid,u.username,d.dept_id,d.deptname from user u join dept d on u.dept_id=d.dept_id;
Query ID = root_20190419143939_7e240803-dad1-4484-8ad1-96e8bea08c14
Total jobs = 1
Java HotSpot(TM) 64-Bit Server VM warning: ignoring option MaxPermSize=512M; support was removed in 8.0
Execution log at: /tmp/root/root_20190419143939_7e240803-dad1-4484-8ad1-96e8bea08c14.log
==================开启MapReduce Local Task======================================
2019-04-19 02:39:19	Starting to launch local task to process map join;	maximum memory = 1908932608 
============将小表读入内存，生成HashTableFiles====================================
2019-04-19 02:39:20	Dump the side-table for tag: 1 with group count: 3 into file: file:/tmp/root/b2027549-5ad1-4224-adca-a3a50c579791/hive_2019-04-19_14-39-15_636_1590766828359575157-1/-local-10003/HashTable-Stage-3/MapJoin-mapfile01--.hashtable
============将生成的HashTableFiles上传至Distributed Cache中==========================
2019-04-19 02:39:20	Uploaded 1 File to: file:/tmp/root/b2027549-5ad1-4224-adca-a3a50c579791/hive_2019-04-19_14-39-15_636_1590766828359575157-1/-local-10003/HashTable-Stage-3/MapJoin-mapfile01--.hashtable (341 bytes)
2019-04-19 02:39:20	End of local task; Time Taken: 1.236 sec.
=============MapReduce Local Task成功===========================
Execution completed successfully
MapredLocal task succeeded
Launching Job 1 out of 1
Number of reduce tasks is set to 0 since there's no reduce operator
Starting Job = job_1555297938886_0129, Tracking URL = http://spark001:8088/proxy/application_1555297938886_0129/
Kill Command = /opt/cloudera/parcels/CDH-5.13.1-1.cdh5.13.1.p0.2/lib/hadoop/bin/hadoop job  -kill job_1555297938886_0129
==================只有一个map没有reduce跟shuffle==================
Hadoop job information for Stage-3: number of mappers: 1; number of reducers: 0
2019-04-19 14:39:30,393 Stage-3 map = 0%,  reduce = 0%
2019-04-19 14:39:36,600 Stage-3 map = 100%,  reduce = 0%, Cumulative CPU 3.28 sec
MapReduce Total cumulative CPU time: 3 seconds 280 msec
Ended Job = job_1555297938886_0129
MapReduce Jobs Launched: 
Stage-Stage-3: Map: 1   Cumulative CPU: 3.28 sec   HDFS Read: 6793 HDFS Write: 75 SUCCESS
Total MapReduce CPU Time Spent: 3 seconds 280 msec
OK
1	aaa	1001	ppp
2	bbb	1001	ppp
3	ccc	1002	lll
4	ccc	1002	lll
5	eee	1003	mmm
Time taken: 23.169 seconds, Fetched: 5 row(s)
  • explian查看执行计划
hive> explain  select u.uid,u.username,d.dept_id,d.deptname from user u join dept d on u.dept_id=d.dept_id;
OK
==================生成了3个stage======================
STAGE DEPENDENCIES:
  Stage-4 is a root stage
  Stage-3 depends on stages: Stage-4
  Stage-0 depends on stages: Stage-3

STAGE PLANS:
  Stage: Stage-4
    Map Reduce Local Work
      Alias -> Map Local Tables:
        d 
          Fetch Operator
            limit: -1
      Alias -> Map Local Operator Tree:
        d 
          TableScan
            alias: d
            Statistics: Num rows: 3 Data size: 24 Basic stats: COMPLETE Column stats: NONE
            Filter Operator
              predicate: dept_id is not null (type: boolean)
              Statistics: Num rows: 2 Data size: 16 Basic stats: COMPLETE Column stats: NONE
              HashTable Sink Operator
                keys:
                  0 dept_id (type: string)
                  1 dept_id (type: string)

  Stage: Stage-3
    Map Reduce
      Map Operator Tree:
          TableScan
            alias: u
            Statistics: Num rows: 5 Data size: 50 Basic stats: COMPLETE Column stats: NONE
            Filter Operator
              predicate: dept_id is not null (type: boolean)
              Statistics: Num rows: 3 Data size: 30 Basic stats: COMPLETE Column stats: NONE
              Map Join Operator
                condition map:
                     Inner Join 0 to 1
                keys:
                  0 dept_id (type: string)
                  1 dept_id (type: string)
                outputColumnNames: _col0, _col1, _col6, _col7
                Statistics: Num rows: 3 Data size: 33 Basic stats: COMPLETE Column stats: NONE
                Select Operator
                  expressions: _col0 (type: string), _col1 (type: string), _col6 (type: string), _col7 (type: string)
                  outputColumnNames: _col0, _col1, _col2, _col3
                  Statistics: Num rows: 3 Data size: 33 Basic stats: COMPLETE Column stats: NONE
                  File Output Operator
                    compressed: false
                    Statistics: Num rows: 3 Data size: 33 Basic stats: COMPLETE Column stats: NONE
                    table:
                        input format: org.apache.hadoop.mapred.TextInputFormat
                        output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat
                        serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe
      Local Work:
        Map Reduce Local Work

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

Time taken: 0.163 seconds, Fetched: 62 row(s)
  • 关闭自动mapjoin
hive> set hive.auto.convert.join=false;
hive> explain  select u.uid,u.username,d.dept_id,d.deptname from user u join dept d on u.dept_id=d.dept_id;
OK
================生成2个stage===========
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: u
            Statistics: Num rows: 5 Data size: 50 Basic stats: COMPLETE Column stats: NONE
            Filter Operator
              predicate: dept_id is not null (type: boolean)
              Statistics: Num rows: 3 Data size: 30 Basic stats: COMPLETE Column stats: NONE
              Reduce Output Operator
                key expressions: dept_id (type: string)
                sort order: +
                Map-reduce partition columns: dept_id (type: string)
                Statistics: Num rows: 3 Data size: 30 Basic stats: COMPLETE Column stats: NONE
                value expressions: uid (type: string), username (type: string)
          TableScan
            alias: d
            Statistics: Num rows: 3 Data size: 24 Basic stats: COMPLETE Column stats: NONE
            Filter Operator
              predicate: dept_id is not null (type: boolean)
              Statistics: Num rows: 2 Data size: 16 Basic stats: COMPLETE Column stats: NONE
              Reduce Output Operator
                key expressions: dept_id (type: string)
                sort order: +
                Map-reduce partition columns: dept_id (type: string)
                Statistics: Num rows: 2 Data size: 16 Basic stats: COMPLETE Column stats: NONE
                value expressions: deptname (type: string)
      Reduce Operator Tree:
        Join Operator
          condition map:
               Inner Join 0 to 1
          keys:
            0 dept_id (type: string)
            1 dept_id (type: string)
          outputColumnNames: _col0, _col1, _col6, _col7
          Statistics: Num rows: 3 Data size: 33 Basic stats: COMPLETE Column stats: NONE
          Select Operator
            expressions: _col0 (type: string), _col1 (type: string), _col6 (type: string), _col7 (type: string)
            outputColumnNames: _col0, _col1, _col2, _col3
            Statistics: Num rows: 3 Data size: 33 Basic stats: COMPLETE Column stats: NONE
            File Output Operator
              compressed: false
              Statistics: Num rows: 3 Data size: 33 Basic stats: COMPLETE Column stats: NONE
              table:
                  input format: org.apache.hadoop.mapred.TextInputFormat
                  output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat
                  serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe

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

Time taken: 0.09 seconds, Fetched: 59 row(s)

hive> select u.uid,u.username,d.dept_id,d.deptname from user u join dept d on u.dept_id=d.dept_id;
Query ID = root_20190419144444_04313ede-8844-4670-89f8-5a8134ebd282
Total jobs = 1
Launching Job 1 out of 1
Number of reduce tasks not specified. Estimated from input data size: 1
In order to change the average load for a reducer (in bytes):
  set hive.exec.reducers.bytes.per.reducer=<number>
In order to limit the maximum number of reducers:
  set hive.exec.reducers.max=<number>
In order to set a constant number of reducers:
  set mapreduce.job.reduces=<number>
Starting Job = job_1555297938886_0130, Tracking URL = http://spark001:8088/proxy/application_1555297938886_0130/
Kill Command = /opt/cloudera/parcels/CDH-5.13.1-1.cdh5.13.1.p0.2/lib/hadoop/bin/hadoop job  -kill job_1555297938886_0130
===================2个map 1 个reduce======================
Hadoop job information for Stage-1: number of mappers: 2; number of reducers: 1
2019-04-19 14:44:39,720 Stage-1 map = 0%,  reduce = 0%
2019-04-19 14:44:45,992 Stage-1 map = 100%,  reduce = 0%, Cumulative CPU 5.92 sec
2019-04-19 14:44:51,152 Stage-1 map = 100%,  reduce = 100%, Cumulative CPU 8.64 sec
MapReduce Total cumulative CPU time: 8 seconds 640 msec
Ended Job = job_1555297938886_0130
MapReduce Jobs Launched: 
Stage-Stage-1: Map: 2  Reduce: 1   Cumulative CPU: 8.64 sec   HDFS Read: 14732 HDFS Write: 75 SUCCESS
Total MapReduce CPU Time Spent: 8 seconds 640 msec
OK
2	bbb	1001	ppp
1	aaa	1001	ppp
4	ccc	1002	lll
3	ccc	1002	lll
5	eee	1003	mmm
Time taken: 21.517 seconds, Fetched: 5 row(s)
  • 总结
  1. mapjoin 可以看做 boardcast join 就是将小表的数据加载到内存中并且没有shuffle过程，加快处理效率
    但是这样如果数据量过大，加载到内存有可能会引起OOM
  2. 普通join 会产生shuffle，会影响效率（数据传输）；也可能差生数据倾斜（一个key太多，那任务处理就会很慢）
潇洒-人生
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
大表join小表，独钟爱mapjoin
我的祖传代码
09-22 1761
在Hive调优里面，经常会问到一个很小的表和一个大表进行join，如何优化。 ​ Shuffle 阶段代价非常昂贵，因为它需要排序和合并。减少 Shuffle 和 Reduce 阶段的代价可以提高任务性能。 MapJoin通常用于一个很小的表和一个大表进行join的场景，具体小表有多小，由参数hive.mapjoin.smalltable.filesize来决定，该参数表示小表的总大小，默认值为25000000字节，即25M。 Hive0.7...
Hive Map Join 原理
hellojoy的博客
01-27 517
https://cloud.tencent.com/developer/article/1481780 1. Join如何运行 首先，让我们讨论一下 Join 如何在Hive中运行。Common Join 操作如图1所示被编译为 MapReduce 任务。Common Join 任务涉及 Map 阶段和 Reduce 阶段。Mapper 从连接表中读取数据并将连接的 key 和连接的 value 键值对输出到中间文件中。Hadoop 在所谓的 shuffle 阶段对这些键值对进行排序和合并。Reduce
hive的map join原理
窗外的屋檐
03-28 5910
什么是MapJoin? MapJoin顾名思义，就是在Map阶段进行表之间的连接。而不需要进入到Reduce阶段才进行连接。这样就节省了在Shuffle阶段时要进行的大量数据传输。从而起到了优化作业的作用。 MapJoin的原理： 即在map 端进行join，其原理是broadcast join，即把小表作为一个完整的驱动表来进行join操作。通常情况下，要连接的各个表里面的数据会分布...
hive mapjoin 原理
xuehuagongzi000的博客
05-21 2274
1、什么是MapJoin? MapJoin顾名思义，就是在Map阶段进行表之间的连接。而不需要进入到Reduce阶段才进行连接。这样就节省了在Shuffle阶段时要进行的大量数据传输。从而起到了优化作业的作用。 2、MapJoin的原理： 即在map 端进行join，其原理是broadcast join，即把小表作为一个完整的驱动表来进行join操作。通常情况下，要连接的各个表里面的数据会...
hive的mapjoin原理
wj1298250240的博客
03-03 558
什么是MapJoin? MapJoin顾名思义，就是在Map阶段进行表之间的连接。而不需要进入到Reduce阶段才进行连接。这样就节省了在Shuffle阶段时要进行的大量数据传输。从而起到了优化作业的作用。 MapJoin的原理： 省去了reduce操作 即在map 端进行join，其原理是broadcast join，即把小表作为一个完整的驱动表来进行join操作。通常情况下，要连接的各个表里面...
hive中mapjoin原理
qq_39128254的博客
02-24 505
https://blog.csdn.net/u012369535/article/details/89715477 笼统的说，Hive中的Join可分为Common Join（Reduce阶段完成join）和Map Join（Map阶段完成join） 一、Hive Common Join 如果不指定MapJoin或者不符合MapJoin的条件，那么Hive解析器会将Join操作转换成Common Join,即：在Reduce阶段完成join. 整个过程包含Map、Shuffle、Reduce阶段。 Map
hive sql + left join 数据缺失
最新发布
02-29
hive sql + left join 数据缺失
hive 中join和Group的优化
01-07
set hive.map.aggr = true; //是否在 Map 端进行聚合，默认为 True ；该设置会消耗更多的内存。 set hive.groupby.mapaggr.checkinterval = 100000000; //在 Map 端进行聚合操作的条目数目 set hive.groupby....
Hive原理分析
02-24
在开始了解hive之前，需要了解一些知识或者概念，可以更好的理解hive实现原理GoogleMapReduce是Google基于函数式编程map（映射），reduce（化简）提出的一种分布式编程模型，在模型中隐藏了分布式集群的实现细节，交...
Hive Summit 2011-join
05-29
facebook hive中的各种join策略的slides，reporter是个Chinese。
Hive技术原理
02-24
Hive是一个构建于Hadoop顶层的数据仓库工具，可以查询和管理PB级别的分布式数据。支持大规模数据存储、分析，具有良好的可扩展性某种程度上可以看作是用户编程接口，本身不存储和处理数据。依赖分布式文件系统HDFS...
Hive的mapjoin原理与参数说明
xiaozhaoshigedasb的博客
04-01 5632
一、 Map Join原理 Map Join介绍 MapJoin顾名思义，就是在Map阶段进行表之间的连接，map阶段直接拿另外一个表的数据和内存中表数据做匹配。而不需要进入到Reduce阶段才进行连接。这样就节省了在Shuffle阶段时要进行的大量数据传输。从而起到了优化作业的作用。通常用于一个很小的表和一个大表进行join的场景。 MapJoin的原理及过程 执行过程如上图： 首先是在...
Hive调优策略——Fetch抓取 & 表的各种优化策略（mapjoin原理）
follweme888的专栏
06-25 292
总结一下工作中常用的hive调优策略 目录 1. Fetch抓取 2. 小表Join大表（mapjoin的原理） 3. 大表Join大表 （0）前提：配置历史服务器 （1）空key过滤 （2）空key转换（将空值key转换为其他随机数，避免数据倾斜） 4. Group By发生数据倾斜 5. Coun...
Hive中原理及使用MAP JOIN
cqra94148的博客
01-11 468
Hive中简介及使用MAP JOIN Hive中的Join可分为Common Join（Reduce阶段完成join）和Map Join（Map阶段完成join）。本文简单介绍一下mapjoin的原理和机...
MapJoin原理
persuit的专栏
05-19 5270
MapJoin原理 MapJoin简单说就是在Map阶段将小表读入内存，顺序扫描大表完成Join。 上图是Hive MapJoin的原理图，出自Facebook工程师Liyin Tang的一篇介绍Join优化的slice，从图中可以看出MapJoin分为两个阶段： 通过MapReduce Local Task，将小表读入内存，生成HashTableFiles上传至
HIve map jion的原理、操作和使用场景
qq_43688472的博客
01-08 581
一：hive mapjion的使用场景： 1.关联操作中有一张表非常小（有严重的数据倾斜） 2.不等值的链接操作 Join有多个关联键，则以这些关联键的组合作为key；Map输出的value为join之后所关心的(select或者where中需要用到的)列 二：原理 Hive Map Join MapJoin通常用于一个很小的表和一个大表进行join的场景，具体小表有多小，由参数hive.mapj...
map端 join算法实现
热门推荐
tian_1_2_3的博客
12-02 1万+
1、原理阐述 适用于关联表中有小表的情形； 可以将小表分发到所有的map节点，这样，map节点就可以在本地对自己所读到的大表数据进行join并输出最终结果，可以大大提高join操作的并发度，加快处理速度 2、实现示例 –先在mapper类中预先定义好小表，进行join –引入实际场景中的解决方案：一次加载数据库或者用 第一步：定义mapJoin public class Map extends Mapper<LongWritable, Text,Text,Text> { HashMap.
MapJoin的原理及案例
影子
03-21 3567
mapJoin原理：适用于大表join小表，使用DistributedCache机制将小表存储到各个Mapper进程所在机器的磁盘空间上，各个Mapper进程读取不同的大表分片，将分片中的每一条记录与小表中所有记录进行合并 合并后直接输出map结果即可得到最终结果。 注：不需要进行shuffle流程，也不需要reduce处理 案列： detail.txt order_id item_id amout 12 sp001 2 12 sp002 4 12 ...
Hive中MapJoin的原理和机制
ych0112xzz的博客
07-24 8508
笼统的说，Hive中的Join可分为Common Join（Reduce阶段完成join）和Map Join（Map阶段完成join）。本文简单介绍一下两种join的原理和机制。 1 Hive Common Join 如果不指定MapJoin或者不符合MapJoin的条件，那么Hive解析器会将Join操作转换成Common Join,即：在Reduce阶段完成join. 整个过程包含Ma...
hive mapjoin
02-08
Hive的mapjoin和reduce side join之间的区别在于它们的实现方式。Mapjoin是一种在Map阶段完成的join，它只需要加载小表，然后在Map任务中进行join，因此它速度更快，但是需要保证小表数据量不会很大，否则会导致内存...

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

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值