hive map join

最新推荐文章于 2024-05-12 09:00:00 发布
最新推荐文章于 2024-05-12 09:00:00 发布
阅读量254 收藏
点赞数 2
分类专栏： hive 文章标签： hive
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47699191/article/details/119207666
版权

我的hive版本是2.3.1
map join 默认开启

不管大小表放左边还是右边,自动将小表放入内存,然后在map端顺序扫描大表跟内存中的数据进行join

a 大表

user_id  oid
0001,B
0001,A
0002,C
0003,D
0001,E
0001,F
0004,W
0001,Z

b 小表

user_id name
0001,王
0002,刘
0003,赵
0004,高

sql

select
a.user_id,
a.oid,
b.name
from a
join b
on a.user_id=b.user_id

默认开启

set hive.auto.convert.join=true;

执行计划 没有reduce

0: jdbc:hive2://wxt01:10000> explain select
0: jdbc:hive2://wxt01:10000> a.user_id,
0: jdbc:hive2://wxt01:10000> a.oid,
0: jdbc:hive2://wxt01:10000> b.name
0: jdbc:hive2://wxt01:10000> from a
0: jdbc:hive2://wxt01:10000> join b
0: jdbc:hive2://wxt01:10000> on a.user_id=b.user_id;
OK
+-------------------------------------------------------------------------------------------------------+--+
|                                                Explain                                                |
+-------------------------------------------------------------------------------------------------------+--+
| 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:                                                                      |
|         $hdt$_1:b                                                                                     |
|           Fetch Operator                                                                              |
|             limit: -1                                                                                 |
|       Alias -> Map Local Operator Tree:                                                               |
|         $hdt$_1:b                                                                                     |
|           TableScan                                                                                   |
|             alias: b                                                                                  |
|             Statistics: Num rows: 1 Data size: 36 Basic stats: COMPLETE Column stats: NONE            |
|             Filter Operator                                                                           |
|               predicate: user_id is not null (type: boolean)                                          |
|               Statistics: Num rows: 1 Data size: 36 Basic stats: COMPLETE Column stats: NONE          |
|               Select Operator                                                                         |
|                 expressions: user_id (type: string), name (type: string)                              |
|                 outputColumnNames: _col0, _col1                                                       |
|                 Statistics: Num rows: 1 Data size: 36 Basic stats: COMPLETE Column stats: NONE        |
|                 HashTable Sink Operator                                                               |
|                   keys:                                                                               |
|                     0 _col0 (type: string)                                                            |
|                     1 _col0 (type: string)                                                            |
|                                                                                                       |
|   Stage: Stage-3                                                                                      |
|     Map Reduce                                                                                        |
|       Map Operator Tree:                                                                              |
|           TableScan                                                                                   |
|             alias: a                                                                                  |
|             Statistics: Num rows: 1 Data size: 56 Basic stats: COMPLETE Column stats: NONE            |
|             Filter Operator                                                                           |
|               predicate: user_id is not null (type: boolean)                                          |
|               Statistics: Num rows: 1 Data size: 56 Basic stats: COMPLETE Column stats: NONE          |
|               Select Operator                                                                         |
|                 expressions: user_id (type: string), oid (type: string)                               |
|                 outputColumnNames: _col0, _col1                                                       |
|                 Statistics: Num rows: 1 Data size: 56 Basic stats: COMPLETE Column stats: NONE        |
|                 Map Join Operator                                                                     |
|                   condition map:                                                                      |
|                        Inner Join 0 to 1                                                              |
|                   keys:                                                                               |
|                     0 _col0 (type: string)                                                            |
|                     1 _col0 (type: string)                                                            |
|                   outputColumnNames: _col0, _col1, _col3                                              |
|                   Statistics: Num rows: 1 Data size: 61 Basic stats: COMPLETE Column stats: NONE      |
|                   Select Operator                                                                     |
|                     expressions: _col0 (type: string), _col1 (type: string), _col3 (type: string)     |
|                     outputColumnNames: _col0, _col1, _col2                                            |
|                     Statistics: Num rows: 1 Data size: 61 Basic stats: COMPLETE Column stats: NONE    |
|                     File Output Operator                                                              |
|                       compressed: false                                                               |
|                       Statistics: Num rows: 1 Data size: 61 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                   |
|       Local Work:                                                                                     |
|         Map Reduce Local Work                                                                         |
|                                                                                                       |
|   Stage: Stage-0                                                                                      |
|     Fetch Operator                                                                                    |
|       limit: -1                                                                                       |
|       Processor Tree:                                                                                 |
|         ListSink                                                                                      |
|                                                                                                       |
+-------------------------------------------------------------------------------------------------------+--+
70 rows selected (0.241 seconds)

关闭map join

set hive.auto.convert.join=false;

执行计划 有reduce阶段在reduce阶段join,不是map join

0: jdbc:hive2://wxt01:10000> explain select
0: jdbc:hive2://wxt01:10000> a.user_id,
0: jdbc:hive2://wxt01:10000> a.oid,
0: jdbc:hive2://wxt01:10000> b.name
0: jdbc:hive2://wxt01:10000> from a
0: jdbc:hive2://wxt01:10000> join b
0: jdbc:hive2://wxt01:10000> on a.user_id=b.user_id;
OK
+---------------------------------------------------------------------------------------------------+--+
|                                              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: a                                                                              |
|             Statistics: Num rows: 1 Data size: 56 Basic stats: COMPLETE Column stats: NONE        |
|             Filter Operator                                                                       |
|               predicate: user_id is not null (type: boolean)                                      |
|               Statistics: Num rows: 1 Data size: 56 Basic stats: COMPLETE Column stats: NONE      |
|               Select Operator                                                                     |
|                 expressions: user_id (type: string), oid (type: string)                           |
|                 outputColumnNames: _col0, _col1                                                   |
|                 Statistics: Num rows: 1 Data size: 56 Basic stats: COMPLETE Column stats: NONE    |
|                 Reduce Output Operator                                                            |
|                   key expressions: _col0 (type: string)                                           |
|                   sort order: +                                                                   |
|                   Map-reduce partition columns: _col0 (type: string)                              |
|                   Statistics: Num rows: 1 Data size: 56 Basic stats: COMPLETE Column stats: NONE  |
|                   value expressions: _col1 (type: string)                                         |
|           TableScan                                                                               |
|             alias: b                                                                              |
|             Statistics: Num rows: 1 Data size: 36 Basic stats: COMPLETE Column stats: NONE        |
|             Filter Operator                                                                       |
|               predicate: user_id is not null (type: boolean)                                      |
|               Statistics: Num rows: 1 Data size: 36 Basic stats: COMPLETE Column stats: NONE      |
|               Select Operator                                                                     |
|                 expressions: user_id (type: string), name (type: string)                          |
|                 outputColumnNames: _col0, _col1                                                   |
|                 Statistics: Num rows: 1 Data size: 36 Basic stats: COMPLETE Column stats: NONE    |
|                 Reduce Output Operator                                                            |
|                   key expressions: _col0 (type: string)                                           |
|                   sort order: +                                                                   |
|                   Map-reduce partition columns: _col0 (type: string)                              |
|                   Statistics: Num rows: 1 Data size: 36 Basic stats: COMPLETE Column stats: NONE  |
|                   value expressions: _col1 (type: string)                                         |
|       Reduce Operator Tree:                                                                       |
|         Join Operator                                                                             |
|           condition map:                                                                          |
|                Inner Join 0 to 1                                                                  |
|           keys:                                                                                   |
|             0 _col0 (type: string)                                                                |
|             1 _col0 (type: string)                                                                |
|           outputColumnNames: _col0, _col1, _col3                                                  |
|           Statistics: Num rows: 1 Data size: 61 Basic stats: COMPLETE Column stats: NONE          |
|           Select Operator                                                                         |
|             expressions: _col0 (type: string), _col1 (type: string), _col3 (type: string)         |
|             outputColumnNames: _col0, _col1, _col2                                                |
|             Statistics: Num rows: 1 Data size: 61 Basic stats: COMPLETE Column stats: NONE        |
|             File Output Operator                                                                  |
|               compressed: false                                                                   |
|               Statistics: Num rows: 1 Data size: 61 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                                                                                  |
|                                                                                                   |
+---------------------------------------------------------------------------------------------------+--+
67 rows selected (0.122 seconds)
小涛手记
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
hive开启自动转化common join和map join 带来的问题
qq_41018861的博客
09-22 1104
我们采用的hive版本是3.1.2属于较新版本，此版本下hive本身默认开启map join。
Hive mapjoin使用
lquarius的博客
07-31 8693
方法一 set hive.auto.convert.join = true; --是否开自动mapjoin set hive.mapjoin.smalltable.filesize;--mapjoin的表size大小 以上两个参数同时使用，在hive.auto.convert.join为true时，只要小表size小于hive.mapjoin.smalltable.filesize的设置值，并且小表不是关联操作的最后一张表，小表就会走mapjoin。 set hive.auto.conve...
HIVE调优MapJoin
最新发布
2301_77836489的博客
05-12 1821
HIVE调优具体实现
hive sql数据倾斜——大表join小表如何使用map join
qq_41018861的博客
01-05 4817
Map Join是Hive的一种优化操作，其适用于小表JOIN大表的场景，由于表的JOIN操作是在Map端且在内存进行的，所以其并不需要启动Reduce任务也就不需要经过shuffle阶段，从而能在一定程度上节省资源提高JOIN效率 一、mapjoin的使用场景： 关联操作中有一张表非常小 不等值的链接操作 二、具体使用： 方法一： 在Hive0.11前，必须使用MAPJOIN来标记显示地启动该优化操作，由于其需要将小表加载进内存所以要注意小表的大小 SELECT/*+MAPJOIN(smallta.
hive中的map join
H_hanwen的博客
11-18 1954
本文主要讲述一下自己在hive中使用map join遇到的一些问题。语言过于直白，请谅解 1.什么是map join？ map join主要是在关联的时候使用，hive开启map join后可以将关联的小表放入内存中去执行，以此来提高脚本的运行速度   2.map join如何设置？ set hive.auto.convert.join=false; --false表示关闭m...
Hive MapJoin原理
sakulamartain的博客
10-29 1383
本文主要想讨论在Hive1.2.2环境中，以下三种情况下，2表做left join的执行原理： 1. 2张相同大小的表做left join； 2. 大表做主表，与临时表做left join； 在进行试验之前，先说下官方对于 Map Join的原理说明： Hive MapJoin原理说明： MapJoin 就是在Map阶段将小表读入内存并生成HashTableFiles，然后顺序扫描大表完成Join。 上图是Hive MapJoin的原理图，出自Facebook工程师Liyin T...
通俗易懂的Hive join几种形式原理详解
石榴姐yyds
07-26 3913
表的Join是数据分析处理过程中必不可少的操作，Hive同样支持Join的语法，Hive Join的底层还是通过MapReduce来实现的，Hive实现Join时，为了提高MapReduce的性能，提供了多种Join方案来实现，例如适合小表Join大表的Map Join，大表Join大表的Reduce Join，以及大表Join的优化方案Bucket Join等。 1 Map Join 应用场景 适合于小表join大表或者小表Join小表 原理 将小的那份数据给每个MapTask的内存都放一.
hive 中join和Group的优化
01-07
set hive.map.aggr = true; //是否在 Map 端进行聚合，默认为 True ；该设置会消耗更多的内存。 set hive.groupby.mapaggr.checkinterval = 100000000; //在 Map 端进行聚合操作的条目数目 set hive.groupby....
hadoop Join代码（map join 和reduce join）
12-10
本文将深入探讨Map JOIN和Reduce JOIN两种在Hadoop中实现JOIN的方法，并通过代码示例来阐述它们的工作原理。 1. Map JOIN： Map JOIN在Hadoop中主要应用于小表与大表的连接。小表的数据可以完全加载到内存中，而大...
Hive-Summit-2011-join.zip_hive
09-21
3. **Map-side Join**：为了解决大规模数据集的Join问题，Hive引入了Map-side Join。这种方法适用于小表与大表的连接，小表可以被完全加载到内存中，从而避免了在Reduce阶段的昂贵数据交换。 4. **Bucketing与...
Hive性能优化
01-27
本文来自于cnblogs,赘述了在工作中总结Hive的常用优化手段和在工作中使用Hive出现的问题。下面开始本篇文章的优化介绍:继续《那些年使用Hive踩过的坑》一文中的剩余部分.首先，我们来看看Hadoop的计算框架特性，在此...
Hive on Spark EXPLAIN statement
03-27
Hive on Spark EXPLAIN statement : 讲述了 Common Join / Map join / Bucket Map Join / Sorted Merge Bucket Map Join / skew join 在explain 中的 树结构 。In Hive, command EXPLAIN can be used to show the ...
Hive的ReduceJoin/MapJoin/SMBJoin
someInNeed的博客
03-27 565
Hive中就是把Map，Reduce的Join拿过来，通过SQL来表示。 参考链接：https://cwiki.apache.org/confluence/display/Hive/LanguageManual+Joins 1.Reduce /Common/Shuffle Join Reduce Join在Hive中也叫Common Join或Shuffle Join 如果两边数据量都很大，它会进行把相同key的value合在一起，正好符合我们在sql中的join，然后再去组合，如图所示。 .
MapJoin 的使用方法
Taerge0110的博客
10-27 1021
在对大表和一个或多个小表执行join操作时，mapjoin会将您指定的小表全部加载到执行join操作的程序的内存中，在Map阶段完成表连接从而加快join的执行速度。要使MapJoin能够顺利进行，那就必须满足这样的条件：除了一份表的数据分布在不同的Map中外，其他连接的表的数据必须在每个Map中有完整的拷贝。mapjoin在Map阶段执行表连接，而非等到Reduce阶段才执行表连接，可以缩短大量数据传输时间，提升系统资源利用率，从而起到优化作业的作用。mapjoin中多个小表用英文逗号（,）分隔，例如/
Hive优化--Map Join
yyGeek的博客
03-09 414
适用场景：大表join小表Map Join算法可以通过两个只有map阶段的Job完成一个join操作。
hive的MapJoin机制
Inner Peace
09-12 8897
什么是MapJoin? MapJoin顾名思义，就是在Map阶段进行表之间的连接。而不需要进入到Reduce阶段才进行连接。这样就节省了在Shuffle阶段时要进行的大量数据传输。从而起到了优化作业的作用。 MapJoin的原理： 即在map 端进行join，其原理是broadcast join，即把小表作为一个完整的驱动表来进行join操作。通常情况下，要连接的各个表里面的数据会分布在不同
Hive优化之Mapjoin
异乡流狼
11-28 1026
一、场景 MapJoin是Hive的一种优化操作，其适用于小表JOIN大表的场景，由于表的JOIN操作是在Map端且在内存进行的，所以其并不需要启动Reduce任务也就不需要经过shuffle阶段，从而能在一定程度上节省资源提高JOIN效率。 二、使用 2.1 Hive v0.7 之前通过在查询语句中增加一个标记进行触发： SELECT /*+ MAPJOIN(smalltable)*/ sma...
Hive MapJoin 执行计划
张伟的专栏
12-12 1062
  本文通过展示hive.mapjoin.smalltable.filesize 这个参数的设置,来比较是否使用mapjoin的执行计划的区别 测试sql: SELECT id, clienttime FROM ( SELECT id, clienttime, key FROM log_table WHERE day = '20180801' ) a1 LEFT JOIN (S...
Hive中MapJoin的原理和机制
ych0112xzz的博客
07-24 8546
笼统的说，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
和 reduce side join的区别是什么？Hive的mapjoin和reduce side join之间的区别在于它们的实现方式。Mapjoin是一种在Map阶段完成的join，它只需要加载小表，然后在Map任务中进行join，因此它速度更快，但是需要保证小表数据量不会很大，否则会导致内存溢出。Reduce side join则是在Reduce阶段完成的join，它需要加载大表和小表，并在Reduce任务中进行join，因此它速度比较慢，但是不存在内存溢出的问题。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值