自定义UDAF函数开发详解

自定义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';