MapReduce 中的两表 join 实例(二)

最新推荐文章于 2022-11-16 18:05:29 发布
最新推荐文章于 2022-11-16 18:05:29 发布
阅读量104 收藏
点赞数
文章标签： 大数据 java
原文链接：https://yq.aliyun.com/articles/517040
版权
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
package  com.baidu.uilt;
import  java.io.*;
 
import  org.apache.hadoop.io.*;
 
public  class  TextPair  implements  WritableComparable<TextPair> {
 
   private  Text first;
   private  Text second;
   
   public  TextPair() {
     set( new  Text(),  new  Text());
   }
   
   public  TextPair(String first, String second) {
     set( new  Text(first),  new  Text(second));
   }
   
   public  TextPair(Text first, Text second) {
     set(first, second);
   }
   
   public  void  set(Text first, Text second) {
     this .first = first;
     this .second = second;
   }
   
   public  Text getFirst() {
     return  first;
   }
 
   public  Text getSecond() {
     return  second;
   }
 
   @Override
   public  void  write(DataOutput out)  throws  IOException {
     first.write(out);
     second.write(out);
   }
 
   @Override
   public  void  readFields(DataInput in)  throws  IOException {
     first.readFields(in);
     second.readFields(in);
   }
   
   @Override
   public  int  hashCode() {
     return  first.hashCode() *  163  + second.hashCode();
   }
   
   @Override
   public  boolean  equals(Object o) {
     if  (o  instanceof  TextPair) {
       TextPair tp = (TextPair) o;
       return  first.equals(tp.first) && second.equals(tp.second);
     }
     return  false ;
   }
 
   @Override
   public  String toString() {
     return  first +  "\t"  + second;
   }
   
   @Override
   public  int  compareTo(TextPair tp) {
     int  cmp = first.compareTo(tp.first);
     if  (cmp !=  0 ) {
       return  cmp;
     }
     return  second.compareTo(tp.second);
   }
 
   public  static  class  Comparator  extends  WritableComparator {
     
     private  static  final  Text.Comparator TEXT_COMPARATOR =  new  Text.Comparator();
     
     public  Comparator() {
       super (TextPair. class );
     }
 
     @Override
     public  int  compare( byte [] b1,  int  s1,  int  l1,
                        byte [] b2,  int  s2,  int  l2) {
       
       try  {
         int  firstL1 = WritableUtils.decodeVIntSize(b1[s1]) + readVInt(b1, s1);
         int  firstL2 = WritableUtils.decodeVIntSize(b2[s2]) + readVInt(b2, s2);
         int  cmp = TEXT_COMPARATOR.compare(b1, s1, firstL1, b2, s2, firstL2);
         if  (cmp !=  0 ) {
           return  cmp;
         }
         return  TEXT_COMPARATOR.compare(b1, s1 + firstL1, l1 - firstL1,
                                        b2, s2 + firstL2, l2 - firstL2);
       }  catch  (IOException e) {
         throw  new  IllegalArgumentException(e);
       }
     }
   }
 
   static  {
     WritableComparator.define(TextPair. class ,  new  Comparator());
   }
   public  static  class  FirstComparator  extends  WritableComparator {
     
     private  static  final  Text.Comparator TEXT_COMPARATOR =  new  Text.Comparator();
     
     public  FirstComparator() {
       super (TextPair. class );
     }
 
     @Override
     public  int  compare( byte [] b1,  int  s1,  int  l1,
                        byte [] b2,  int  s2,  int  l2) {
       
       try  {
         int  firstL1 = WritableUtils.decodeVIntSize(b1[s1]) + readVInt(b1, s1);
         int  firstL2 = WritableUtils.decodeVIntSize(b2[s2]) + readVInt(b2, s2);
         return  TEXT_COMPARATOR.compare(b1, s1, firstL1, b2, s2, firstL2);
       }  catch  (IOException e) {
         throw  new  IllegalArgumentException(e);
       }
     }
     
     @Override
     public  int  compare(WritableComparable a, WritableComparable b) {
       if  (a  instanceof  TextPair && b  instanceof  TextPair) {
         return  ((TextPair) a).first.compareTo(((TextPair) b).first);
       }
       return  super .compare(a, b);
     }
   }
 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
package  com.baidu.loan;
/***
  * 
  * /home/users/ouerqiang/hadoop/hadoop-client-palo/hadoop/bin/hadoop jar LoanIdeaInfoText.jar  com.baidu.loan.LoanIdeainfoJoinIterialByDAILI6  /test/fbiz/loan/ideainfo/LoanIdeainfoByDAILIUnitID_0928  /test/fbiz/loan/ideainfo/LoanIterialByDAI_0928  /test/fbiz/loan/ideainfo/LoanIdeainfoJoinIterialByDAILI6_1_0928
  * 
  * **/
import  java.io.IOException;
import  java.util.Iterator;
import  org.apache.hadoop.mapred.FileOutputFormat;
import  org.apache.hadoop.mapred.JobClient;
import  org.apache.hadoop.mapred.JobConf;
import  org.apache.hadoop.mapred.MapReduceBase;
import  org.apache.hadoop.mapred.Mapper;
import  org.apache.hadoop.mapred.OutputCollector;
import  org.apache.hadoop.mapred.Partitioner;
import  org.apache.hadoop.mapred.Reducer;
import  org.apache.hadoop.mapred.Reporter;
import  org.apache.hadoop.mapred.TextInputFormat;
import  org.apache.hadoop.mapred.lib.MultipleInputs;
import  org.apache.hadoop.util.Tool;
import  org.apache.hadoop.util.ToolRunner;
import  org.apache.hadoop.conf.Configured;
import  org.apache.hadoop.fs.Path;
import  org.apache.hadoop.io.LongWritable;
import  org.apache.hadoop.io.Text;
 
import  com.baidu.uilt.TextPair;
 
public  class  LoanIdeainfoJoinIterialByDAILI6  extends  Configured  implements  Tool {
 
     public  static  class  JoinUnitMapper  extends  MapReduceBase  implements
             Mapper<LongWritable, Text, TextPair, Text> {
 
         public  void  map(LongWritable key, Text value,
                 OutputCollector<TextPair, Text> output, Reporter reporter)
                 throws  IOException {
             String gbkStr = value.toString();
             if  (gbkStr.split( "\t" ).length <  2  && gbkStr.split( "," ).length ==  4 ) {
                 String[] strs = gbkStr.split( "," );
                 output.collect( new  TextPair(strs[ 0 ],  "0" ), value);
             }
 
         }
     }
 
     public  static  class  JoinIterialMapper  extends  MapReduceBase  implements
             Mapper<LongWritable, Text, TextPair, Text> {
 
         public  void  map(LongWritable key, Text value,
                 OutputCollector<TextPair, Text> output, Reporter reporter)
                 throws  IOException {
             String gbkStr = value.toString();
             if  (gbkStr.split( "\t" ).length >  4 ) { // LoanIterial
                 String[] strs = gbkStr.split( "\t" );
                 output.collect( new  TextPair(strs[ 0 ],  "1" ), value);
             }
         }
     }
 
     public  static  class  JoinReducer  extends  MapReduceBase  implements
             Reducer<TextPair, Text, Text, Text> {
 
         public  void  reduce(TextPair key, Iterator<Text> values,
                 OutputCollector<Text, Text> output, Reporter reporter)
                 throws  IOException {
 
             Text stationName =  new  Text(values.next());
             while  (values.hasNext()) {
                 Text record = values.next();
                 Text outValue =  new  Text(stationName.toString() +  "\t"
                         + record.toString());
                 output.collect(stationName, record);
                 //output.collect(key.getFirst(), outValue);
             }
         }
     }
     
     public  static  class  KeyPartitioner  implements  Partitioner<TextPair, Text> {
         @Override
         public  void  configure(JobConf job) {}
         
         @Override
         public  int  getPartition(TextPair key, Text value,  int  numPartitions) {
           return  (key.getFirst().hashCode() & Integer.MAX_VALUE) % numPartitions;
         }
       }
     
     @Override
     public  int  run(String[] args)  throws  Exception {
         if  (args.length !=  3 ) {
               return  - 1 ;
             }
             
             JobConf conf =  new  JobConf(getConf(), getClass());
             conf.setJobName( "Join record with station name" );
             
             String strPathUnit =args[ 0 ];
             String strPathIterial =args[ 1 ];
             Path outputPath=  new  Path(args[ 2 ]);
             
             MultipleInputs.addInputPath(conf,  new  Path(strPathUnit),
                 TextInputFormat. class , JoinUnitMapper. class );
             MultipleInputs.addInputPath(conf,  new  Path(strPathIterial),
                 TextInputFormat. class , JoinIterialMapper. class );
             FileOutputFormat.setOutputPath(conf, outputPath);
 
             conf.setPartitionerClass(KeyPartitioner. class );
             conf.setOutputValueGroupingComparator(TextPair.FirstComparator. class );
             
             conf.setMapOutputKeyClass(TextPair. class );
             
             conf.setReducerClass(JoinReducer. class );
 
             conf.setOutputKeyClass(Text. class );
             
             JobClient.runJob(conf);
             return  0 ;
     }
     
     public  static  void  main(String[] args)  throws  Exception {
         int  exitCode = ToolRunner.run( new  LoanIdeainfoJoinIterialByDAILI6(), args);
         System.exit(exitCode);
     }
 
     
 
}


需要注意的是上面的代码只是针对两表的一对一（多）关系，不满足多对多关系。如果需要满足多对多关系则需要加上一下判断即可。


本文转自 梦朝思夕 51CTO博客，原文链接:http://blog.51cto.com/qiangmzsx/1560553


weixin_34061555
关注
用MapReduce实现2个表的join连接与查询
一个学习的博客
11-05 2301
首先准备两个CVS表单 我第一个表单为customer 第二个表单为order 接着实现2表连接查询 首先写一个实体类CustomerOrder。定义变量 package cn.kgc.kb15.demo05; import org.apache.hadoop.io.WritableComparable; import javax.xml.crypto.Data; import java.io.DataInput; import java.io.DataOutput; imp..
hadoop学习笔记（六）MapReduce常见实例三：Join操作（Map端join、Reduce端join、单表join）
Lee的学习笔记
12-20 959
目录 什么是join？ Map端Join 任务描述 流程分析 代码 执行结果 Reduce端Join 任务描述 流程分析 代码 执行结果 单表Join 任务描述 流程分析 代码 执行结果 什么是join？   Map端Join MapReduce提供了表连接操作其中包括Map端join、Reduce端join还有单表连接，现在我们要讨论的是Map端joi...
MapReduce实现两表join
weixin_34409741的博客
09-06 1340
一、方法介绍 假设要进行join的数据分别来自File1和File2. 参考：https://blog.csdn.net/yimingsilence/article/details/70242604 1.1reduce side join reduce side join是一种最简单的join方式，其主要思想如下：在map阶段，map函数同时读取两个文件File1和File2，为...
如何使用MapReduce实现两表的join
weixin_44361667的博客
03-05 665
map join： map side join 是针对一下场景进行的优化。两个待连接的表中，有一个表非常大，而另一个非常小，以至于小表可以直接存放到内存中。这样，我们可以将小表复制多份，让每一个map task内存中存在一份（比如放在hash table中），然后只扫描大表：对于大表中的每一条记录key/value，在hash table中查找是否具有相同key的记录，入股有，则连接后输出即可。 场景：MapJoin 适用于有一份数据较小的连接情况。 做法：直接将较小的数据加载到内存中，按照连接的关键字建立
Hadoop-mapreduce案例-两表join
weixin_42782897的博客
04-12 255
订单数据表t_order： id date pid amount 1001 20150710 P0001 2 1002 20150710 P0001 3...
MapReduce实现两表join_join的类型
wj1298250240的博客
03-07 278
参考： https://www.cnblogs.com/duaner92/p/9596770.html join的类型： 1.1 reduce side join reduce side join是一种最简单的join方式，其主要思想如下： 在map阶段，map函数同时读取两个文件File1和File2，为了区分两种来源的key/value数据对，对每条数据打一个标签（tag）,比如：tag=0表...
Mapreduce实例（六）：单表join
Bee_Darker的博客
06-02 410
任务目标 1.准确理解MapReduce单表连接的设计原理 2.熟练掌握MapReduce单表连接程序的编写 3.了解单表连接的运用场景 4.学会编写MapReduce单表连接程序代码解决问题
详解HDFS多文件Join操作的实例
08-29
本文将详解 HDFS 多文件 Join 操作的实例，包括 All Join 和 Left Join 两种类型，及其在实际应用中的实现。 一、HDFS 多文件 Join 操作的概念 在 HDFS 中，Join 操作是指将多个文件或表格中的数据进行合并和匹配...
Map Reduce的join算法的实现
weixin_44319151的博客
11-19 416
##1、reduce端join算法实现 这里有两个数据表：orders.txt和product.txt 假如数据量巨大，两表的数据是以文件的形式存储在HDFS中，需要用mapreduce程序来实现一下SQL查询运算： select a.id,a.date,b.name,b.category_id,b.price from t_order a join t_product b on a.pid ...
Mapreduce实例（五）：Reduce端join
Bee_Darker的博客
06-02 326
任务目标 1.了解reduce端join的适用场景 2.准确理解reduce端join的设计原理 3.熟练掌握reduce端join程序代码的编写
MapReduce中两表join的几种方案
商亮的专栏
12-12 727
转载自：http://my.oschina.net/leejun2005/blog/95186 原文本未删改。 1. 概述 在传统数据库（如：MYSQL）中，JOIN操作是非常常见且非常耗时的。而在HADOOP中进行JOIN操作，同样常见且耗时，由于Hadoop的独特设计思想，当进行JOIN操作时，有一些特殊的技巧。 本文首先介绍了Hadoop上通常的JOIN实现方法，然后
oracle/hive下两个大表的关联如何进行优化
最新发布
weixin_49196517的博客
11-16 3979
ORACLE/HIVE下两个大表优化
hadoop 两表join处理方法
伤心的驴的专栏
11-17 950
1. 概述 在传统数据库（如：MYSQL）中，JOIN操作是非常常见且非常耗时的。而在HADOOP中进行JOIN操作，同样常见且耗时，由于Hadoop的独特设计思想，当进行JOIN操作时，有一些特殊的技巧。 本文首先介绍了Hadoop上通常的JOIN实现方法，然后给出了几种针对不同输入数据集的优化方法。 2. 常见的join方法介绍 假设要进行join的数据分别来自File1和File2.
MapReduce 中的两表 join 几种方案简介
路卫杰的专栏
07-16 5775
概述 在传统数据库（如：MYSQL）中，JOIN操作是非常常见且非常耗时的。而在HADOOP中进行JOIN操作，同样常见且耗时，由于Hadoop的独特设计思想，当进行JOIN操作时，有一些特殊的技巧。本文首先介绍了Hadoop上通常的JOIN实现方法，然后给出了几种针对不同输入数据集的优化方法。 常见的join方法介绍 假设要进行join的数据分别来自File1和File2.2.1 reduce s
MapReduce的两表join操作优化
Jonney's house
03-26 2200
注：优化前的分析过程详见本博的上篇博文 案例 地址(Address)和人员(Person)的一对多关联   原始数据 地址(Address)数据 id AddreName 1 beijing 2 shanghai 3 guangzhou 人员(Person)数据 1 zhangsan 1 2 lisi 2 3 wangwu 1 4 zhaoliu 3 5 maqi 3
MapReduce实现两表的Join--原理及python和java代码实现
热门推荐
William Zhao's notes
05-25 1万+
用Hive一句话搞定的，但是有时必须要用mapreduce 方法介绍 1. 概述 在传统数据库（如：MYSQL）中，JOIN操作是非常常见且非常耗时的。而在HADOOP中进行JOIN操作，同样常见且耗时，由于Hadoop的独特设计思想，当进行JOIN操作时，有一些特殊的技巧。 本文首先介绍了Hadoop上通常的JOIN实现方法，然后给出了几种针对不同输入数据集的优化方法。 2. 常见
使用mapreduce实现多表连接join操作
sherry2233的博客
06-05 2369
（1） 准备小的数据测试集  输入是两个文件，一个代表工厂表，包含工厂名列和地址编号列；另一个代表地址表，包含地址名列和地址编号列。要求从输入数据中找出工厂名和地址名的对应关系，输出"地址编号——地址名——工厂名"表。 工厂表    地址表 结果输出如下： （2）设计思路    多表关联和单表关联相似，都类似于数据库中的自然连接。相比单表关联，多表关联的左右表和连接列
MapReduce实现hive join操作
Cumu Blog
10-30 4369
1. hive中join就是一条select语句，其个性
MapReduce高级特性：应用实例与排序Join解析
"这篇文档是关于MapReduce的高级特性，主要涵盖了各种应用场景的实例，包括内存排序、自定义数据类型、二次排序、内存排序找出每组最大值以及两个表的简单JOIN操作。文档通过实际案例深入浅出地解析了MR的重要知识点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值