【详解】Hive自定义函数

import org.apache.hadoop.hive.ql.exec.UDF;
import org.apache.hadoop.io.Text;

public class UpperCaseUDF extends UDF {
    public Text evaluate(Text str) {
        if (str == null) {
            return null;
        }
        return new Text(str.toString().toUpperCase());
    }
}

2.2 打包与上传

编译上述 Java 类，并将其打包成 JAR 文件。然后，将 JAR 文件上传到 HDFS 上，以便 Hive 可以访问它。

2.3 在 Hive 中注册 UDF

使用 ADD JAR 命令将 JAR 文件添加到 Hive 中，然后使用 CREATE TEMPORARY FUNCTION 命令来创建临时函数：

ADD JAR hdfs://path/to/your/jarfile.jar;
CREATE TEMPORARY FUNCTION upper_case AS 'com.example.UpperCaseUDF';

2.4 使用 UDF

现在可以在 Hive 查询中使用新创建的 UDF 了：

SELECT upper_case(name) FROM employees;

3. 创建 UDAF

3.1 编写 UDAF 类

UDAF 的实现相对复杂，需要实现 org.apache.hadoop.hive.ql.udf.generic.GenericUDAFResolver 接口。这里以计算平均值为例：

import org.apache.hadoop.hive.ql.exec.UDAF;
import org.apache.hadoop.hive.ql.exec.UDAFEvaluator;
import org.apache.hadoop.io.DoubleWritable;

public class AverageUDAF implements UDAF {

    public static class AverageEvaluator implements UDAFEvaluator {
        private DoubleWritable result = new DoubleWritable(0);
        private long count = 0;

        public void init() {
            result.set(0);
            count = 0;
        }

        public boolean iterate(DoubleWritable value) {
            if (value != null) {
                result.set(result.get() + value.get());
                count++;
            }
            return true;
        }

        public DoubleWritable terminatePartial() {
            return result;
        }

        public boolean merge(DoubleWritable other) {
            if (other != null) {
                result.set(result.get() + other.get());
                count++;
            }
            return true;
        }

        public DoubleWritable terminate() {
            if (count > 0) {
                result.set(result.get() / count);
            }
            return result;
        }
    }
}

3.2 注册与使用 UDAF

注册和使用 UDAF 的步骤与 UDF 类似，只需确保正确引用了 UDAF 的类路径。

ADD JAR hdfs://path/to/your/jarfile.jar;
CREATE TEMPORARY FUNCTION avg_custom AS 'com.example.AverageUDAF';

SELECT avg_custom(salary) FROM employees;

4. 创建 UDTF

4.1 编写 UDTF 类

UDTF 需要实现 org.apache.hadoop.hive.ql.udf.generic.GenericUDTF 接口。以下是一个简单的例子，该函数将输入的字符串拆分为多个单词：

import org.apache.hadoop.hive.ql.exec.UDF;
import org.apache.hadoop.hive.ql.udf.generic.GenericUDTF;
import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector;
import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspectorFactory;
import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorFactory;
import org.apache.hadoop.hive.serde2.objectinspector.primitive.StringObjectInspector;

import java.util.ArrayList;

public class ExplodeStringUDTF extends GenericUDTF {
    @Override
    public StructObjectInspector initialize(ObjectInspector[] args) throws UDFArgumentException {
        if (args.length != 1) {
            throw new UDFArgumentException("explode_string takes only one argument");
        }
        if (args[0].getCategory() != ObjectInspector.Category.PRIMITIVE) {
            throw new UDFArgumentException("explode_string only takes string as parameter");
        }
        ArrayList<String> fieldNames = new ArrayList<>();
        ArrayList<ObjectInspector> fieldOIs = new ArrayList<>();
        fieldNames.add("word");
        fieldOIs.add(PrimitiveObjectInspectorFactory.javaStringObjectInspector);
        return ObjectInspectorFactory.getStandardStructObjectInspector(fieldNames, fieldOIs);
    }

    @Override
    public void process(Object[] record) throws HiveException {
        String str = ((StringObjectInspector) record[0]).getPrimitiveJavaObject();
        for (String word : str.split("\\s+")) {
            forward(word);
        }
    }

    @Override
    public void close() throws HiveException {
        // 清理工作
    }
}

4.2 注册与使用 UDTF

同样地，注册和使用 UDTF 也类似于 UDF 和 UDAF。

ADD JAR hdfs://path/to/your/jarfile.jar;
CREATE TEMPORARY FUNCTION explode_string AS 'com.example.ExplodeStringUDTF';

SELECT word FROM explode_string('Hello world from Hive') t;

通过自定义函数，我们可以极大地扩展 Hive 的功能，解决更多复杂的业务需求。无论是简单的 UDF、聚合的 UDAF 还是生成多行记录的 UDTF，都能根据具体的应用场景灵活选择和实现。希望本文能帮助你更好地理解和使用 Hive 自定义函数。

Apache Hive 是一个基于 Hadoop 构建的数据仓库工具，它允许用户使用 SQL 语法查询存储在 Hadoop 分布式文件系统（HDFS）中的数据。Hive 支持用户通过编写自定义函数（UDF，User-Defined Functions）来扩展其功能。这些函数可以用于处理特定的数据转换或计算任务，是增强 Hive 查询能力的重要手段。

下面我将提供一个简单的 UDF 示例，该示例展示了如何创建一个自定义函数来判断一个字符串是否为回文串。这个例子假设你已经有一个运行中的 Hive 环境，并且具备基本的 Java 编程知识。

步骤 1: 创建 Java 类

首先，你需要创建一个 Java 类来实现 org.apache.hadoop.hive.ql.exec.UDF 接口。在这个类中，我们将定义一个方法来检查传入的字符串是否为回文。

import org.apache.hadoop.hive.ql.exec.UDF;
import org.apache.hadoop.io.Text;

public class IsPalindromeUDF extends UDF {
    public Text evaluate(Text str) {
        if (str == null || str.toString().isEmpty()) {
            return new Text("false");
        }
        String original = str.toString();
        String reversed = new StringBuilder(original).reverse().toString();
        return new Text(original.equals(reversed) ? "true" : "false");
    }
}

步骤 2: 打包并上传到 HDFS

编译上述 Java 代码，并将其打包成 JAR 文件。然后，将此 JAR 文件上传到 HDFS，以便 Hive 可以访问。

# 假设你的 JAR 文件名为 ispalindromeudf.jar
hadoop fs -put ispalindromeudf.jar /user/hive/udfs/

步骤 3: 在 Hive 中注册 UDF

接下来，在 Hive 中注册这个新的 UDF。这通常需要指定 JAR 文件的位置和类名。

ADD JAR /user/hive/udfs/ispalindromeudf.jar;
CREATE TEMPORARY FUNCTION is_palindrome AS 'com.example.IsPalindromeUDF';

步骤 4: 使用 UDF

现在你可以像使用任何内置函数一样使用新创建的 UDF 了。

SELECT word, is_palindrome(word) FROM words_table;

这里，words_table 是一个包含单词列表的表，word 列包含了要检查的单词。查询将返回每个单词及其是否为回文的结果。

注意事项

确保你的类路径正确无误。
如果在生产环境中使用 UDF，请考虑性能优化，比如避免不必要的对象创建等。
测试 UDF 的所有边界条件，确保其健壮性和准确性。

通过以上步骤，你就可以成功地在 Hive 中添加并使用自定义函数了。这对于处理特定类型的数据非常有用，尤其是在标准 Hive 函数无法满足需求时。Apache Hive 是一个基于 Hadoop 的数据仓库工具，可以将结构化的数据文件映射为一张数据库表，并提供简单的 SQL 查询功能，可以将 SQL 语句转换为 MapReduce 任务进行运行。为了增强 Hive 的功能，用户可以通过编写自定义函数（UDF）来实现特定的数据处理逻辑。

Hive 自定义函数主要分为以下几种类型：

User Defined Function (UDF)：用于处理单行记录并返回单个结果。
User Defined Aggregate Function (UDAF)：用于聚合多行记录并返回单个结果。
User Defined Table Generating Function (UDTF)：用于处理单行记录并返回多行记录。

1. User Defined Function (UDF)

UDF 是最常用的自定义函数类型，主要用于处理单行记录并返回单个结果。下面是一个简单的 UDF 示例，该示例定义了一个将字符串转换为大写的函数。

步骤 1: 创建 Java 类

首先，需要创建一个 Java 类，并继承 org.apache.hadoop.hive.ql.udf.generic.GenericUDF 类。

import org.apache.hadoop.hive.ql.exec.UDF;
import org.apache.hadoop.io.Text;

public class UpperCaseUDF extends UDF {
    public Text evaluate(Text input) {
        if (input == null) {
            return null;
        }
        return new Text(input.toString().toUpperCase());
    }
}

步骤 2: 打包和上传

将上述代码编译并打包成 JAR 文件，然后将 JAR 文件上传到 Hadoop 集群中。

步骤 3: 在 Hive 中注册 UDF

在 Hive 中使用 ADD JAR 命令加载 JAR 文件，并使用 CREATE TEMPORARY FUNCTION 命令注册 UDF。

ADD JAR /path/to/your/jarfile.jar;
CREATE TEMPORARY FUNCTION upper_case AS 'com.example.UpperCaseUDF';

步骤 4: 使用 UDF

在 Hive 查询中使用自定义的 UDF。

SELECT upper_case(name) FROM employees;

2. User Defined Aggregate Function (UDAF)

UDAF 用于聚合多行记录并返回单个结果。下面是一个简单的 UDAF 示例，该示例定义了一个计算平均值的函数。

步骤 1: 创建 Java 类

首先，需要创建一个 Java 类，并实现 org.apache.hadoop.hive.ql.udf.generic.GenericUDAFResolver 接口。

import org.apache.hadoop.hive.ql.exec.UDAF;
import org.apache.hadoop.hive.ql.exec.UDAFEvaluator;
import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector;
import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorFactory;

public class AverageUDAF implements UDAF {

    public static class AverageEvaluator implements UDAFEvaluator {
        private double sum = 0.0;
        private int count = 0;

        @Override
        public void init() {
            sum = 0.0;
            count = 0;
        }

        @Override
        public boolean iterate(ObjectInspector[] arguments, Object[] values) {
            if (values[0] != null) {
                double value = ((DoubleWritable) values[0]).get();
                sum += value;
                count++;
            }
            return true;
        }

        @Override
        public double terminatePartial() {
            return sum / count;
        }

        @Override
        public boolean merge(Object partial) {
            if (partial != null) {
                double partialResult = ((DoubleWritable) partial).get();
                sum += partialResult * count;
                count++;
            }
            return true;
        }

        @Override
        public double terminate() {
            return sum / count;
        }
    }

    @Override
    public UDAFEvaluator getEvaluator(TypeInfo[] parameters) throws SemanticException {
        if (parameters.length != 1 || !parameters[0].equals(TypeInfoFactory.doubleTypeInfo)) {
            throw new UDFArgumentTypeException(0, "Only one double argument is accepted");
        }
        return new AverageEvaluator();
    }
}

步骤 2: 打包和上传

将上述代码编译并打包成 JAR 文件，然后将 JAR 文件上传到 Hadoop 集群中。

步骤 3: 在 Hive 中注册 UDAF

在 Hive 中使用 ADD JAR 命令加载 JAR 文件，并使用 CREATE TEMPORARY FUNCTION 命令注册 UDAF。

ADD JAR /path/to/your/jarfile.jar;
CREATE TEMPORARY FUNCTION avg_custom AS 'com.example.AverageUDAF';

步骤 4: 使用 UDAF

在 Hive 查询中使用自定义的 UDAF。

SELECT avg_custom(salary) FROM employees;

3. User Defined Table Generating Function (UDTF)

UDTF 用于处理单行记录并返回多行记录。下面是一个简单的 UDTF 示例，该示例定义了一个将字符串拆分为多行的函数。

步骤 1: 创建 Java 类

首先，需要创建一个 Java 类，并实现 org.apache.hadoop.hive.ql.udf.generic.GenericUDTF 接口。

import org.apache.hadoop.hive.ql.exec.UDF;
import org.apache.hadoop.hive.ql.udf.generic.GenericUDTF;
import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector;
import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspectorFactory;
import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorFactory;
import org.apache.hadoop.hive.serde2.objectinspector.primitive.StringObjectInspector;

import java.util.ArrayList;

public class SplitUDTF extends GenericUDTF {

    private StringObjectInspector stringOI;

    @Override
    public void initialize(ObjectInspector[] args) throws UDFArgumentException {
        if (args.length != 2) {
            throw new UDFArgumentException("split takes exactly two arguments");
        }
        if (args[0].getCategory() != ObjectInspector.Category.PRIMITIVE ||
            args[1].getCategory() != ObjectInspector.Category.PRIMITIVE) {
            throw new UDFArgumentException("split only accepts primitive types as arguments");
        }
        this.stringOI = (StringObjectInspector) args[0];
    }

    @Override
    public String toString() {
        return "split";
    }

    @Override
    public void process(Object[] record) throws HiveException {
        String str = stringOI.getPrimitiveJavaObject(record[0]);
        String delimiter = stringOI.getPrimitiveJavaObject(record[1]);
        for (String s : str.split(delimiter)) {
            forward(s);
        }
    }

    @Override
    public void close() throws HiveException {
    }

    @Override
    public ObjectInspector[] getOutputObjectInspector() {
        return new ObjectInspector[]{PrimitiveObjectInspectorFactory.javaStringObjectInspector};
    }
}

步骤 2: 打包和上传

将上述代码编译并打包成 JAR 文件，然后将 JAR 文件上传到 Hadoop 集群中。

步骤 3: 在 Hive 中注册 UDTF

在 Hive 中使用 ADD JAR 命令加载 JAR 文件，并使用 CREATE TEMPORARY FUNCTION 命令注册 UDTF。

ADD JAR /path/to/your/jarfile.jar;
CREATE TEMPORARY FUNCTION split_custom AS 'com.example.SplitUDTF';

步骤 4: 使用 UDTF

在 Hive 查询中使用自定义的 UDTF。

SELECT word
FROM (SELECT split_custom('a,b,c,d', ',') AS (word)) t;

以上是 Hive 自定义函数的基本介绍和示例代码。通过这些自定义函数，可以极大地扩展 Hive 的功能，满足更复杂的数据处理需求。