hive udf简单示例

最新推荐文章于 2024-04-06 19:26:09 发布
最新推荐文章于 2024-04-06 19:26:09 发布
阅读量234 收藏
点赞数
文章标签： hive 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44651989/article/details/108849103
版权

hive udf简单示例

udaf

Kurt


import org.apache.commons.math3.stat.descriptive.moment.Kurtosis;
import org.apache.hadoop.hive.ql.exec.UDAF;
import org.apache.hadoop.hive.ql.exec.UDAFEvaluator;
import org.apache.hadoop.io.DoubleWritable;
import org.apache.hadoop.io.LongWritable;

import java.util.*;

public class Kurt extends UDAF {
    private static Kurtosis kurtosis = new Kurtosis();

    public static class KurtEvaluatorLong implements UDAFEvaluator {
        private static List<LongWritable> state;

        public KurtEvaluatorLong() {
            super();
            state = new ArrayList<>();
            init();
        }

        /**
         * init函数类似于构造函数，用于UDAF的初始化
         */
        public void init() {
            state.clear();
        }

        /**
         * 迭代处理原始数据的一行。
         *
         * 参数的数量和类型需要与我们从Hive命令行调用这个UDAF相同。
         *
         * 这个函数应该总是返回true。
         *
         * @param o
         * @return
         */
        public boolean iterate(LongWritable o) {
            if (o != null) {
                state.add(o);
            }
            return true;
        }

        /**
         * 终止部分聚合并返回状态。如果状态是原语，就返回原语Java类，如Integer或String。
         *
         * @return
         */
        public List<LongWritable> terminatePartial() {
            // combiner
            return state.size() == 0 ? null : state;
        }

        /**
         * 与部分状态合并
         *
         * 这个函数应该始终有一个参数，该参数的类型与terminatePartial()的返回值相同。
         *
         * @param o
         * @return
         */

        public boolean merge(List<LongWritable> o) {
            if (o.size() != 0) {
                state.addAll(o);
            }
            return true;
        }

        /**
         * 终止聚合并返回最终结果。
         *
         * @return
         */
        public Double terminate() {

            if (state.size() == 0) {
                return null;
            } else {
                double[] lon = new double[state.size()];
                for (int i = 0; i < state.size(); i++) {
                    lon[i] = Double.parseDouble(state.get(i).toString());
                }
                return kurtosis.evaluate(lon);
            }
        }
    }

    public static class KurtEvaluatorDouble implements UDAFEvaluator {
        private static List<DoubleWritable> state;

        public KurtEvaluatorDouble() {
            super();
            state = new ArrayList<>();
            init();
        }

        /**
         * init函数类似于构造函数，用于UDAF的初始化
         */
        public void init() {
            state.clear();
        }

        /**
         * 迭代处理原始数据的一行。
         * <p>
         * 参数的数量和类型需要与我们从Hive命令行调用这个UDAF相同。
         * <p>
         * 这个函数应该总是返回true。
         *
         * @param o
         * @return
         */
        public boolean iterate(DoubleWritable o) {
            if (o != null) {
                state.add(o);
            }
            return true;
        }

        /**
         * 终止部分聚合并返回状态。如果状态是原语，就返回原语Java类，如Integer或String。
         *
         * @return
         */
        public List<DoubleWritable> terminatePartial() {
            // combiner
            return state.size() == 0 ? null : state;
        }

        /**
         * 与部分状态合并
         * <p>
         * 这个函数应该始终有一个参数，该参数的类型与terminatePartial()的返回值相同。
         *
         * @param o
         * @return
         */

        public boolean merge(List<DoubleWritable> o) {
            if (o.size() != 0) {
                state.addAll(o);
            }
            return true;
        }

        /**
         * 终止聚合并返回最终结果。
         *
         * @return
         */
        public Double terminate() {

            if (state.size() == 0) {
                return null;
            } else {
                double[] lon = new double[state.size()];
                for (int i = 0; i < state.size(); i++) {
                    lon[i] = Double.parseDouble(state.get(i).toString());
                }
                return kurtosis.evaluate(lon);
            }
        }
    }
//{"value":-1.1992118504785885}
}

Mode


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

import java.util.*;

public class Mode extends UDAF {

    /**
     * 执行实际类。Hive将自动查找实现UDAFEvaluator的UDAF的所有内部类。
     */
    public static class ModeEvaluatorLong implements UDAFEvaluator {
        Map<Long, Long> stats;
        List<Long> list;
        Long maxNum;

        public ModeEvaluatorLong() {
            super();
            stats = new HashMap<>();
            list = new ArrayList<>();
            init();
        }

        /**
         * init函数类似于构造函数，用于UDAF的初始化
         */
        public void init() {
            stats.clear();
            list.clear();
            maxNum = new Long(0);
        }

        /**
         * 迭代处理原始数据的一行。
         *
         * 参数的数量和类型需要与我们从Hive命令行调用这个UDAF相同。
         *
         * 这个函数应该总是返回true。
         *
         * @param o
         * @return
         */
        public boolean iterate(LongWritable o) {
            if (o != null) {
                // 统计输入列每个元素的数量
                if (stats.containsKey(o.get())) {
                    stats.put(o.get(), stats.get(o.get()) + 1);
                } else {
                    stats.put(o.get(), new Long(1));
                }
            }
            return true;
        }

        /**
         * 终止部分聚合并返回状态。如果状态是原语，就返回原语Java类，如Integer或String。
         * @return
         */
        public Map<Long, Long> terminatePartial() {
            // combiner
            return stats.size() == 0 ? null : stats;
        }

        /**
         * 与部分状态合并
         *
         * 这个函数应该始终有一个参数，该参数的类型与terminatePartial()的返回值相同。
         * @param o
         * @return
         */

        public boolean merge(Map<Long, Long> o) {
            if (o.size() != 0) {
                Iterator<Long> iterable = o.keySet().iterator();
                while (iterable.hasNext()) {
                    Long key = iterable.next();
                    if (this.stats.containsKey(key)) {
                        this.stats.put(key,o.get(key)+stats.get(key));
                    }else {
                        this.stats.put(key, o.get(key));
                    }
                }
            }
            return true;
        }

        /**
         * 终止聚合并返回最终结果。
         * @return
         */
        public List<Long> terminate() {

            if (stats.size() == 0) {
                return null;
            } else {
                Iterator<Long> iterator = stats.keySet().iterator();
                while (iterator.hasNext()) {
                    Long key = iterator.next();
                    Long sv = stats.get(key);
                    if (sv > maxNum) {//初始化
                        maxNum = sv;
                        list.clear();
                        list.add(key);
                    } else if (sv == maxNum) {
                        list.add(key);
                    }
                }
            }
            return list;
        }
    }

    public static class ModeEvaluatorDouble implements UDAFEvaluator {
        Map<Double, Long> stats;
        List<Double> list;
        Long maxNum;

        public ModeEvaluatorDouble() {
            super();
            stats = new HashMap<>();
            list = new ArrayList<>();
            init();
        }

        public void init() {
            stats.clear();
            list.clear();
            maxNum = new Long(0);
        }

        public boolean iterate(DoubleWritable o) {
            if (o != null) {
                // 统计输入列每个元素的数量
                if (stats.containsKey(o.get())) {
                    stats.put(o.get(), stats.get(o.get()) + 1);
                } else {
                    stats.put(o.get(), new Long(1));
                }
            }
            return true;
        }

        public Map<Double, Long> terminatePartial() {
            // combiner
            return stats.size() == 0 ? null : stats;
        }

        public boolean merge(Map<Double, Long> o) {
            if (o.size() != 0) {
                Iterator<Double> iterable = o.keySet().iterator();
                while (iterable.hasNext()) {
                    Double key = iterable.next();
                    if (this.stats.containsKey(key)) {
                        this.stats.put(key,o.get(key)+stats.get(key));
                    }else {
                        this.stats.put(key, o.get(key));
                    }
                }
            }
            return true;
        }

        public List<Double> terminate() {

            if (stats.size() == 0) {
                return null;
            } else {
                Iterator<Double> iterator = stats.keySet().iterator();
                while (iterator.hasNext()) {
                    Double key = iterator.next();
                    Long sv = stats.get(key);
                    if (sv > maxNum) {//初始化
                        maxNum = sv;
                        list.clear();
                        list.add(key);
                    } else if (sv == maxNum) {
                        list.add(key);
                    }
                }
            }
            return list;
        }
    }
}

Skew


import org.apache.commons.math3.stat.descriptive.moment.Skewness;
import org.apache.hadoop.hive.ql.exec.UDAF;
import org.apache.hadoop.hive.ql.exec.UDAFEvaluator;
import org.apache.hadoop.io.DoubleWritable;
import org.apache.hadoop.io.LongWritable;

import java.util.ArrayList;
import java.util.List;

public class Skew extends UDAF {
    private static Skewness skewness = new Skewness();

    public static class SkewEvaluatorLong implements UDAFEvaluator {
        private static List<LongWritable> state;

        public SkewEvaluatorLong() {
            super();
            state = new ArrayList<>();
            init();
        }

        /**
         * init函数类似于构造函数，用于UDAF的初始化
         */
        public void init() {
            state.clear();
        }

        /**
         * 迭代处理原始数据的一行。
         * 参数的数量和类型需要与我们从Hive命令行调用这个UDAF相同。
         * 这个函数应该总是返回true。
         *
         * @param o
         * @return
         */
        public boolean iterate(LongWritable o) {
            if (o != null) {
                state.add(o);
            }
            return true;
        }

        /**
         * 终止部分聚合并返回状态。如果状态是原语，就返回原语Java类，如Integer或String。
         *
         * @return
         */
        public List<LongWritable> terminatePartial() {
            // combiner
            return state.size() == 0 ? null : state;
        }

        /**
         * 与部分状态合并
         * <p>
         * 这个函数应该始终有一个参数，该参数的类型与terminatePartial()的返回值相同。
         *
         * @param o
         * @return
         */

        public boolean merge(List<LongWritable> o) {
            if (o.size() != 0) {
                state.addAll(o);
            }
            return true;
        }

        /**
         * 终止聚合并返回最终结果。
         *
         * @return
         */
        public Double terminate() {

            if (state.size() == 0) {
                return null;
            } else {
                double[] lon = new double[state.size()];
                for (int i = 0; i < state.size(); i++) {
                    lon[i] = Double.parseDouble(state.get(i).toString());
                }
                return skewness.evaluate(lon);
            }
        }
    }

    public static class SkewEvaluatorDouble implements UDAFEvaluator {
        private static List<DoubleWritable> state;

        public SkewEvaluatorDouble() {
            super();
            state = new ArrayList<>();
            init();
        }

        /**
         * init函数类似于构造函数，用于UDAF的初始化
         */
        public void init() {
            state.clear();
        }

        /**
         * 迭代处理原始数据的一行。
         * <p>
         * 参数的数量和类型需要与我们从Hive命令行调用这个UDAF相同。
         * <p>
         * 这个函数应该总是返回true。
         *
         * @param o
         * @return
         */
        public boolean iterate(DoubleWritable o) {
            if (o != null) {
                state.add(o);
            }
            return true;
        }

        /**
         * 终止部分聚合并返回状态。如果状态是原语，就返回原语Java类，如Integer或String。
         *
         * @return
         */
        public List<DoubleWritable> terminatePartial() {
            // combiner
            return state.size() == 0 ? null : state;
        }

        /**
         * 与部分状态合并
         * <p>
         * 这个函数应该始终有一个参数，该参数的类型与terminatePartial()的返回值相同。
         *
         * @param o
         * @return
         */

        public boolean merge(List<DoubleWritable> o) {
            if (o.size() != 0) {
                state.addAll(o);
            }
            return true;
        }

        /**
         * 终止聚合并返回最终结果。
         *
         * @return
         */
        public Double terminate() {

            if (state.size() == 0) {
                return null;
            } else {
                double[] lon = new double[state.size()];
                for (int i = 0; i < state.size(); i++) {
                    lon[i] = Double.parseDouble(state.get(i).toString());
                }
                return skewness.evaluate(lon);
            }
        }
    }
}

部分依赖

    <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>
        <hadoop.version>3.0.0</hadoop.version>
        <hive.version>2.1.1</hive.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.apache.hive</groupId>
            <artifactId>hive-exec</artifactId>
            <version>${hive.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>org.apache.logging.log4j</groupId>
                    <artifactId>log4j-1.2-api</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.apache.logging.log4j</groupId>
                    <artifactId>log4j-slf4j-impl</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-client</artifactId>
            <version>${hadoop.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-log4j12</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.apache.logging.log4j</groupId>
                    <artifactId>log4j-1.2-api</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-api</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.apache.logging.log4j</groupId>
                    <artifactId>log4j-slf4j-impl</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-common</artifactId>
            <version>${hadoop.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>org.apache.logging.log4j</groupId>
                    <artifactId>log4j-1.2-api</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-api</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-log4j12</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-hdfs</artifactId>
            <version>${hadoop.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>net.minidev</groupId>
                    <artifactId>json-smart</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.apache.logging.log4j</groupId>
                    <artifactId>log4j-1.2-api</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.apache.logging.log4j</groupId>
                    <artifactId>log4j-slf4j-impl</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-api</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-log4j12</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-api</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-simple</artifactId>
            <version>1.7.25</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>
ε(´ο｀*)))
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【Hive】函数（UDF篇）
listeningdu的博客
11-22 5912
Hive/UDF
Hive自定义UDF函数及使用
小健的博客
01-30 3144
UDF全称：User-Defined Functions，即用户自定义函数，在Hive SQL编译成MapReduce任务时，执行java方法，类似于像MapReduce执行过程中加入一个插件，方便扩展。
Hive 的 UDF 函数（Python 版本）
shawn
05-26 3158
Python 实现 Hive 的 UDF 函数其实非常的简单
Hive 之 UDF 运用（包会的）
最新发布
JIE的博客 --- moon_coder
04-06 1960
Hive 支持两种 UDF 函数自定义操作，分别是：GenericUDF（通用UDF）：用于实现那些可以处理任意数据类型的函数。它们的输入和输出类型可以是任意的，但需要在函数内部处理类型转换和逻辑，可以实现更复杂的逻辑处理。UDF：用于实现那些只能处理特定数据类型的函数。每个 UDF 都明确指定了输入参数的类型和返回值类型，使用更为简单。本文采用的是通用 UDF —— GenericUDF 实现方法这里通过一个在 Hive 中实现两数相加的自定义 UDF 案例来进行说明，看完你就会啦，轻松拿捏。在。
Hive中UDF、UDTF 、UDAF函数详解及示例
赵昕彧
05-03 6943
文章目录一.自定义函数意义UDF函数UDTF函数UDAF函数二.示例操作UDF函数示例UDTF函数示例UDAF函数示例 一.自定义函数意义 在Hive的使用中，系统内置函数有时无法满足业务需求，这时就需要开发者自己编写函数来实现业务需求。 自定义函数，极大丰富了个性化定制的需要，使Hive得到了极大的拓展。 Hive有三种自定义函数，可以实现不同方面的需求。 UDF函数 常见的函数类型，...
大数据 java hive udf函数的示例代码（手机号码脱敏）
08-19
"大数据 Java Hive UDF 函数示例代码（手机号码脱敏）" 大数据 Java Hive UDF 函数示例代码（手机号码脱敏）是指使用 Java 语言开发的用户定义函数（User Defined Function，UDF），该函数可以在 Hive 中使用，实现...
javasql笔试题-spark-hive-udf:展示如何在ApacheSpark中使用HiveUDF的示例项目
06-17
sql笔试题示例 Hive UDF 项目 介绍 该项目只是一个示例，包含多个 (UDF)，用于 Apache Spark。 它旨在演示如何在 Scala 或 Java 中构建 Hive UDF 并在 . 为什么要使用 Hive UDF？ Hive UDF 的一个特别好的用途是与 ...
spark-hive-udf:Spark Hive UDF示例
04-22
Spark Hive UDF示例 建立项目 mvn clean package 将spark-hive-udf-1.0.0-SNAPSHOT.jar复制到边缘节点临时目录 spark-hive-udf]# cp target/spark-hive-udf-1.0.0-SNAPSHOT.jar /tmp 通过提供罐子来启动火花壳 spark...
hive自定义UDF编写函数.docx
01-26
Hive 自定义 UDF 编写函数 本文主要讲解了 Hive 中自定义 UDF 函数的编写方法，包括创建 UDF 类、实现自定义函数逻辑、编译和打包 UDF jar 包、上传至 Hive 服务器并注册自定义函数。 一、创建 UDF 类 为了实现...
Hive的Udf函数进行数据脱敏
01-26
ADD JAR /path/to/your/hiveUDF.jar; CREATE TEMPORARY FUNCTION mask AS 'com.yourpackage.MaskingUDF'; ``` 4. **使用UDF**： 注册完成后，你可以在查询中直接使用`mask`函数。假设我们有一个包含手机号码的表`...
Hive中的UDF实例开发
weixin_38650528的博客
06-17 1688
1，背景数据挖掘项目中，常见的需求之一就是分析节假日订单跟平时订单的区别。2，需求输入一个日期，判断是否是节假日。3，UDF(user-defined function)全称为用户自定义函数。UDF类：实现的evaluate函数的入参和返回值只支持可序列化的数据类型，即string，int，double等等。GenricUDF类：实现的evaluate函数可支持array,map等复杂的参数。本例...
2、Hive UDF编程实例
weixin_30696427的博客
04-21 154
Hive的UDF包括3种：UDF(User-Defined Function)、UDAF(User-Defined Aggregate Function)和UDTF(User-Defined Table-Generating Function)，Hive只支持Java编写UDF，其他的编程语言只能通过select transform转化为流来与Hive交互。 UDF(User-Defined...
hive自定义函数分类+UDF实例
东城庞太师
02-06 727
hive自定义函数分为三类： UDF（User-Defined-Function）普通函数， 一进一出 UDAF（User-Defined Aggregation Function）聚合函数，多进一出 UDTF（User-Defined Table-Generating Functions）表生成函数， 一进多出 UDF实例 新建子模块hive_demo ...
hive UDF 例子
duan19056的专栏
01-06 7733
1、源码 package com.hive.udf; import org.apache.commons.lang.StringUtils; import org.apache.hadoop.hive.ql.exec.UDF; import org.apache.hadoop.io.Text; public class Trim extends UDF { private Te
hive UDF 测试样例开发
VincentQB的博客
01-12 9941
hive UDF 测试样例开发
hive UDF开发实例
爱笑的博客
04-20 1105
把 hive 安装目录下的lib 添加到java项目中 简单UDF示例 1、先开发一个java类，继承UDF，并重载evaluate方法 package com.hive.udf; import org.apache.hadoop.hive.ql.exec.UDF; public class ToLowerCase extends UDF { public String
hive UDF
热门推荐
yfk的专栏
01-21 5万+
HIVE允许用户使用UDF（user defined function）对数据进行处理。 用户可以使用‘show functions’ 查看function list，可以使用'describe function function-name'查看函数说明。 hive> show functions; OK ! != ...... Time taken: 0.275 seconds hive>
hive udf 使用示例
百岁
11-30 287
 在使用过程中，在执行sql的过程中需要将partition按照一定的规则动态分区： import org.apache.hadoop.hive.ql.exec.UDF; public class SharedRouter extends UDF { private static SolrCloudPainRouter cloudPainRouter; public Strin...
一个简单的UDF小程序（HIVE）
Arch_zly的博客
04-27 2287
一个运行于HIVE的简单的UDF程序，可以作为对UDF的一个简单的入门，你自己也可以很容易的亲自实践。主要包括以下步骤： 在hive中建一个测试用例表、编辑UDF的java程序、HIVE中添加JAR包并创建UDF临时函数（1）在hive中建一个测试用例表（当然如果你已经有合适的数据可以跳过这一步）create table littlebigdata ( name string, email str...
hive udf 转spark udf
05-25
在上面的示例中，假设 Hive UDF 的返回类型是字符串类型，因此 Spark UDF 的返回类型也是 `StringType()`。如果 Hive UDF 的返回类型是整数类型，Spark UDF 的返回类型应该是 `IntegerType()`。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值