Hive中用户自定义函数UDF UDTF UDAF

最新推荐文章于 2024-04-23 14:59:38 发布
最新推荐文章于 2024-04-23 14:59:38 发布
阅读量1.2k 收藏 12
点赞数
分类专栏： hive 文章标签： hive udf
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/houkai18792669930/article/details/106199410
版权

概述      

       Hive 自带了一些函数，比如：max/min 等，但是数量有限，当 Hive 提供的内置函数无法满足你的业务处理需要时，此时就可以考虑使用用户自定义

函数（UDF：user-defined function）根据用户自定义函数类别分为以下三种：

  1. UDF（User-Defined-Function）  一进一出
  2. UDAF（User-Defined Aggregation Function）  聚集函数，多进一出   类似于：count/max/min
  3. UDTF（User-Defined Table-Generating Functions）  一进多出

创建UDF步骤

1.创建工程，引入maven包

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.hl</groupId>
    <artifactId>hive</artifactId>
    <version>0.1</version>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.apache.hive</groupId>
            <artifactId>hive-exec</artifactId>
            <version>2.3.7</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>${maven.compiler.source}</source>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

2.继承相关抽象类，实现UDF

一进一出 UDF

package hive.User_Defined_Functions;
import org.apache.hadoop.hive.ql.exec.UDF;
import org.apache.hadoop.io.Text;
/**
 * @describe:  用户自定义函数 一进一出
 *步骤：
 *  1.继承 org.apache.hadoop.hive.ql.UDF，需要实现 evaluate 函数；evaluate 函数支持重载；
 *  2.hive命令行添加 jar
 *      add jar linux_jar_path
 *  3.hive命令行创建function
 *      create [temporary] function [dbname.]function_name AS class_name;
 *  hive的命令行删除function
 *      Drop [temporary] [dbname.]function_name; 	function [if exists]
 */
public class MyUDF extends UDF {

    /**
     * 实现 evaluate 函数；evaluate 函数支持重载；
     * 注意： UDF必须要有返回类型，可以返回 null，但是返回类型不能为 void
     */
    public Text evaluate(final Text s) {
        if (s == null) {
            return null;
        }
        return new Text(s.toString().toLowerCase());
    }
}
/*
 * 测试：
 *  add jar udf.jar
 *  create temporary function mylower as "hive.User_Defined_Functions.MyUDF";
 *  select mylower(name) from student;
 */

一进多出UDTF

package hive.User_Defined_Functions;
import org.apache.hadoop.hive.ql.exec.UDFArgumentException;
import org.apache.hadoop.hive.ql.metadata.HiveException;
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.StructObjectInspector;
import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorFactory;
import java.util.ArrayList;
import java.util.List;

/**
 * @describe: 通用的用户定义表生成函数（UDTF），为单个输入行生成可变数量的输出行
 * 案例：自定义一个 UDTF 实现将一个任意分割符的字符串切割成独立的单词
 *   输入："hello,world,hadoop,hive"
 *   命令：Myudtf(line, ",")
 *   输出：hello world hadoop hive
 */
public class MyUDTF extends GenericUDTF {
    private ArrayList<String> outList = new ArrayList<>();
    @Override
    public StructObjectInspector initialize(StructObjectInspector argOIs) throws UDFArgumentException {
        //1.定义输出数据的列名和类型
        List<String> fieldNames = new ArrayList<>();
        List<ObjectInspector> fieldOIs = new ArrayList<>();
        //2.添加输出数据的列名和类型
        fieldNames.add("lineToWord");
        fieldOIs.add(PrimitiveObjectInspectorFactory.javaStringObjectInspector);
        return ObjectInspectorFactory.getStandardStructObjectInspector(fieldNames, fieldOIs);
    }

    @Override
    public void process(Object[] args) throws HiveException {
        //1.获取原始数据
        String arg = args[0].toString();
        //2.获取数据传入的第二个参数，此处为分隔符
        String splitKey = args[1].toString();
        //3.将原始数据按照传入的分隔符进行切分
        String[] fields = arg.split(splitKey);
        //4.遍历切分后的结果，并写出
        for (String field : fields) {
            //集合为复用的，首先清空集合
            outList.clear();
            //将每一个单词添加至集合
            outList.add(field);
            //将集合内容写出
            forward(outList);
        }
    }
    @Override
    public void close() throws HiveException {
    }
}

多进一出UDAF

UDAF需要实现下面的类

org.apache.hadoop.hive.ql.udf.generic.AbstractGenericUDAFResolver
org.apache.hadoop.hive.ql.udf.generic.GenericUDAFEvaluator

demo1 多个数字求和

package hive.User_Defined_Functions;
import org.apache.hadoop.hive.ql.metadata.HiveException;
import org.apache.hadoop.hive.ql.udf.generic.GenericUDAFEvaluator;
import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector;
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.PrimitiveObjectInspectorUtils;
import org.apache.hadoop.io.LongWritable;

/**
 * @describe: 多进一出，两个数求sum
 */
public class MyUDAFSUM extends GenericUDAFEvaluator {
    //输入数据序列化
    private PrimitiveObjectInspector inputOI;
    //返回值
    private LongWritable result;
    private boolean warned;

    public MyUDAFSUM() {
        this.warned = false;
    }

    /**
     * 这个方法返回udaf的返回类型。这里定义返回类型为long
     */
    @Override
    public ObjectInspector init(GenericUDAFEvaluator.Mode m, ObjectInspector[] parameters) throws HiveException {
        assert (parameters.length == 1);
        //输入类型初始化
        super.init(m, parameters);
        result = new LongWritable(0L);
        inputOI = ((PrimitiveObjectInspector) parameters[0]);
        //输出
        return PrimitiveObjectInspectorFactory.writableLongObjectInspector;
    }

    /**
     * 创建新的聚合计算需要的内存，用来存储mapper，combiner，reducer运算过程中的相加总和。
     *
     * @return GenericUDAFEvaluator.AggregationBuffer 用来存储聚集过程期间的结果
     */
    @Override
    public GenericUDAFEvaluator.AggregationBuffer getNewAggregationBuffer() throws HiveException {
        SumLong result = new SumLong();
        reset(result);
        return result;
    }

    /**
     * 重置聚合结果，可以方便重复使用相同的聚合
     */
    @Override
    public void reset(GenericUDAFEvaluator.AggregationBuffer agg) throws HiveException {
        SumLong myagg = (SumLong) agg;
        myagg.empty = true;
        myagg.sum = 0L;
    }

    /**
     * 迭代遍历原始的输入数据
     */
    @Override
    public void iterate(GenericUDAFEvaluator.AggregationBuffer agg, Object[] parameters) throws HiveException {
        assert (parameters.length == 1);
        try {
            merge(agg, parameters[0]);
        } catch (NumberFormatException e) {
            if (!(this.warned)) {
                this.warned = true;
            }
        }
    }

    /**
     * 合并部分聚合结果
     * <p>
     * 说明：
     * PrimitiveObjectInspectorUtils.getLong(数据， 数据的数据类型): 获取对应数据类型的数值
     */
    @Override
    public void merge(GenericUDAFEvaluator.AggregationBuffer agg, Object partial) throws HiveException {
        if (partial != null) {
            SumLong myagg = (SumLong) agg;
            myagg.sum += PrimitiveObjectInspectorUtils.getLong(partial, inputOI);
            myagg.empty = false;
        }
    }

    /**
     * 获得部分聚合的结果
     */
    @Override
    public Object terminatePartial(GenericUDAFEvaluator.AggregationBuffer agg) throws HiveException {
        return terminate(agg);
    }

    /**
     * 获得最终的聚合结果
     */
    @Override
    public Object terminate(GenericUDAFEvaluator.AggregationBuffer agg) {
        SumLong myagg = (SumLong) agg;
        if (myagg.empty) {
            return null;
        }
        result.set(myagg.sum);
        return result;
    }

    /**
     * 存储sum值的类
     */
    @GenericUDAFEvaluator.AggregationType(estimable = true)
    static class SumLong extends GenericUDAFEvaluator.AbstractAggregationBuffer {
        boolean empty;
        long sum;

        //预计存储空间大小 12个字节
        public int estimate() {
            return 12;
        }
    }
}

demo2多个数字求平均值

package hive.User_Defined_Functions;

import org.apache.hadoop.hive.ql.exec.UDFArgumentTypeException;
import org.apache.hadoop.hive.ql.metadata.HiveException;
import org.apache.hadoop.hive.ql.parse.SemanticException;
import org.apache.hadoop.hive.ql.udf.generic.AbstractGenericUDAFResolver;
import org.apache.hadoop.hive.ql.udf.generic.GenericUDAFEvaluator;
import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector;
import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspectorFactory;
import org.apache.hadoop.hive.serde2.objectinspector.PrimitiveObjectInspector;
import org.apache.hadoop.hive.serde2.objectinspector.StructField;
import org.apache.hadoop.hive.serde2.objectinspector.StructObjectInspector;
import org.apache.hadoop.hive.serde2.objectinspector.primitive.DoubleObjectInspector;
import org.apache.hadoop.hive.serde2.objectinspector.primitive.LongObjectInspector;
import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorFactory;
import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorUtils;
import org.apache.hadoop.hive.serde2.typeinfo.PrimitiveTypeInfo;
import org.apache.hadoop.hive.serde2.typeinfo.TypeInfo;
import org.apache.hadoop.io.DoubleWritable;
import org.apache.hadoop.io.LongWritable;

import java.util.ArrayList;

/**
 * @describe:
 * 案例：计算多个数的平均数
 *    sum= 数据值的叠加
 *    count = 数据的个数
 *    平均数=sum/count
 *
 */
public class MyUDAFAverage extends AbstractGenericUDAFResolver {

    /**
     * 入参数据类型的校验，如果参数校验通过则直接返回数据聚合处理结果
     * @param parameters 参数类型
     */
    @Override
    public GenericUDAFEvaluator getEvaluator(TypeInfo[] parameters)
            throws SemanticException {
        if (parameters.length != 1) {
            throw new UDFArgumentTypeException(parameters.length - 1, "Exactly one argument is expected.");
        }

        if (parameters[0].getCategory() != ObjectInspector.Category.PRIMITIVE) {
            throw new UDFArgumentTypeException(0, "Only primitive type arguments are accepted but " + parameters[0].getTypeName() + " is passed.");
        }
        switch (((PrimitiveTypeInfo) parameters[0]).getPrimitiveCategory()) {
            case BYTE:
            case SHORT:
            case INT:
            case LONG:
            case FLOAT:
            case DOUBLE:
            case STRING:
            case TIMESTAMP: return new GenericUDAFAverageEvaluator();
            case BOOLEAN:
            default: throw new UDFArgumentTypeException(0, "Only numeric or string type arguments are accepted but " + parameters[0].getTypeName() + " is passed.");
        }
    }

    /**
     * GenericUDAFAverageEvaluator. 平均数计算
     * 自定义静态内部类：数据处理类，继承GenericUDAFEvaluator抽象类
     */
    public static class GenericUDAFAverageEvaluator extends GenericUDAFEvaluator {
        //原数据
        PrimitiveObjectInspector inputOI;
        //中间数据 count sum整体结构
        StructObjectInspector soi;
        //输入的count数据结构
        StructField countField;
        //输入的sum 数据结构
        StructField sumField;
        LongObjectInspector countFieldOI;
        DoubleObjectInspector sumFieldOI;

        //定义全局输出数据的类型，用于存储实际数据
        Object[] partialResult;
        //最终输出结果
        DoubleWritable result;

        /*
         * 初始化：对各个模式处理过程，提取输入数据类型OI，返回输出数据类型OI
         * .每个模式（Mode）都会执行初始化
         * 1.输入参数parameters：
         * .1.1.对于PARTIAL1 和COMPLETE模式来说，是原始数据（单值）
         *    .设定了iterate()方法的输入参数的类型OI为：
         *    .		 PrimitiveObjectInspector 的实现类 WritableDoubleObjectInspector 的实例
         *    .		 通过输入OI实例解析输入参数值
         * .1.2.对于PARTIAL2 和FINAL模式来说，是模式聚合数据（双值）
         *    .设定了merge()方法的输入参数的类型OI为：
         *    .		 StructObjectInspector 的实现类 StandardStructObjectInspector 的实例
         *    .		 通过输入OI实例解析输入参数值
         * 2.返回值OI：
         * .2.1.对于PARTIAL1 和PARTIAL2模式来说，是设定了方法terminatePartial()返回值的OI实例
         *    .输出OI为 StructObjectInspector 的实现类 StandardStructObjectInspector 的实例
         * .2.2.对于FINAL 和COMPLETE模式来说，是设定了方法terminate()返回值的OI实例
         *    .输出OI为 PrimitiveObjectInspector 的实现类 WritableDoubleObjectInspector 的实例
         */
        @Override
        public ObjectInspector init(Mode mode, ObjectInspector[] parameters) throws HiveException {
            assert (parameters.length == 1);

            //输入初始化
            super.init(mode, parameters);
            //原始数据到部分聚集数据 || 原始数据到所有剧集数据
            if (mode == Mode.PARTIAL1 || mode == Mode.COMPLETE) {
                inputOI = (PrimitiveObjectInspector) parameters[0];
            } else {
                //聚集到聚集 || 聚集到最终结果
                soi = (StructObjectInspector) parameters[0];
                countField = soi.getStructFieldRef("count");
                sumField = soi.getStructFieldRef("sum");
                //数组中的每个数据，需要其各自的基本类型OI实例解析
                countFieldOI = (LongObjectInspector) countField.getFieldObjectInspector();
                sumFieldOI = (DoubleObjectInspector) sumField.getFieldObjectInspector();
            }

            // 输出中间过程是有sum 和count 是数组
            if (mode == Mode.PARTIAL1 || mode == Mode.PARTIAL2) {
                //部分聚合结果是一个数组
                partialResult = new Object[2];
                partialResult[0] = new LongWritable(0);
                partialResult[1] = new DoubleWritable(0);
                //构造Struct的OI实例，用于设定聚合结果数组的类型，需要字段名List和字段类型List作为参数来构造
                ArrayList<String> fname = new ArrayList<>();
                fname.add("count");
                fname.add("sum");
                ArrayList<ObjectInspector> foi = new ArrayList<ObjectInspector>();
                //注：此处的两个OI类型 描述的是 partialResult[] 的两个类型，故需一致
                foi.add(PrimitiveObjectInspectorFactory.writableLongObjectInspector);
                foi.add(PrimitiveObjectInspectorFactory.writableDoubleObjectInspector);
                return ObjectInspectorFactory.getStandardStructObjectInspector(fname, foi);
            } else {
                //FINAL 最终聚合结果为一个数值，并用基本类型OI设定其类型
                result = new DoubleWritable(0);
                return PrimitiveObjectInspectorFactory.writableDoubleObjectInspector;
            }
        }

        /*
         * 聚合数据缓存存储结构
         */
        static class AverageAgg implements AggregationBuffer {
            long count;
            double sum;
        }

        /**
         * 创建新的聚合计算需要的内存
         */
        @Override
        public AggregationBuffer getNewAggregationBuffer() throws HiveException {
            AverageAgg result = new AverageAgg();
            reset(result);
            return result;
        }

        /**
         *  重置聚合结果，可以方便重复使用相同的聚合
         */
        @Override
        public void reset(AggregationBuffer agg) throws HiveException {
            AverageAgg myagg = (AverageAgg) agg;
            myagg.count = 0;
            myagg.sum = 0;
        }

        boolean warned = false;

        /*
         * 遍历原始数据
         */
        @Override
        public void iterate(AggregationBuffer agg, Object[] parameters) {
            assert (parameters.length == 1);
            Object p = parameters[0];
            if (p != null) {
                AverageAgg myagg = (AverageAgg) agg;
                try {
                    //通过基本数据类型OI解析Object p的值
                    double v = PrimitiveObjectInspectorUtils.getDouble(p, inputOI);
                    myagg.count++;
                    myagg.sum += v;
                } catch (NumberFormatException e) {
                    if (!warned) {
                        warned = true;
                    }
                }
            }
        }

        /*
         * 得出部分聚合结果
         */
        @Override
        public Object terminatePartial(AggregationBuffer agg) throws HiveException {
            AverageAgg myagg = (AverageAgg) agg;
            ((LongWritable) partialResult[0]).set(myagg.count);
            ((DoubleWritable) partialResult[1]).set(myagg.sum);
            return partialResult;
        }

        /*
         * 合并部分聚合结果
         * 注：Object[] 是 Object 的子类，此处 partial 为 Object[]数组
         */
        @Override
        public void merge(AggregationBuffer agg, Object partial) {
            if (partial != null) {
                AverageAgg myagg = (AverageAgg) agg;
                //通过StandardStructObjectInspector实例，分解出 partial 数组元素值
                Object partialCount = soi.getStructFieldData(partial, countField);
                Object partialSum = soi.getStructFieldData(partial, sumField);
                //通过基本数据类型的OI实例解析Object的值
                myagg.count += countFieldOI.get(partialCount);
                myagg.sum += sumFieldOI.get(partialSum);
            }
        }

        /*
         * 得出最终聚合结果
         */
        @Override
        public Object terminate(AggregationBuffer agg) throws HiveException {
            AverageAgg myagg = (AverageAgg) agg;
            if (myagg.count == 0) {
                return null;
            } else {
                result.set(myagg.sum / myagg.count);
                return result;
            }
        }
    }

}

3.打jar包并add 到hive中

add jar jar_path

4.创建函数

create [temporary] function [dbname.]function_name AS class_name;

 

17245
关注
  • 0
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Hive+GenericUDF示例一
wisgood的专栏
05-18 1万+
和UDF相比，通用GDF（GenericUDF）支持复杂类型（比如List，struct等）的输入和输出。            下面来看一个小示例。             Hive中whereme表中包含若干人的行程如下：   [plain] view plaincopy A       2013-10-10 8:00:00      h
HIVE自定义UDAF函数
weixin_46429290的博客
08-31 1586
/ 确定各个阶段输入输出参数的数据格式ObjectInspectors public ObjectInspector init(Mode m , ObjectInspector [ ] parameters) throws HiveException;// 保存数据聚集结果的类 abstract AggregationBuffer getNewAggregationBuffer() throws HiveException;...
hive学习笔记之十：用户自定义聚合函数(UDAF)
最新发布
2401_84048832的博客
04-23 1045
为什么我不完全主张自学？①平台上的大牛基本上都有很多年的工作经验了，你有没有想过之前行业的门槛是什么样的，现在行业门槛是什么样的？以前企业对于程序员能力要求没有这么高，甚至十多年前你只要会写个“Hello World”，你都可以入门这个行业，所以以前要入门是完全可以入门的。②现在也有一些优秀的年轻大牛，他们或许也是自学成才，但是他们一定是具备优秀的学习能力，优秀的自我管理能力（时间管理，静心坚持等方面）以及善于发现问题并总结问题。
Hive之自定义聚合函数UDAF
碣石观海的博客
05-03 1万+
----本文笔记整理自 《Hive编程指南》13.9 用户自定义聚合函数 一、自定义聚合函数（GenericUDAFAverage实现） 1.聚合函数：指0行到多行的0个到多个列作为参数输入，返回单一值的函数，经常和group by子句一起用。 如：sum(col)，avg(col)，max(col)，std(col)等。 2.实现通用的自定义聚合函数 GenericUDAFA...
Hive之自定义函数（UDF、UDAF、UDTF）
IT小王
08-31 1269
内容仅截取函数部分，其他Hive学习笔记见个人博客 https://wangbowen.cn/2020/08/27/Hive%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0/ 十三、函数 13.1 发现和描述函数 -- 可以看到hive当前会话的所有函数名称，包括内置和用户自定义的 show functions; -- 查看函数的简介(加上extended显示更详细的文档) describe function [extended] <函数名>; 13.2 调用函数 函
Hive- UDF&GenericUDF
u011250186的博客
04-28 1428
hive udf简介 在Hive中，用户可以自定义一些函数，用于扩展HiveQL的功能，而这类函数叫做UDF（用户自定义函数）。UDF分为两大类：UDAF（用户自定义聚合函数）和UDTF（用户自定义表生成函数）。在介绍UDAF和UDTF实现之前，我们先在本章介绍简单点的UDF实现——UDF和GenericUDF，然后以此为基础在下一章介绍UDAF和UDTF的实现。 Hive有两个不同的接口编写UDF程序。一个是基础的UDF接口，一个是复杂的GenericUDF接口。 org.apache.hado..
Hive自定义函数
01-20
UDF（用户自定义函数） #### 背景 UDF是解决系统内置函数不足以应对多样化业务场景的关键。由于每个业务都有其独特性，因此需要通过自定义函数来实现个性化处理。 #### 意义 UDF的引入极大地丰富了Hive的函数库，...
hive-udf:hive自定义函数
05-18
hive-udfhive自定义函数主要实现hive3种自定义函数1，udf函数，主要用于处理一对一数据处理2，udtf函数，主要用于处理一对多数据处理2，udaf函数，主要用与处理多对一数据聚合处理
hive 创建自定义函数 和 hive加载说明
08-11
在Hive中，UDF分为三种类型：UDF（User Defined Function）、UDAF（User Defined Aggregate Function）和UDTF（User Defined Table Generating Function）。UDF是最基础的，处理单行单列的数据；UDAF用于聚合操作，...
Hive的Udf函数进行数据脱敏
01-26
在Hive中，UDF分为三种类型：UDF（单行函数）、UDAF（累积聚合函数）和UDTF（多行转换函数）。在这里，我们只需要UDF，因为它适用于处理单行数据。 1. **编写Java类**： 要创建一个UDF，你需要编写一个Java类，该...
hive自定义函数demo
05-30
Hive自定义函数（User Defined Function，UDF）是用户编写并集成到Hive系统中的函数，用来处理Hive不内置支持的特定计算或转换任务。UDF接受单个输入参数并返回一个结果，非常适合进行简单的数据转换和计算。 2. *...
Hive的UDF编程之GenericUDF编程
weixin_42229056的博客
07-24 1580
Hive编程指南的GenericUDF，GenericUD可以接受负责数据类型的数据参数输入，这里我们使用的是输入数组，判断数组中是否包含某个值
大数据——Spark-SQL自定义函数UDF、UDAF、UDTF
蜂蜜柚子加苦茶
11-17 782
Spark-SQL自定义函数UDF、UDAF、UDTF自定义函数分类UDFUDAFUDTF 自定义函数分类 类似有Hive当中的自定义函数，Spark同样可以使用自定义的函数来实现新的功能 Spark中的自定义函数有三类： UDF（User-Defined-Function） 输入一行，输出一行 UDAF（User-Defined Aggregation Function） 输入多行，输出一行 UDTF（User-Defined Table-Generating Functions）
Hive自定义函数简单概述
shkstart的博客
10-10 655
一、概述 --1. 在hive中有三种自定义函数： 1. UDF ：一进一出 --一行变一行 2. UDTF : 一进多出 -- 一行变多行 3. UDAF ：多进一出 -- 多行变一行 -- 2. 实现步骤： a、进入函数的是什么参数 b、希望得到什么结果 c、考虑通用性 二、UDTF函数 2.1 UDTF解析 -- 1. 说明 A custom UDTF can be created by extending the GenericUDTF abstract class .
Hive用户自定义函数UDAF开发
游离在社会边缘
07-21 1032
释义 UDAF是User Defined Aggregation Function的简称。UDAF用来进行聚合运算，其输入是多行数据，输出一个计算结果。 如何开发 UDAF有两种实现方式：继承UDAF；或继承AbstractGenericUDAFResolver。前一种方式是简单的方式，但其使用了java的反射机制，因此性能上比后一种方式要低效，因此生产上不建议使用第一种方式。 计算的逻辑...
Spark_SQL自定义函数 UDF UDAF UDTF
写的不好之处,请指教
04-20 4930
自定义函数分类 类似于hive当中的自定义函数， spark同样可以使用自定义函数来实现新的功能。 spark中的自定义函数有如下3类 1.UDF(User-Defined-Function) 输入一行，输出一行 2.UDAF(User-Defined Aggregation Funcation) 输入多行，输出一行 3.UDTF(User-Define...
hive基础选择题
热门推荐
weixin_38861839的博客
05-21 1万+
1.下列关于Hive特点总结正确的选项是（） A Hive支持自由的扩展集群的规模，只需要重启服务即可 B Hive支持自定义函数，用户可以根据自己的需求去定义函数 C Hive SQL执行时，需要避免节点出现问题 D Hive 适合处理小批量数据 【B】 A. 错误，Hive一般不需要重启服务就可以扩展集群 B. 正确，用户可以上传自己定义的函数UDF，User Define Function jar包提交至Hive环境，注册后即可使用 C. 错误，Hive具有良好的容错性，节点出现问题，SQ
使用sparksql 和 hive api 代码实现用户自定义函数udf udaf udtf
03-16
使用SparkSQL和Hive API，可以通过以下步骤实现用户自定义函数（UDF）、聚合函数（UDAF）和表生成函数（UDTF）： 1. 编写自定义函数的代码，例如： ``` // UDF def myUDF(str: String): Int = { str.length } //...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值