使用hadoop的datajoin包進行關係型join操作

datajoin包在hadoop的contrib目錄下，我們也可以在src下面看見其源碼，它的源碼很小，我建議大體看看以瞭解其原理。

利用datajoin進行join操作，在《Hadoop in action》裏面已經講的十分清楚，在這裏只提及值得注意的幾個地方。

1. TaggedMapOutput的目的是標識數據，讓我們知道哪個記錄是從哪裏來的。
2. DataJoinMapperBase類中的generateInputTag在map任務開始時被調用（還沒進行map函數），其目的是生成tag，並自動存儲於DataJoinMapperBase類的inputTag中。 
   
3. generateTaggedMapOutput（）用於生存帶標籤的數據，這可以讓我們知道數據的來源，在我們想進行left join /right join的時候很有用，同時對於過濾數據等操作也有幫助。
4. datajoin在當前是用舊API寫的，也就是說Mapper子類是實現Mapper接口而不是擴展Mapper虛類，但是MapperChain.addMapper雖然是在舊API目錄下面，但是卻只支持擴展虛類的方式，相信當你數據流比較長的時候這會給你帶來麻煩，這個問題我沒有解決，重寫datajoin包可能是一種好的方式，但你也可以手動執行多個作業來間接達到目的。

下面是我自己想的一個練習，由於上述的第4點的限制，這其實是一個不完整的練習。

           數據是《hadoop in action》的數據：

datajoin_customers文件	datajoin_orders文件
10001,Stephanie Leung,555-555-5555 10002,Edward Kim,123-456-7890 10003,Jose Madriz,281-330-8004 10004,David Stork,408-555-0000 102343,Posa Wu, 12387887989	10003,A,12.95,02-Jun-2008 10001,B,88.25,20-May-2008 10002,C,32.00,30-Nov-2007 10003,D,25.02,22-Jan-2009 21312,F,32.00,23-Jan-2010

         題目：選出id爲10,000到1000,000,000的用戶數據進行right join（保留右邊，左邊爲如果沒有對應用戶信息則設爲NULL）。

         說明：我們設想訂單可以是匿名用戶購買的（比如淘寶網），現在我希望知道這個id範圍的一些訂單信息。

import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.contrib.utils.join.DataJoinMapperBase;
import org.apache.hadoop.contrib.utils.join.DataJoinReducerBase;
import org.apache.hadoop.contrib.utils.join.TaggedMapOutput;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.io.Writable;
import org.apache.hadoop.mapred.FileInputFormat;
import org.apache.hadoop.mapred.FileOutputFormat;
import org.apache.hadoop.mapred.JobClient;
import org.apache.hadoop.mapred.JobConf;
import org.apache.hadoop.mapred.TextInputFormat;
import org.apache.hadoop.mapred.TextOutputFormat;

import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;


public class DataJoin extends Configured implements Tool{

	public static class Mapper extends DataJoinMapperBase{

		protected Text generateInputTag(String inputFile) {
			return new Text(inputFile);
		}

		protected TaggedMapOutput generateTaggedMapOutput(Object value) {
			TaggedMapOutput ret = new MyTaggedWritable((Text)value);
			String ck = ((Text)value).toString().split(",", 2)[0];
			if(10000 > Long.valueOf(ck) || 1000000000 < Long.valueOf(ck)){
				return null;
 			}
			ret.setTag(new Text(this.inputTag));
			
			return ret;
		}
		protected Text generateGroupKey(TaggedMapOutput aRecord) {
			return new Text(aRecord.getData().toString().split(",")[0]);
		}
	}
	
	
	public static class Reducer extends DataJoinReducerBase{

		protected TaggedMapOutput combine(Object[] tags, Object[] values) {
			if(tags.length < 1)
				return null;
			if(tags.length == 1 && ((Text)tags[0]).toString().endsWith("customers")){
				return null;
			}
			
			
			String retStr = "";
			if(tags.length == 1 && ((Text)tags[0]).toString().endsWith("orders")){
				retStr = "NULL,";
			}
			for(int i = 0; i < values.length; i++){
				if(i >  0)
					retStr += ",";
				retStr +=((MyTaggedWritable)values[i]).getData().toString().split(",",2)[1];
			}
			TaggedMapOutput ret = new MyTaggedWritable(new Text(retStr));
			ret.setTag((Text)tags[0]);
			return ret;
		}
		
	}
	public static class MyTaggedWritable extends TaggedMapOutput{

		public Text data;
		
		public MyTaggedWritable(){
			this.data = new Text("");  //必須有，否則反序列化時出錯。
		}
		
		public MyTaggedWritable(Text data){
			this.data = data;
		}
		
		public void readFields(DataInput in) throws IOException {
			this.tag.readFields(in);
			this.data.readFields(in);
		}

		public void write(DataOutput out) throws IOException {
			this.tag.write(out);
			this.data.write(out);
		}

		public Writable getData() {
			return this.data;
		}
		
	}
	public int run(String[] arg0) throws Exception {
		Configuration conf = getConf();
		JobConf job = new JobConf(conf, DataJoin.class);
		job.setJarByClass(DataJoin.class);
		
		Path in = new Path(arg0[0]);
		Path out = new Path(arg0[1]);
		FileInputFormat.setInputPaths(job,in);
		FileOutputFormat.setOutputPath(job, out);
		
		job.setJobName("DataJoin");
		job.setMapperClass(Mapper.class);
		job.setReducerClass(Reducer.class);
		job.setInputFormat(TextInputFormat.class);
		job.setOutputFormat(TextOutputFormat.class);
		job.setOutputKeyClass(Text.class);
		job.setMapOutputKeyClass(Text.class);
		job.setMapOutputValueClass(MyTaggedWritable.class);
		job.setOutputValueClass(Text.class);
		job.set("mapred.textoutputformat.separator", ",");
		JobClient.runJob(job);
		return 0;
	}
	
	public static void main(String args[]) throws Exception{
		int res = ToolRunner.run(new Configuration(), new DataJoin(),args);
		System.exit(res);
	}

}

在generateTaggedMapOutput中我們進行數據過濾，把10000到1000,000,000間的數據選出來，然後在combine進行left join，我們知道combine函數是決定聯結方式的地方。

參考： [1]  <<hadoop in action>>