UDF函数开发

最新推荐文章于 2024-05-12 09:37:02 发布
最新推荐文章于 2024-05-12 09:37:02 发布
阅读量2.5k 收藏 2
点赞数 1
文章标签： d s
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lsb19930706/article/details/81780473
版权

Hive有两个不同的接口编写UDF程序。一个是操作简单数据类型的UDF接口，一个是操作复杂类型的GenericUDF接口。

UDF接口暂不讨论。

下面看一个例子：

ary建表语句：

create table ary(
array1 array<struct<id:string,name:string>>,
array2 array<struct<addr:string,id:string,dt:String>>
)
row format delimited fields terminated by '\t'
map keys terminated by ',';

ary表中数据如下：

hive > select * from ary;
OK
ary.array1      ary.array2
[{"id":"001","name":"明明"}]    [{"addr":"杨浦","id":"001","dt":"20180703"}]
[{"id":"002","name":"阿达"}]    [{"addr":"黄浦","id":"004","dt":"20180629"}]
[{"id":"003","name":"阿珂"}]    [{"addr":"浦东","id":"003","dt":"20180817"}]
[{"id":"004","name":"小宝"}]    [{"addr":"松江","id":"002","dt":"20180623"}]

我们需要的结果：

hive > select aa(array1,array2,'id') from ary;                
OK
_c0
[{"id":"001","name":"明明","addr":"杨浦","dt":"20180703"}]
[{"id":"NULL","name":"NULL","addr":"NULL","dt":"NULL"}]
[{"id":"003","name":"阿珂","addr":"浦东","dt":"20180817"}]
[{"id":"NULL","name":"NULL","addr":"NULL","dt":"NULL"}]

函数逻辑：

操作一行数据，通过传入的字段名对两个结构体类型的数组中字段值进行匹配，值相等则返回匹配到的全部值（当然id只匹配一个），否则全部置空

编写UDF自定义函数：

package com.paic.gbd.udfarray;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.hive.ql.udf.generic.GenericUDF;
import org.apache.commons.logging.LogFactory;
import org.apache.commons.logging.Log;
import org.apache.hadoop.hive.ql.exec.UDFArgumentException;
import org.apache.hadoop.hive.ql.exec.UDFArgumentLengthException;
import org.apache.hadoop.hive.ql.exec.UDFArgumentTypeException;
import org.apache.hadoop.hive.ql.metadata.HiveException;
import org.apache.hadoop.hive.serde2.lazy.LazyString;
import org.apache.hadoop.hive.serde2.lazy.LazyStruct;
import org.apache.hadoop.hive.serde2.lazy.LazyMap;
import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector;
import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector.Category;
import org.apache.hadoop.hive.serde2.objectinspector.ListObjectInspector;
import org.apache.hadoop.hive.serde2.objectinspector.MapObjectInspector;
import org.apache.hadoop.hive.serde2.objectinspector.StructObjectInspector;
import org.apache.hadoop.hive.serde2.objectinspector.StandardListObjectInspector;
import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspectorFactory;
import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspectorUtils;
import org.apache.hadoop.hive.serde2.objectinspector.StructField;
import org.apache.hadoop.hive.serde2.objectinspector.PrimitiveObjectInspector;
import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorFactory;
import org.apache.hadoop.hive.serde2.objectinspector.primitive.StringObjectInspector;
import java.util.ArrayList;
import java.util.List;
 
public class GenericArrayUnion extends GenericUDF {

	//定义输出日志，方便调试，在hive.log里面查看，该文件目录在hive-log4j.properties配置文件里查看
	 static final Log LOG = LogFactory.getLog(GenericArrayUnion.class.getName());
     输入变量定义
	 private static final int ARG_COUNT = 3; // Number of arguments to this UDF
	 private static final String FUNC_NAME = "array_union"; // External Name
     private ListObjectInspector arrayOI;
     private ListObjectInspector arrayOI2;
     private ObjectInspector strOI;
     
     private StructObjectInspector structOI;
     private StructObjectInspector structOI2;
     private ArrayList<Object> valueList = new ArrayList<Object>(); 
     private ArrayList<Object> valueList2 = new ArrayList<Object>(); 
     int num1=0;
     int num2=0;
     int valueListLength=0;
     int valueList2Length=0;
     @Override
     public ObjectInspector initialize(ObjectInspector[] arguments) throws UDFArgumentException {
    	  arrayOI = (ListObjectInspector)arguments[0];
    	  arrayOI2 = (ListObjectInspector)arguments[1];
    	  strOI = (ObjectInspector)arguments[2];
    	  
          structOI = ((StructObjectInspector)arrayOI.getListElementObjectInspector());
          structOI2 = ((StructObjectInspector)arrayOI2.getListElementObjectInspector());
          
          //判断参数个数
          if (arguments.length != ARG_COUNT) {
  			throw new UDFArgumentException("The function " + FUNC_NAME
  					+ " accepts " + ARG_COUNT + " arguments.");
  			}
          //判断参数1，2的数据类型
          if (!arguments[0].getCategory().equals(Category.LIST) || !arguments[1].getCategory().equals(Category.LIST)) {
  			throw new UDFArgumentException(
  					"\""
  							+ org.apache.hadoop.hive.serde.serdeConstants.LIST_TYPE_NAME
  							+ "\" "
  							+ "expected at function arguments, but \"" + arguments[0].getTypeName()  
  							+ "\" and \"" + arguments[1].getTypeName() + "\" is found.");
  			}
         //数组中结构体结构必须完全一致
  		 if ( structOI.getCategory() != Category.STRUCT 
  				|| structOI2.getCategory() != Category.STRUCT) {
  			throw new UDFArgumentException(
  					"\""
  							+ org.apache.hadoop.hive.serde.serdeConstants.STRUCT_TYPE_NAME
  							+ "\" "
  							+ "expected at ARRAY elements type, but \"" + structOI.getCategory()  
  							+ "\" and \"" + structOI2.getCategory() + "\" is found.");
  		 }
          //判断参数3的数据类型
          if(!arguments[2].getCategory().equals(Category.PRIMITIVE)) {
        	  throw new UDFArgumentException(
    					"\""
    							+ org.apache.hadoop.hive.serde.serdeConstants.PrimitiveTypes
    							+ "\" "
    							+ "expected at function arguments, but \"" + arguments[2].getTypeName()  
    							+  "\" is found.");
          }
          
          //输出结构体类型的数组定义
          ArrayList structFieldNames = new ArrayList();
          ArrayList structFieldObjectInspectors = new ArrayList();
          String value1=null;
          String value2=null;
          valueListLength=0;
          int strOINum1=0;
          for(int i=0;i<structOI.getAllStructFieldRefs().size();i++) {
        	  valueListLength++;
        	  value1=structOI.getAllStructFieldRefs().get(i).toString().substring(2);
        	  structFieldNames.add(value1);
        	  if(ObjectInspectorUtils.getWritableConstantValue(arguments[2]).toString().equals(value1)) {
        		  //定位关联字段在第一个数组中位置
        		  num1=i;
        		  strOINum1++;
        	  }
          }
          if(strOINum1!=1) {
        	  throw new UDFArgumentException(
        			  "第一个数组中必须有一个传参字段"
        			  );
          }
          valueList2Length=0;
          int strOINum2=0;
          for(int i=0;i<structOI2.getAllStructFieldRefs().size();i++) {
        	  valueList2Length++;
        	  value2=structOI2.getAllStructFieldRefs().get(i).toString().substring(2);
        	  if(!ObjectInspectorUtils.getWritableConstantValue(arguments[2]).toString().equals(value2)) {
        		  structFieldNames.add(value2);
        	  }else {
        		//定位关联字段在第二个数组中位置
        		  num2=i;
        		  strOINum2++;
        	  }
          } 
          if(strOINum2!=1) {
        	  throw new UDFArgumentException(
        			  "第二个数组中必须有一个传参字段"
        			  );
          }
	   
	      for(int i=0;i<structFieldNames.size();i++) {
	    	  structFieldObjectInspectors.add( PrimitiveObjectInspectorFactory.writableStringObjectInspector );
	      }

          StructObjectInspector si2;
          si2 = ObjectInspectorFactory.getStandardStructObjectInspector(structFieldNames, structFieldObjectInspectors); 
         
          return ObjectInspectorFactory.getStandardListObjectInspector(si2);
     }
 
     @Override
     public Object evaluate(DeferredObject[] arguments) throws HiveException{
    	 LOG.info("hello1");
    	 LOG.info(num1);LOG.info(num2);
    	 LOG.info(valueListLength);LOG.info(valueList2Length);
    	 
	  int arr_len = arrayOI.getListLength(arguments[0].get());
      
      valueList.clear();
      valueList2.clear();

      
      //遍历array
      String[] value;
      value=new String[valueListLength+valueList2Length-1];
      LOG.info("hello2");
      LOG.info(arr_len);
	  for(int i=0;i<arr_len;i++)
	  { 	//获取第一个数组值
               LazyStruct LStruct = (LazyStruct)arrayOI.getListElement(arguments[0].get(),i);
               //获取struct中的所有value值
               StructObjectInspector s_arrayElementOI = (StructObjectInspector) structOI;
   			   List field_value = s_arrayElementOI.getStructFieldsDataAsList(LStruct);
               valueList.addAll(field_value);
               
            //获取第二个数组值   
               LazyStruct LStruct2 = (LazyStruct)arrayOI2.getListElement(arguments[1].get(),i);
               //获取struct中的所有value值
               StructObjectInspector s_arrayElementOI2 = (StructObjectInspector) structOI2;
   			   List field_value2 = s_arrayElementOI2.getStructFieldsDataAsList(LStruct2);
               valueList2.addAll(field_value2);
               
               LOG.info("hello3");
               //关联字段值相同则添加到输出，否则输出"NULL"
               if(valueList.get(num1).toString().equals(valueList2.get(num2).toString())) {
            	   //添加第一个数组值到输出
            	   LOG.info(valueList.size());
            	   LOG.info(valueList2.size());
            	   for(int j=0;j<valueList.size();j++) {
            		  value[j]=valueList.get(j).toString(); 
            		  LOG.info(value[j]);
            	   }
            	   
            	   //添加第二个数组值到输出
            	   for(int j=0,n=0;j<valueList2.size();j++) {
            		   //添加变量n,用value数组索引j+valueList.size()会出现数组越界
            		   if(j!=num2) {
            			   value[n+valueList.size()]=valueList2.get(j).toString();
            			   LOG.info(value[n+valueList.size()]);
            			   n++; 
            		   }
            	   }
               }else {
            	   for(int j=0;j<value.length;j++) {
            		   value [j]="NULL";
            	   }
               }
              

               
               valueList.clear();
               valueList2.clear();
          }
	  LOG.info("hello8");
	  LOG.info(value.length);
	  Object[] e;	
	  e = new Object[value.length];
	  for(int i=0;i<value.length;i++) {
		  LOG.info(i);
		  e[i]=new Text(value[i]);
	  }
	  
	  ArrayList result = new ArrayList();
	  result.add(e);
	  LOG.info("hello10");
      return result;
     }
   
     @Override
     public String getDisplayString(String[] children) {
          assert( children.length>0 );
 
          StringBuilder sb = new StringBuilder();
          sb.append("array_union(");
          sb.append(children[0]);
          sb.append(")");
 
          return sb.toString();
     }

}

将代码导成jar包上传到linux上，在hive命令行中添加jar包，并创建函数

hive > add jar /home/hadoop/aa.jar;                                    
Added /home/hadoop/aa.jar to class path
Added resource: /home/hadoop/aa.jar
hive > create function aa as 'com.paic.gbd.udfarray.GenericArrayUnion';
OK
Time taken: 0.031 seconds

最终函数生成了前文需要的结果

LSB19930706
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
HIVE UDF函数开发流程
a18033860865的博客
07-26 734
HIVE UDF函数开发流程。
UDF函数开发流程
qiubaifeng的博客
06-13 2040
1。首先编写UDF 继承： org.apache.hadoop.hive.ql.exec.UDF; 需要导入hive-exec-0.13.1-cdh5.3.6.jar 包及hadoop-common-2.5.0-cdh5.3.6.jar eg:package com.paic.nets.pnc.udf; import java.text.SimpleDateFormat;...
最全大数据自定义函数udf，2024年最新大数据开发开发避坑指南
最新发布
2301_82241942的博客
05-12 378
二，udf制作流程。
hiveUDF函数开发
皮皮虾的博客
05-12 302
maven配置 <!-- 添加依赖组件，版本与cdh集群版本相同即可 --> <dependency> <groupId>org.apache.hadoop</groupId> <artifactId>hadoop-assemblies</artifactId> <version>2.5.1</version> </dependency&g
hive之udf函数开发
luo981695830的博客
02-22 895
接上一篇hive开发之maven手动安装jar包，点击可跳转 添加pom依赖，说明version要与环境一致，不然可能会因为版本不一致问题报错 <dependencies> <!--添加Hadoop依赖--> <dependency> <groupId>org.apache.hadoop</groupId > <artifactId>hadoo
Hive UDF函数开发与部署样例
Charlie的博客
03-15 653
Hive UDF函数开发 pom.xml添加hive-exec依赖 创建一个新的Java项目，在pom.xml中添加必要的maven依赖 <dependency> <groupId>org.apache.hadoop</groupId> <artifactId>hadoop-client</artifactId> <version>3.2.2</version> </dependen
UDF函数开发中的坑
fly_sky333的博客
03-23 2879
hive中udf函数遇到的问题和处理方式
Java编写udf函数
mac_kamou的博客
10-27 1632
java编写udf并创建方法
hive UDF函数开发
Xlucas的博客
10-07 2341
编写代码 hive的UDF函数只需要继承UDF这个类就可以，如果重写evaluate方向就可以了，里面的具体实现可以用java来实现这里面的逻辑package function_duf;import org.apache.hadoop.hive.ql.exec.UDF; import org.apache.hadoop.io.Text;public class UDFCOMP extends UD
Hive UDF函数开发及企业规范
大数据研习社
12-30 1521
UDF简称自定义函数，它是Hive函数库的扩展，自定义函数UDF在MapReduce执行阶段发挥作用。开发步骤如下： 1） 给hive.ql.exec.UDF包开发一个自定义函数类，从UDF继承。自定义函数类实现evaluate方法。 2） 在FunctionRegistry类中注册开发的自定义函数类。 3） 打包发布至Hive客户端。
AES解密UDF函数.doc
03-05
### AES解密UDF函数详解 #### 一、概述 在大数据处理领域，尤其是在Hadoop生态体系中的数据处理环节，用户定义的函数（User Defined Function, UDF）扮演着非常重要的角色。它允许开发人员根据特定需求编写自定义...
获取规范薪酬UDF函数.doc
03-05
### 获取规范薪酬UDF函数详解 #### UDF概述与应用场景 在大数据处理中，用户定义的函数（User Defined Function，简称UDF）是Hive SQL的一种扩展机制，它允许开发人员自定义函数来处理特定的数据处理需求。对于...
获取主办单位UDF函数.doc
03-05
因此，开发一个能够识别并提取出主办单位的UDF函数具有很高的实用价值。 #### 实现步骤 1. **代码打包与上传** 首先，需要将编写的Java代码打包成JAR文件。打包完成后，将该JAR文件上传到HDFS的指定目录，例如`/...
Hive UDF开发
12-27
### Hive UDF开发详解 #### 一、引言 在大数据处理领域，Apache Hive作为一款广泛使用的数据仓库工具，能够高效地对存储在Hadoop文件系统中的数据进行查询与管理。然而，对于某些特定的数据处理需求，Hive内置的...
获取规范货币类型UDF函数.doc
03-05
### 获取规范货币类型UDF函数 #### 概述 在大数据处理领域，特别是金融数据分析场景中，经常需要对数据进行标准化处理。对于货币类型的规范化处理是常见需求之一。本篇文章将详细介绍如何创建一个Hive UDF（User ...
K8s 很难么？带你从头到尾捋一遍，不信你学不会
民工哥的博客
02-23 8842
点击关注公众号，回复“1024”获取2TB学习资源！为什么要学习 Kubernetes?虽然 Docker 已经很强大了，但是在实际使用上还是有诸多不便，比如集群管理、资源调度、文件管理等...
Android开发（1） | Fragment 的应用——新闻应用
Jormungand_V的博客
02-21 6400
文章目录 news_item.xml： <TextView xmlns:android="http://schemas.android.com/apk/res/android" android:id="@+id/news_title" android:layout_width="match_parent" android:layout_height="wrap_content" android:lines="1" android:ellipsize="
Visual Studio 2022 有哪些新功能？
热门推荐
学海无涯苦作舟的博客
02-09 2万+
Visual Studio 2022现已与它支持的 .NET 6 一起正式发布。它包括许多新功能和改进，例如可以为您自动完成代码块的 AI IntelliCode。 您可以 从他们的网站下载安装程序。虽然它仍然是新的，但它仍然是 Visual Studio，所以除非您依赖尚未更新的扩展，否则不要害怕尝试一下。 我们将介绍我们发现的最重要的更改，但如果您想逐行阅读补丁说明，可以从 Microsoft 的文档中进行。还有一个描述总体方向的路线图。 终于64位了 Visual Studio 一直是 32 位的，.
Java开发UDF函数
05-12
UDF（User-Defined Function）是用户自定义函数，是Hive中的一种扩展功能。UDF可以让用户定义自己的函数，这些函数可以被Hive SQL语句调用，以实现更复杂的数据处理操作。 下面是一个Java开发UDF函数的示例： 1. 创建Java项目，导入hive-exec和hive-common的依赖。 2. 创建类名为MyUDF的Java类，继承org.apache.hadoop.hive.ql.exec.UDF。 3. 实现evaluate()方法，并根据需要添加其他方法和属性。 ```java package com.example; import org.apache.hadoop.hive.ql.exec.UDF; public class MyUDF extends UDF { public int evaluate(int num) { // 实现UDF的逻辑 return num * 2; } } ``` 4. 打包项目成jar文件并上传到Hive服务器上。 5. 在Hive中注册UDF，使用以下命令： ```sql CREATE FUNCTION my_udf AS 'com.example.MyUDF' USING JAR 'path/to/my-udf.jar'; ``` 6. 在Hive中使用UDF，例如： ```sql SELECT my_udf(10); ``` 上述示例中，创建了一个名为MyUDF的类，实现了一个evaluate()方法，该方法接受一个整数参数并将其乘以2。然后将项目打包成jar文件，并上传到Hive服务器上。最后，在Hive中注册UDF并使用它。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值