Pig 重写加载函数和存储函数UDF

最新推荐文章于 2023-11-23 21:36:15 发布
原创 最新推荐文章于 2023-11-23 21:36:15 发布 · 1.2w 阅读 · 1 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#pig #Hadoop #PigStorage #pig入门 #pig深入
本文介绍了如何通过自定义Pig UDF（User Defined Function）来实现对数据的灵活读取、处理和存储，包括指定列和行的分隔符，以适应不同格式的数据需求。通过实例演示了如何打包、注册UDF，并在Pig脚本中调用此UDF进行数据处理。此外，还展示了如何利用此UDF进行数据的存储，以及如何通过LoadMetadata接口返回通用的资源方案，从而实现对多种数据格式的支持。

pig自带的pigstorage不能指定行分隔符，所以自己重写了一个简单的UDF类，可以指定列和行的分隔符，之前研究过的简单的，

http://blog.csdn.net/ruishenh/article/details/12048067

但是弊端大，所以这次重写一下。


操作步骤打好包上传到服务器，

grunt> register  /home/pig/pig-0.11.0/udflib/myStorage.jar 

grunt> cat student;
1,xiaohouzi,25/2,xiaohouzi2,24/3,xiaohouzi3,23    

grunt> a = load 'student' using com.hcr.hadoop.pig.MyStorage(',','/');

grunt> dump a;

(1,xiaohouzi,25)
(2,xiaohouzi2,24)
(3,xiaohouzi3,23)

grunt> store a into 'myStorageOut' using com.hcr.hadoop.pig.MyStorage(',','/');

执行提示成功后查看

grunt> cat myStorageOut
1,xiaohouzi,25/2,xiaohouzi2,24/3,xiaohouzi3,23/



源码类

package com.hcr.hadoop.pig;

import java.io.DataOutputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.List;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FSDataOutputStream;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.io.WritableComparable;
import org.apache.hadoop.io.compress.BZip2Codec;
import org.apache.hadoop.io.compress.CompressionCodec;
import org.apache.hadoop.io.compress.GzipCodec;
import org.apache.hadoop.mapreduce.InputFormat;
import org.apache.hadoop.mapreduce.InputSplit;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.OutputFormat;
import org.apache.hadoop.mapreduce.RecordReader;
import org.apache.hadoop.mapreduce.RecordWriter;
import org.apache.hadoop.mapreduce.TaskAttemptContext;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.input.LineRecordReader;
import org.apache.hadoop.mapreduce.lib.input.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
import org.apache.hadoop.util.ReflectionUtils;
import org.apache.pig.Expression;
import org.apache.pig.LoadFunc;
import org.apache.pig.LoadMetadata;
import org.apache.pig.PigException;
import org.apache.pig.ResourceSchema;
import org.apache.pig.ResourceSchema.ResourceFieldSchema;
import org.apache.pig.ResourceStatistics;
import org.apache.pig.StoreFunc;
import org.apache.pig.StoreFuncInterface;
import org.apache.pig.backend.executionengine.ExecException;
import org.apache.pig.backend.hadoop.executionengine.mapReduceLayer.PigSplit;
import org.apache.pig.data.DataType;
import org.apache.pig.data.Tuple;
import org.apache.pig.data.TupleFactory;
import org.apache.pig.impl.logicalLayer.schema.Schema.FieldSchema;
import org.apache.pig.impl.util.StorageUtil;

public class MyStorage extends LoadFunc implements StoreFuncInterface,LoadMetadata {

	private static final Log LOG = LogFactory.getLog(MyStorage.class);

	private static final String utf8 = "UTF-8";

	private static String fieldDel = "\t";

	private static String recordDel = "\n";

	protected RecordReader recordReader = null;

	protected RecordWriter writer = null;

	public MyStorage() {
	}

	public MyStorage(String fieldDel) {
		this(fieldDel, "\n");
	}

	public MyStorage(String fieldDel, String recordDel) {
		this.fieldDel = fieldDel;
		this.recordDel = recordDel;
	}

	@Override
	public void setLocation(String s, Job job) throws IOException {
		FileInputFormat.setInputPaths(job, s);
	}

	@Override
	public InputFormat getInputFormat() throws IOException {
		return new MyStorageInputFormat(recordDel);
	}

	@Override
	public void prepareToRead(RecordReader recordReader, PigSplit pigSplit)
			throws IOException {
		this.recordReader = recordReader;
	}

	@Override
	public Tuple getNext() throws IOException {
		try {
			boolean flag = recordReader.nextKeyValue();
			if (!flag) {
				return null;
			}
			Text value = (Text) recordReader.getCurrentValue();
			String[] strArray = value.toString().split(fieldDel);
			List lst = new ArrayList<String>();
			int i = 0;
			for (String singleItem : strArray) {
				lst.add(i++, singleItem);
			}
			return TupleFactory.getInstance().newTuple(lst);
		} catch (InterruptedException e) {
			throw new ExecException("Read data error",
					PigException.REMOTE_ENVIRONMENT, e);
		}
	}

	/**
	 * */
	@Override
	public String relToAbsPathForStoreLocation(String location, Path curDir)
			throws IOException {
		return LoadFunc.getAbsolutePath(location, curDir);
	}

	@Override
	public OutputFormat getOutputFormat() throws IOException {
		return new MyStorageOutputFormat(StorageUtil.parseFieldDel(fieldDel),
				this.recordDel);
	}

	@Override
	public void setStoreLocation(String location, Job job) throws IOException {
		job.getConfiguration().set("mapred.textoutputformat.separator", "");
		FileOutputFormat.setOutputPath(job, new Path(location));
		if ("true".equals(job.getConfiguration().get(
				"output.compression.enabled"))) {
			FileOutputFormat.setCompressOutput(job, true);
			String codec = job.getConfiguration().get(
					"output.compression.codec");
			try {
				FileOutputFormat.setOutputCompressorClass(job,
						(Class<? extends CompressionCodec>) Class
								.forName(codec));
			} catch (ClassNotFoundException e) {
				throw new RuntimeException("Class not found: " + codec);
			}
		} else {
			// This makes it so that storing to a directory ending with ".gz" or
			// ".bz2" works.
			setCompression(new Path(location), job);
		}

	}

	private void setCompression(Path path, Job job) {
		String location = path.getName();
		if (location.endsWith(".bz2") || location.endsWith(".bz")) {
			FileOutputFormat.setCompressOutput(job, true);
			FileOutputFormat.setOutputCompressorClass(job, BZip2Codec.class);
		} else if (location.endsWith(".gz")) {
			FileOutputFormat.setCompressOutput(job, true);
			FileOutputFormat.setOutputCompressorClass(job, GzipCodec.class);
		} else {
			FileOutputFormat.setCompressOutput(job, false);
		}
	}

	@Override
	public void checkSchema(ResourceSchema s) throws IOException {
		// TODO Auto-generated method stub

	}

	@Override
	public void prepareToWrite(RecordWriter writer) throws IOException {
		this.writer = writer;
	}

	@Override
	public void putNext(Tuple t) throws IOException {
		try {
			writer.write(null, t);
		} catch (InterruptedException e) {
			throw new IOException(e);
		}
	}

	@Override
	public void setStoreFuncUDFContextSignature(String signature) {
		// TODO Auto-generated method stub

	}

	@Override
	public void cleanupOnFailure(String location, Job job) throws IOException {
		StoreFunc.cleanupOnFailureImpl(location, job);
	}

	@Override
	public void cleanupOnSuccess(String location, Job job) throws IOException {
		// TODO Auto-generated method stub

	}

	@Override
	public ResourceSchema getSchema(String location, Job job)
			throws IOException {
			ResourceSchema rs=new ResourceSchema();
            FieldSchema c1 = new FieldSchema("c1", DataType.INTEGER);  
            FieldSchema c2 = new FieldSchema("c2", DataType.INTEGER);
            FieldSchema c3 = new FieldSchema("c3", DataType.DOUBLE);
            ResourceFieldSchema fs1 =new ResourceFieldSchema(c1);
            ResourceFieldSchema fs2 =new ResourceFieldSchema(c2);
            ResourceFieldSchema fs3 =new ResourceFieldSchema(c3);
            rs.setFields(new ResourceFieldSchema[]{fs1,fs2,fs3});
            return rs;
	}

	@Override
	public ResourceStatistics getStatistics(String location, Job job)
			throws IOException {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public String[] getPartitionKeys(String location, Job job)
			throws IOException {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public void setPartitionFilter(Expression partitionFilter)
			throws IOException {
		// TODO Auto-generated method stub
		
	}
}

class MyStorageInputFormat extends TextInputFormat {

	private final String recordDel;

	public MyStorageInputFormat(String recordDel) {
		this.recordDel = recordDel;
	}

	@Override
	public RecordReader<LongWritable, Text> createRecordReader(
			InputSplit split, TaskAttemptContext context) {
		String delimiter = context.getConfiguration().get(
				"textinputformat.record.delimiter");
		if (recordDel != null) {
			delimiter = recordDel;
		}
		byte[] recordDelimiterBytes = null;
		if (null != delimiter){
			try {
				recordDelimiterBytes = decode(delimiter).getBytes("UTF-8");
			} catch (UnsupportedEncodingException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		return new LineRecordReader(recordDelimiterBytes);
	}
	/**
	 * 工作流传过来的列分隔符,有可能是特殊字符,用八进制或者十六进制表示
	 * @throws IOException 
	 */
	public static String decode(String str) throws IOException {
		String re = str;
		if (str != null && str.startsWith("\\")) {
			str = str.substring(1, str.length());
			String[] chars = str.split("\\\\");
			byte[] bytes = new byte[chars.length];
			for (int i = 0; i < chars.length; i++) {
				if (chars[i].equals("t")) {
					bytes[i] = 9;
				} else if (chars[i].equals("r")) {
					bytes[i] = 13;
				} else if (chars[i].equals("n")) {
					bytes[i] = 10;
				} else if (chars[i].equals("b")) {
					bytes[i] = 8;
				} else {
					bytes[i] = Byte.decode(chars[i]);
				}
			}
			try {
				re = new String(bytes, "UTF-8");
			} catch (UnsupportedEncodingException e) {
				throw new IOException(str, e);
			}
		}
		return re;
	}

}

class MyStorageOutputFormat extends TextOutputFormat<WritableComparable, Tuple> {

	private final byte fieldDel;

	private final String recordDel;

	public MyStorageOutputFormat(byte delimiter) {
		this(delimiter, "\n");
	}

	public MyStorageOutputFormat(byte delimiter, String recordDel) {
		this.fieldDel = delimiter;
		this.recordDel = recordDel;
	}

	protected static class MyRecordWriter extends
			TextOutputFormat.LineRecordWriter<WritableComparable, Tuple> {

		private static byte[] newline;

		private final byte fieldDel;

		public MyRecordWriter(DataOutputStream out, byte fieldDel)
				throws UnsupportedEncodingException {
			this(out, fieldDel, "\n".getBytes("UTF-8"));
		}

		public MyRecordWriter(DataOutputStream out, byte fieldDel, byte[] record) {
			super(out);
			this.fieldDel = fieldDel;
			this.newline = record;
		}

		public synchronized void write(WritableComparable key, Tuple value)
				throws IOException {
			int sz = value.size();
			for (int i = 0; i < sz; i++) {
				StorageUtil.putField(out, value.get(i));
				if (i != sz - 1) {
					out.writeByte(fieldDel);
				}
			}
			out.write(newline);
		}
	}

	@Override
	public RecordWriter<WritableComparable, Tuple> getRecordWriter(
			TaskAttemptContext job) throws IOException, InterruptedException {
		Configuration conf = job.getConfiguration();
		boolean isCompressed = getCompressOutput(job);
		CompressionCodec codec = null;
		String extension = "";
		if (isCompressed) {
			Class<? extends CompressionCodec> codecClass = getOutputCompressorClass(
					job, GzipCodec.class);
			codec = (CompressionCodec) ReflectionUtils.newInstance(codecClass,
					conf);
			extension = codec.getDefaultExtension();
		}
		Path file = getDefaultWorkFile(job, extension);
		FileSystem fs = file.getFileSystem(conf);
		if (!isCompressed) {
			FSDataOutputStream fileOut = fs.create(file, false);
			return new MyRecordWriter(fileOut, fieldDel,
					this.recordDel.getBytes());
		} else {
			FSDataOutputStream fileOut = fs.create(file, false);
			return new MyRecordWriter(new DataOutputStream(
					codec.createOutputStream(fileOut)), fieldDel,
					this.recordDel.getBytes());
		}
	}

}

本人试验 \001 和 \002同样可以

grunt> register  /home/pig/pig-0.11.0/udflib/myStorage.jar 
grunt> cat X;
keyDataKNZKCZY:ZDKJS:616150:AFS:3842708d_20131219194420-642464756keyDataKNZKCZY:ZDKJS:616614:AFS:3843920d_20131219194420-642464756keyDataKNZKCZY:ZDKJS:616661:AFS:3844040d_20131219194420-642464756
grunt> a = load 'X' using com.hcr.hadoop.pig.MyStorage('\\001','\\002');
grunt> dump a;
(keyData,KNZKCZY:ZDKJS:616150:AFS:3842708,d_20131219194420-642464756)
(keyData,KNZKCZY:ZDKJS:616614:AFS:3843920,d_20131219194420-642464756)
(keyData,KNZKCZY:ZDKJS:616661:AFS:3844040,d_20131219194420-642464756)
grunt>


有的时候如果加载模式不想指定具体模式（比如太多了字段，或者不够公有化）就想使用已存在的模式

实现LoadMetadata接口，然后

重写



@Override
public ResourceSchema getSchema(String location, Job job)
throws IOException {
ResourceSchema rs=new ResourceSchema();
            FieldSchema c1 = new FieldSchema("c1", DataType.INTEGER);  
            FieldSchema c2 = new FieldSchema("c2", DataType.INTEGER);
            FieldSchema c3 = new FieldSchema("c3", DataType.DOUBLE);
            ResourceFieldSchema fs1 =new ResourceFieldSchema(c1);
            ResourceFieldSchema fs2 =new ResourceFieldSchema(c2);
            ResourceFieldSchema fs3 =new ResourceFieldSchema(c3);
            rs.setFields(new ResourceFieldSchema[]{fs1,fs2,fs3});
            return rs;

}


这一个简单的例子中就返回了直接使用模式的形式 

grunt> register  /home/pig/pig-0.11.0/udflib/myStorage.jar            
grunt> a = load 'student' using com.hcr.hadoop.pig.MyStorage(',','/');
grunt> describe a;
a: {c1: int,c2: int,c3: double}
grunt> b = foreach  a generate c1,c2,c3;
grunt> describe b;
b: {c1: int,c2: int,c3: double}

hive udf
yangxiangpao的专栏
04-30 711
转载自：http://blog.csdn.net/yfkiss/article/details/7885262 今天有同事来问一个我写过的UDF的问题，想起之前貌似写过一篇这样的文章，草稿箱里找了下，确实有，躺了一年半了，发出来，也许对某些同学有帮助~ HIVE允许用户使用UDF（user defined function）对数据进行处理。 用户可以使用‘show f
Hadoop技术与应用 第六、七章测验
m0_74394367的博客
10-14 781
Hadoop技术与应用 第六、七章测验
Hadoop技术与应用的习题
m0_55834564的博客
11-23 2850
28、Region Server是Google的论文《Bigtable：一个分布式的结构化数据存储系统》中描述的BigTable的组成部分。17、Google的论文《Google File System》提到：还依赖一个高可用的、序列化的分布式锁服务组件，叫Chubby。B.GFS存储的文件都被分割成固定大小的块，每个块都会被复制到多个块服务器上（可靠性）。块的冗余度默认为3。3、GFS 存储的文件都被分割成固定大小的块,每个块都会复制到多个块服务器上（可靠性），请问默认冗余存储几份？
学习Hadoop第三十三课（Hive自定义UDF）
u012453843的专栏
11-07 3830
上节课我们一起学习了Hive进行多表联合查询，这节课我们一起来学习一下Hive的自定义UDF。 第一步：创建Hive工程       我们这里为了简单就不用Maven了，而是直接使用lib包并把我们需要的jar包放到lib当中。如下所示。       我们需要把hive的lib下的所有的包放到lib下，hive的jar包所在的位置如下图所示。      光导hive的包还不行，我们
(转)Pig 重写加载函数和存储函数UDF
weixin_30873847的博客
04-18 177
pig自带的pigstorage不能指定行分隔符，所以自己重写了一个简单的UDF类，可以指定列和行的分隔符，之前研究过的简单的， http://blog.csdn.net/ruishenh/article/details/12048067 但是弊端大，所以这次重写一下。 操作步骤打好包上传到服务器， grunt> register /home/pig/pig-0.1...
pig udf java_如何给Apache Pig自定义UDF函数？
weixin_36082987的博客
02-19 258
近日由于工作所需，需要使用到Pig来分析线上的搜索日志数据，散仙本打算使用hive来分析的，但由于种种原因，没有用成，而Pig(pig0.12-cdh)散仙一直没有接触过，所以只能临阵磨枪了，花了两天时间，大致看完了pig官网的文档，在看文档期间，也是边实战边学习，这样以来，对pig的学习，会更加容易，当然本篇不是介绍如何快速学好一门框架或语言的文章，正如标题所示，散仙打算介绍下如何在Pig中，使...
pig 教程及 自定义udf 的java版
FREEDOM
03-21 978
pig教程https://www.w3cschool.cn/apache_pig/ Apache Pig 用户定义函数（UDF） 原文：https://www.w3cschool.cn/apache_pig/apache_pig_user_defined_functions.html，略有改动 除了内置函数之外，Apache Pig还为UserDefinedFunction（UDF：...
hive自定义udf、udtf
mannnn__的博客
09-11 237
创建mavena项目，引入依赖 <dependency> <groupId>org.apache.hive</groupId> <artifactId>hive-exec</artifactId> <version>1.2.1</version> ...
HaDoop_Pig_Store格式
AngusDavis的博客
09-07 697
PigStorage 默认情况 对应使用制定分隔符分割的文本格式，默认为 tab BinStorage   map/reduce job 的存储方式，用户也可以使用（可以 load 也可以 store），builtin； JsonLoader/JsonStorage   前者需要指定 schema，builtin TextLoader   用来读入文本
5.自定义UDF
resilienter的博客
02-21 427
自定义UDF和窗口 普通UDF Flink暴露了所有udf函数的接口(实现方式为接口或者抽象类)。例如MapFunction, FilterFunction, ProcessFunction等等。我们可以对这些函数进行自定义,继承这个类,重写其中的方法即可. 富函数 相比于普通的UDF,富函数实际上提供了额外的open方法和close提供给用户做初始化和清理的操作.另外，getRuntimeCon...
Hive 自定义UDF函数
muyingmiao的专栏
09-25 660
在使用hive中，有时要根据业务需求自定义一些函数，下面是自定义函数的步骤 1.新建一个maven项目，在项目的pom文件中引入依赖 <dependency> <groupId>org.apache.hive</groupId> <artifactId>hive-exec</a...
Hive内置函数和自定义函数(UDF、UDTF)
weixin_43230682的博客
07-01 882
内置函数 在Hive中查看所有的内置函数和使用方法命令： SHOW FUNCTIONS; DESCRIBE FUNCTION <function_name>; DESCRIBE FUNCTION EXTENDED <function_name>; 内置函数详情可以查看官方文档： https://cwiki.apache.org/confluence/display/Hive/LanguageManual+UDF#LanguageManualUDF-Built-inOperators
Pig自定义过滤UDF和加载UDF
weixin_33757609的博客
09-04 250
Pig是一种数据流编程语言，由一系列操作和变换构成，每一个操作或者变换都对输入进行处理，然后产生输出结果，整体操作表示一个数据流。Pig的执行环境将数据流翻译为可执行的内部表示，在Pig内部，这些变换操作被转换为一系列的MapReduce作业。 Pig自身有许多个方法，有时候需要我们自己定制特定的处理方法即UDF。 UDF具体的步骤如...
（转）PIG 的几种 storage
The Big Data Way
02-07 527
PIG 的几种 storage PIG 现在除了默认的 PigStorage（对应使用制定分隔符分割的文本格式，默认为 tab） 以外还提供了 BinStorage，默认情况下 map/reduce job 的存储方式，用户也可以使用（可以 load 也可以 store），builtin； JsonLoader/JsonStorage，前者需要指定 schema，builtin Tex...
pig 指定行分割符和列分隔符号
幸运小侯子
09-26 256
由于我们的hdfs上抽取的数据是存储行分隔符和列分割符不是用的\n和\t。所以就想能看看是否能指定行分隔符，查了半天没查到。。可能是查找能力有限，呵呵，后来下载下来pig-0.11.0的源码看了一下PigStorage的类，输入inputFormat类指定了就是PigTextInputFormat，这个类直接集成了org.apache.hadoop.mapreduce.lib.input.Text...
Pig学习之 UDF
乄浅醉的专栏
06-20 1555
Eval function详细点击[官方文档](http://pig.apache.org/docs/r0.16.0/udf.html#eval-functions) Algebraic Interface代数函数实现了 这个接口，并提供了处理整个bag的机制。结果通常必须是scalar类型的，例如，代数函数的结果不能是 tuple、bag或者map类型。这个函数的特性是它不能处理未经过排序的整个数
Pig用户自定义函数（UDF）
热门推荐
zythy的专栏
01-15 1万+
以词频统计为例，讲解Pig的用户自定义函数（UDF）。
Apache Pig学习笔记之内置函数（三）
三劫散仙
03-03 381
[img]http://dl2.iteye.com/upload/attachment/0105/3491/7c7b3bef-0dda-3ac6-8cdb-1ecc1dd9c194.jpg[/img] 1 简介 Pig附带了一些的内置函数，这些函数包括（转换函数，加载和存储函数，数学函数，字符串函数，以及包和元组函数），在Pig里面主要有二种函数分别是内置函数和自定义的UDF函数，他们区别...
数据分析引擎：Pig
px的博客
01-12 656
Pig简述 Pig是一个用来处理大规模数据集的平台，由Yahoo！贡献给Apache Pig可以简化MapReduce仸务的开发 Pig可以看做hadoop的客户端软件，可以连接到hadoop集群迕行数据分析工作 Pig方便不熟悉java的用户，使用一种较为简便的类似二SQL的面向数据流的语言pig Latin迕行数据处理 Pig Latin可以迕行排序、过滤、求和、分组、关联等常用操作...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值