自定义UDAF函数开发详解
UDAF 函数分为如下两部分：
一、负责检查数据类型（Resolver）
二、负责数据执行处理（Evaluator）
第一部分（Resolver）
Resolver 部分继承 AbstractGenericUDAFResolver类，之后只需要重载getEvaluator 方法，AbstractGenericUDAFResolver的源码如下：
public abstract class AbstractGenericUDAFResolver implements GenericUDAFResolver2 {
public AbstractGenericUDAFResolver() {
}
public GenericUDAFEvaluator getEvaluator(GenericUDAFParameterInfo info) throws SemanticException {
if (info.isAllColumns()) {
throw new SemanticException("The specified syntax for UDAF invocation is invalid.");
} else {
return this.getEvaluator(info.getParameters());
}
}
public GenericUDAFEvaluator getEvaluator(TypeInfo[] info) throws SemanticException {
throw new SemanticException("This UDAF does not support the deprecated getEvaluator() method.");
}
}
它根据SQL传入的参数类型,返回正确的evaluator。这里最主要是实现操作符的重载。
UDAF的第一部分代码为
public class GenericUDAFMedian extends AbstractGenericUDAFResolver {
@Override
public GenericUDAFEvaluator getEvaluator(TypeInfo[] parameters)
throws SemanticException {
if(parameters.length != 1) {
throw new UDFArgumentTypeException(parameters.length-1, "Only 1 parameter is accepted!");
}
ObjectInspector objectInspector = TypeInfoUtils.getStandardJavaObjectInspectorFromTypeInfo(parameters[0]);
if(!ObjectInspectorUtils.compareSupported(objectInspector)) {
throw new UDFArgumentTypeException(parameters.length - 1, "Cannot support comparison of map<> type or complex type containing map<>.");
}
switch (((PrimitiveTypeInfo)parameters[0]).getPrimitiveCategory()) {
case BYTE:
case SHORT:
case INT:
case LONG:
case FLOAT:
case DOUBLE:
return new GenericUDAFMedianEvaluatorDouble();
case STRING:
case BOOLEAN:
default:
throw new UDFArgumentTypeException(0,
"Only numeric type(int long double) arguments are accepted but "
+ parameters[0].getTypeName() + " was passed as parameter of index->1.");
}
}
...........
}
第二部分（Evaluator）
Evaluator部分继承 GenericUDAFEvaluator 类
GenericUDAFEvaluator 类的源码如下：
public abstract class GenericUDAFEvaluator implements Closeable {
GenericUDAFEvaluator.Mode mode;
public static boolean isEstimable(GenericUDAFEvaluator.AggregationBuffer buffer) {
if (!(buffer instanceof GenericUDAFEvaluator.AbstractAggregationBuffer)) {
return false;
} else {
Class<? extends GenericUDAFEvaluator.AggregationBuffer> clazz = buffer.getClass();
GenericUDAFEvaluator.AggregationType annotation = (GenericUDAFEvaluator.AggregationType)AnnotationUtils.getAnnotation(clazz, GenericUDAFEvaluator.AggregationType.class);
return annotation != null && annotation.estimable();
}
}
public GenericUDAFEvaluator() {
}
public void configure(MapredContext mapredContext) {
}
public ObjectInspector init(GenericUDAFEvaluator.Mode m, ObjectInspector[] parameters) throws HiveException {
this.mode = m;
return null;
}
public abstract GenericUDAFEvaluator.AggregationBuffer getNewAggregationBuffer() throws HiveException;
public abstract void reset(GenericUDAFEvaluator.AggregationBuffer var1) throws HiveException;
public void close() throws IOException {
}
public void aggregate(GenericUDAFEvaluator.AggregationBuffer agg, Object[] parameters) throws HiveException {
if (this.mode != GenericUDAFEvaluator.Mode.PARTIAL1 && this.mode != GenericUDAFEvaluator.Mode.COMPLETE) {
assert parameters.length == 1;
this.merge(agg, parameters[0]);
} else {
this.iterate(agg, parameters);
}
}
public Object evaluate(GenericUDAFEvaluator.AggregationBuffer agg) throws HiveException {
return this.mode != GenericUDAFEvaluator.Mode.PARTIAL1 && this.mode != GenericUDAFEvaluator.Mode.PARTIAL2 ? this.terminate(agg) : this.terminatePartial(agg);
}
public abstract void iterate(GenericUDAFEvaluator.AggregationBuffer var1, Object[] var2) throws HiveException;
public abstract Object terminatePartial(GenericUDAFEvaluator.AggregationBuffer var1) throws HiveException;
public abstract void merge(GenericUDAFEvaluator.AggregationBuffer var1, Object var2) throws HiveException;
public abstract Object terminate(GenericUDAFEvaluator.AggregationBuffer var1) throws HiveException;
public GenericUDAFEvaluator getWindowingEvaluator(WindowFrameDef wFrmDef) {
return null;
}
public abstract static class AbstractAggregationBuffer implements GenericUDAFEvaluator.AggregationBuffer {
public AbstractAggregationBuffer() {
}
public int estimate() {
return -1;
}
}
/** @deprecated */
public interface AggregationBuffer {
}
public static enum Mode {
PARTIAL1,
PARTIAL2,
FINAL,
COMPLETE;
private Mode() {
}
}
@Retention(RetentionPolicy.RUNTIME)
public @interface AggregationType {
boolean estimable() default false;
}
}
代码中 重点介绍 Mode 的4个枚举类型，这四个枚举类型就代表整个UDAF函数的代码执行过程，也就是mapreduce的执行过程。
根据mapreduce执行原理:
在map阶段（数据入口）会执行 PARTIAL1(调用iterate和terminatePartial) 和 COMPLETE (iterate和terminate)
在combiner阶段会执行 PARTIAL2(调用merge和terminatePartial)
在reduce阶段会执行 FINAL (调用merge和terminate)
那么针对GenericUDAFEvaluator 类中每个方法都做什么我们重点说一下：
- init ： 在 PARTIAL1，PARTIAL2，FINAL，COMPLETE 这四个阶段都会执行init方法，接收输入参数，设置UDAF的返回类型(return PrimitiveObjectInspectorFactory.writableLongObjectInspector;)
- reset : 重置聚合
- iterate : 迭代parameters表示的原始数据并保存到AggregationBuffer中
- terminatePartial : 以持久化的方式返回AggregationBuffer表示部分聚合结果，这里的持久化意味着返回值只能Java基础类型、数组、基础类型包装器、Hadoop的Writables、Lists和Maps。即使实现了java.io.Serializable，也不要使用自定义的类
- merge : 相当于reduce阶段(也存在于Combine阶段)，用于最后的聚合。Object类型的partial参数与- terminatePartial返回值一致，AggregationBuffer参数与上述一致
- terminate : 返回由agg表示的最终结果
- getNewAggregationBuffer :用于返回存储临时聚合结果的 GenericUDAFEvaluator.AggregationBuffer对象
上述这些方法基本按照init、getNewAggregationBuffer、iterate、terminatePartial、merge、terminate的顺序调用
执行流程是：
1、init方法
2、自行定义一个类实现AggregationBuffer类(相当于自定义保存数据聚集的存储类型)
3、调用getNewAggregationBuffer()实例化自定义的AggregationBuffer类
4、调用iterate()遍历每一行数据，存入自定义的AggregationBuffer类的属性中
5、调用terminatePartial()进行部分聚合
6、调用merge()进行最终聚合
7、调用terminate()最终处理，返回最后结果(返回的数据类型要和上面每个过程中的数据类型以及init定义的返回类型一致)
总结
编写自定义UDAF函数，主要就是要掌握运行原理和机制，作为小白，也是花了点时间整理了一下。个人认为重点是理解Mode的4种枚举类型，以及所对应的mapreduce执行过程。其次，要理解在执行过程中调用了那些方法，方法的作用是什么。这样才能完成UDAF函数的自定义开发工作
永久UDAF函数设置
1. 将jar包上传至 HDFS
hdfs://nameservice1/user/hive/jar/median_udaf_double.jar
2. 创建永久UDAF函数
create function medianUDAF as 'UDAF.GenericUDAFMedian' using jar 'hdfs://nameservice1/user/hive/jar/median_udaf_double.jar';
