hive join

hive(0.9.0)：
1.支持equality joins, outer joins, and left semi joins
2.只支持等值条件
3.支持多表join

原理
hive执行引擎会将HQL“翻译”成为map-reduce任务，如果多张表使用同一列做join则将被翻译成一个reduce，否则将被翻译成多个map-reduce任务。
eg：
SELECT a.val, b.val, c.val FROM a JOIN b ON (a.key = b.key1) JOIN c ON (c.key = b.key1)将被翻译成1个map-reduce任务
SELECT a.val, b.val, c.val FROM a JOIN b ON (a.key = b.key1) JOIN c ON (c.key = b.key2)
将被翻译成2个map-reduce任务
这个很好理解，一般来说（map side join除外，后面会介绍），map过程负责分发数据，具体的join操作在reduce完成，因此，如果多表基于不同的列做join，则无法在一轮map-reduce任务中将所有相关数据shuffle到统一个reducer
对于多表join，hive会将前面的表缓存在reducer的内存中，然后后面的表会流式的进入reducer和reducer内存中其它的表做join。
eg：

[plain]  view plain copy

 

1. SELECT a.val, b.val, c.val FROM a JOIN b ON (a.key = b.key1) JOIN c ON (c.key = b.key1)  

在reducer中，a、b表待join的数据会放在内存中。
这会引起一些问题，如果reducer个数不足或者a、b表数据过大，则可能oom
因此，我们需要将数据量最大的表放到最后，或者通过“STREAMTABLE”显示指定reducer流式读入的表
eg：
SELECT /*+ STREAMTABLE(a) */ a.val, b.val, c.val FROM a JOIN b ON (a.key = b.key1) JOIN c ON (c.key = b.key1)此时，b、c表数据在reducer将放在内存中

Outer join
Outer join包括left、right、full outer join，其目的是针对不匹配的情况做一些控制。 
表a：

SELECT a.val, b.val FROM a LEFT OUTER JOIN b ON (a.key=b.key)LEFT OUTER JOIN：如果a.key中找不到对应的b.key，则输出a.val，NULL

LEFT OUTER JOIN可以用来代替not in（not in 在Hive0.8才支持）
eg：
select a.key from a left outer join b on a.key=b.key where b.key1 is null

实例:

[plain]  view plain copy

 

1. hive> select * from a ;  
2. OK  
3. key     value  
4. 1       a  
5. 2       b  
6. 3       c  
7. Time taken: 0.155 seconds  
8. hive> select * from b;   
9. OK  
10. key     value  
11. 1       d  
12. 2       e  
13. 4       f  
14. hive> SELECT a.value, b.value FROM a LEFT OUTER JOIN b ON (a.key=b.key);   
15. OK  
16. value   value  
17. a       d  
18. b       e  
19. c       NULL  
20. hive> SELECT a.value, b.value FROM a RIGHT OUTER JOIN b ON (a.key=b.key);  
21. OK  
22. value   value  
23. a       d  
24. b       e  
25. NULL    f  
26. hive> SELECT a.value, b.value FROM a FULL OUTER JOIN b ON (a.key=b.key);   
27. OK  
28. value   value  
29. a       d  
30. b       e  
31. c       NULL  
32. NULL    f  

Left Semi Join

hive之前（现已支持！）不支持in/exists，left semi join是in/exists更有效率的实现。
eg：
SELECT a.key, a.value FROM a WHERE a.key in (SELECT b.key FROM B);可以使用如下语句代替：
SELECT a.key, a.val FROM a LEFT SEMI JOIN b on (a.key = b.key)

Map Side Join
假如join两张表，其中有一张表特别小（可以放到内存中），那么可以使用Map-side join。Map side join是在mapper中做join，原理是将其中一张join表放到每个mapper任务的内存中，从而不用reducer任务，在mapper中就完成join。Map side join不适合FULL/RIGHT OUTER JOIN，理由大家思考下。
示例：
SELECT /*+ MAPJOIN(b) */ a.key, a.value FROM a join b on a.key = b.key

Bucketed Map Join
Bucketed map join是一种特殊的map side join，其针对的是所有的表都使用待join的key作为bucket列，并且bucket数量彼此有倍数关系的场景。在这种场景下，由于不需要将整张表导入内存，只需要将相应的bucket导入内存，因此，适宜一些数据量比较大的表。
例如，Table a使用key作为bucket列，共有8个bucket，Table b也是用key作为bucket列，有16个bucket，则使用Map side join，a只需要将b对应的2个bucket放入内存即可，如下：
SELECT /*+ MAPJOIN(b) */ a.key, a.valueFROM a join b on a.key = b.key

在不一点left semi join的原理：

只用B表的join字段做reduce端的过滤，感觉不是semi join这个词的意思

这里有个left semi join的explain:

Java代码  

1. STAGE PLANS:  
2.   Stage: Stage-4  
3.     Conditional Operator  
4.   
5.   Stage: Stage-1  
6.     Map Reduce  
7.       Alias -> Map Operator Tree:  
8.         t1:t   
9.           TableScan  
10.             alias: t  
11.             Select Operator  
12.               expressions:  
13.                     expr: dt  
14.                     type: string  
15.                     expr: regexp_extract(params, '&orderNo=([^&]*)', 1)  
16.                     type: string  
17.               outputColumnNames: _col1, _col2  
18.               Reduce Output Operator  
19.                 key expressions:  
20.                       expr: lower(trim(_col2))  
21.                       type: string  
22.                 sort order: +  
23.                 Map-reduce partition columns:  
24.                       expr: lower(trim(_col2))  
25.                       type: string  
26.                 tag: 0  
27.                 value expressions:  
28.                       expr: _col1  
29.                       type: string  
30.                       expr: _col2  
31.                       type: string  
32.         t2:t   
33.           TableScan  
34.             alias: t  
35.             Filter Operator  
36.               predicate:  
37.                   expr: (substring(ordercreatetime, 0, 10) = '2014-11-01')  
38.                   type: boolean  
39.               Select Operator  
40.                 expressions:  
41.                       expr: orderno  
42.                       type: string  
43.                 outputColumnNames: _col0  
44.                 Group By Operator  
45.                   bucketGroup: false  
46.                   keys:  
47.                         expr: _col0  
48.                         type: string  
49.                   mode: hash  
50.                   outputColumnNames: _col0  
51.                   Reduce Output Operator  
52.                     key expressions:  
53.                           expr: lower(trim(_col0))  
54.                           type: string  
55.                     sort order: +  
56.                     Map-reduce partition columns:  
57.                           expr: lower(trim(_col0))  
58.                           type: string  
59.                     tag: 1  
60.       Reduce Operator Tree:  
61.         Join Operator  
62.           condition map:  
63.                Left Semi Join 0 to 1  
64.           condition expressions:  
65.             0 {VALUE._col1} {VALUE._col2}  
66.             1   
67.           handleSkewJoin: false  
68.           outputColumnNames: _col1, _col2  
69.           Select Operator  
70.             expressions:  
71.                   expr: _col1  
72.                   type: string  
73.                   expr: _col2  
74.                   type: string  
75.             outputColumnNames: _col0, _col1  
76.             File Output Operator  
77.               compressed: false  
78.               GlobalTableId: 0  
79.               table:  
80.                   input format: org.apache.hadoop.mapred.TextInputFormat  
81.                   output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat  
82.   
83.   Stage: Stage-0  
84.     Fetch Operator  
85.       limit: -1 
    

resource:http://blackproof.iteye.com/blog/2155550