详解 Hive 的常见函数

一、函数类型

  • UDF:一进一出,输入一行数据输出一行数据,例如:upper 等普通函数
  • UDAF:多进一出,输入多行数据输出一行数据,例如:max 等聚合函数
  • UDTF:一进多出,输入一行数据输出多行数据,例如:explode 等炸裂函数

二、内置函数

1. 查看内置函数

-- 查看系统自带的函数
show functions;

-- 显示自带的函数的用法
desc function func_name;

-- 详细显示自带的函数的用法
desc function extended func_name;

2. 常用内置函数

2.1 NVL
  • 语法:

    -- 如果value为NULL,则返回default_value,否则返回value,如果两个都为NULL,则返回NULL,可嵌套
    NVL(value,default_value)
    
  • 案例:

    -- 如果员工的 comm 为 NULL,则用-1 代替
    select empName, nvl(comm, -1) as comm from emp;
    
2.2 case when / if
  • 语法:

    -- 如果condition为true,则返回value1,否则返回value2,可以有多个 when 分支
    case [column] when condition then value1 else value2 end
    
    -- 如果condition为true,则返回value1,否则返回value2,可以嵌套
    if(condition, value1, value2)
    
  • 案例:

    • 数据准备

      -- 原始数据 emp_sex.txt
      悟空  A  男
      大海  A  男
      宋宋  B  男
      凤姐  A  女
      婷姐  B  女
      婷婷  B  女
      
      -- 建表并导入数据
      create table emp_sex
      (
          name string, 
          dept_id string, 
          sex string
      ) 
      row format delimited fields terminated by "\t";
      
      load data local inpath '/opt/module/hive/datas/emp_sex.txt' into table emp_sex;
      
    • 需求:求出不同部门男女各多少人

      select
      	dept_id,
      	sum(case when sex='男' then 1 else 0 end) as maleNum,
      	sum(case when sex='女' then 1 else 0 end) as femaleNum
      from emp_sex
      group by dept_id;
      
      select
      	dept_id,
      	sum(if(sex='男', 1, 0)) as maleNum,
      	sum(if(sex='女', 1, 0)) as femaleNum
      from emp_sex
      group by dept_id;
      
      
2.3 拼接函数
  • CONCAT(string A/col1, string B/col2…):拼接输入的字符串或列,支持任意个输入字符串
  • CONCAT_WS(separator, [str1, str2,...|array<string>]): 按指定的分隔符拼接输入的字符串或字符数组。如果分隔符是 NULL,返回值也将为 NULL。这个函数会跳过分隔符参数后的任何 NULL 和空字符串
  • COLLECT_LIST(col):函数只接受基本数据类型,可以将某字段的值进行汇总,产生 Array 类型字段
  • COLLECT_SET(col):函数只接受基本数据类型,可以将某字段的值进行去重汇总,产生 Array 类型字段
-- 需求:把星座和血型一样的人归类到一起。结果如下:
射手座,A    唐僧|沙僧
白羊座,A    孙悟空|猪八戒
白羊座,B      白龙马|哪吒

-- 原始数据 person_info.txt
孙悟空  白羊座  A
唐僧  射手座  A
白龙马  白羊座  B
猪八戒  白羊座  A
沙僧  射手座  A
哪吒  白羊座  B

-- 建表并导入数据
create table person_info
(
    name string, 
    constellation string, 
    blood_type string
) 
row format delimited fields terminated by "\t";

load data local inpath "/opt/module/hive/datas/person_info.txt" into table person_info;

-- 实现
select
	a.cb,
	concat_ws('|',collect_set(a.name)) as names
from
(
	select
    	concat(constellation,',',blood_type) as cb,
    	name
    from person_info
) a
group by a.cb

2.4 列转行
  • EXPLODE(col):将类型为 Array 或者 Map 列结构拆分成多行

  • POSEXPLODE(col):将类型为 Array 或者 Map 列结构拆分成多行,并且带上行号

  • LATERAL VIEW:侧写,用于和 split, explode,posexplode 等 UDTF 一起使用,能够将一列数据拆成多行数据,在此基础上可以对拆分后的数据进行聚合形成侧写表

    LATERAL VIEW udtf(expression) tableAlias AS columnAlias
    
    
  • 案例:

    • 需求:将电影分类中的数组数据展开

      《疑犯追踪》    悬疑
      《疑犯追踪》    动作
      《疑犯追踪》    科幻
      《疑犯追踪》    剧情
      《Lie to me》  悬疑
      《Lie to me》  警匪
      《Lie to me》  动作
      《Lie to me》  心理
      《Lie to me》  剧情
      《战狼 2》    战争
      《战狼 2》    动作
      《战狼 2》    灾难
      
    • 数据准备:

      -- 原始数据 movie_info.txt
      《疑犯追踪》  悬疑,动作,科幻,剧情
      《Lie to me》  悬疑,警匪,动作,心理,剧情
      《战狼 2》  战争,动作,灾难
      
      -- 建表并导入数据
      create table movie_info
      (
          movie string,
          category string
      )
      row format delimited fields terminated by "\t";
      
      load data local inpath "/opt/module/data/movie.txt" into table movie_info;
      
    • 实现:

      select
      	movie,
      	icategory
      from movie_info
      lateral view explode(split(category,',')) mi as icategory;
      
2.5 窗口函数
  • OVER([partition by|distribute by] [order by|sort by] [rows between start and end]): 指定分析函数工作的数据窗口大小,这个数据窗口大小可能会随着行的该变而变,在 group by 之后执行,partition by 与 group by 不可共存

    • partition by:限定窗口的分区
    • order by:窗口内排序
      • 若不指定 ORDER BY,默认使用分区内所有行 ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING
      • 若指定了 ORDER BY,默认使用分区内第一行到当前值 ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
    • rows between [start] and [end]:start 和 end 可以使用以下形式
      • CURRENT ROW:当前行
      • n PRECEDING:往前 n 行数据
      • n FOLLOWING:往后 n 行数据
      • UNBOUNDED:无界起点
      • UNBOUNDED PRECEDING:表示从前面的起点
      • UNBOUNDED FOLLOWING:表示到后面的终点
  • LAG(col,n,default_val) over():往前第 n 行数据

  • LEAD(col,n, default_val) over():往后第 n 行数据

  • FIRST_VALUE() over():取第一行数据

  • LAST_VALUE() over():取最后一行数据

  • NTILE(n) over():把有序窗口的行分发到指定数据的组中,各个组有编号,编号从 1 开始,对于每一行,NTILE 返回此行所属的组的编号。注意:n 必须为 int 类型

  • 案例:

    • 数据准备:

      -- 原始数据 business.txt
      jack,2017-01-01,10
      tony,2017-01-02,15
      jack,2017-02-03,23
      tony,2017-01-04,29
      jack,2017-01-05,46
      jack,2017-04-06,42
      tony,2017-01-07,50
      jack,2017-01-08,55
      mart,2017-04-08,62
      mart,2017-04-09,68
      neil,2017-05-10,12
      mart,2017-04-11,75
      neil,2017-06-12,80
      mart,2017-04-13,94
      
      -- 建表并导入数据
      create table business
      (
          name string,
          orderdate string, 
          cost int
      ) 
      ROW FORMAT DELIMITED FIELDS TERMINATED BY ',';
      
      load data local inpath "/opt/module/data/business.txt" into table business;
      
      
    • 需求及实现:

      -- 查询在 2017 年 4 月份购买过的顾客及总人数
      select 
      	name,
      	count(*) over() --over在group by之后执行,针对每行数据开一个窗口,窗口数据都是一样的 
      from business
      where substring(orderdate,1,7) = '2017-04'
      group by name;
      
      -- 查询顾客的购买明细及月购买总额
      -- partition by限定每个窗口的大小
      select
      	name,
      	orderdate,
      	cost,
      	sum(cost) over(partition by name,month(orderdate)) as monthCost
      from business;
      
      -- 上述的场景,  将每个顾客的 cost 按照日期进行累加
      select
      	name,
      	orderdate,
      	cost,
      	sum(cost) over(partition by name order by orderdate asc)
      from business;
      -- 注意:当多行的 order by 值相同时这些行会合并成一个当前行
      
       -- 等价,只有order by col 默认每一行的窗口从起点行到当前行
      select
      	name,
      	orderdate,
      	cost,
      	sum(cost) over(partition by name order by orderdate asc rows between unbounded preceding and current row)
      from business;
      
      -- 查询每个顾客上次的购买时间
      select
      	name,
      	orderdate,
      	lag(orderdate,1,'1970-01-01') over(partition by name order by orderdate asc)
      from business;
      
      -- 查询前 20%时间的订单信息
      select 
      	*
      from
      (
          select
              name,
              orderdate,
              cost,
              ntile(5) over(order by orderdate asc) as rn
          from business
      ) t
      where t.rn=1;
      
      
2.6 排序函数

排序函数可以搭配 over() 窗口函数使用

  • RANK() over():排序相同时序号相同且不连续,如:1,1,3

  • DENSE_RANK() over():排序相同时序号相同且连续,如:1,1,2

  • ROW_NUMBER() over():排序相同时序号不同且连续,如:1,2,3

  • 案例:

    • 需求:计算每门学科成绩排名

    • 数据准备:

      -- 原始数据 score.txt
      孙悟空  语文  87
      孙悟空  数学  95
      孙悟空  英语  68
      大海  语文  94
      大海  数学  56
      大海  英语  84
      宋宋  语文  64
      宋宋  数学  86
      宋宋  英语  84
      婷婷  语文  65
      婷婷  数学  85
      婷婷  英语  78
      
      -- 建表并导入数据
      create table score
      (
          name string,
          subject string, 
          score int
      ) 
      row format delimited fields terminated by "\t";
      
      load data local inpath '/opt/module/data/score.txt' into table score;
      
    • 实现:

      select
      	subject,
      name,
      	score,
      	dense_rank() over(partition by subject order by score desc) as rn
      from score;
      
2.7 其他函数
2.7.1 常用日期函数
  • unix_timestamp:返回当前或指定时间的时间戳

    select unix_timestamp();
    select unix_timestamp("2020-10-28",'yyyy-MM-dd');
    
  • from_unixtime:将时间戳转为日期格式

    select from_unixtime(1603843200); -- 10 位是秒,13 位是毫秒
    
  • current_date:当前日期

    select current_date;
    
    
  • current_timestamp:当前的日期加时间

    select current_timestamp;
    
    
  • to_date:抽取日期部分

    select to_date('2020-10-28 12:12:12');
    
    
  • year:获取年

    select year('2020-10-28 12:12:12');
    
    
  • month:获取月

    select month('2020-10-28 12:12:12');
    
    
  • day:获取日

    select day('2020-10-28 12:12:12');
    
    
  • hour:获取时

    select hour('2020-10-28 12:12:12');
    
    
  • minute:获取分

    select minute('2020-10-28 12:12:12');
    
    
  • second:获取秒

    select second('2020-10-28 12:12:12');
    
    
  • weekofyear:当前时间是一年中的第几周

    select weekofyear('2020-10-28 12:12:12');
    
    
  • dayofmonth:当前时间是一个月中的第几天

    select dayofmonth('2020-10-28 12:12:12');
    
    
  • months_between: 两个日期间的月份

    select months_between('2020-04-01','2020-10-28');
    
    
  • add_months:日期加减月

    select add_months('2020-10-28',-3);
    
    
  • datediff:两个日期相差的天数

    select datediff('2020-11-04','2020-10-28');
    
    
  • date_add:日期加天数

    select date_add('2020-10-28',4);
    
    
  • date_sub:日期减天数

    select date_sub('2020-10-28',-4);
    
    
  • last_day:日期的当月的最后一天

    select last_day('2020-02-30');
    
    
  • date_format(): 格式化日期

    select date_format('2020-10-28 12:12:12','yyyy/MM/dd HH:mm:ss');
    
    
2.7.2 常用取整函数
  • round:四舍五入

    select round(3.14);
    select round(3.54);
    
    
  • ceil: 向上取整

    select ceil(3.14);
    select ceil(3.54);
    
    
  • floor:向下取整

    select floor(3.14);
    select floor(3.54);
    
    
2.7.3 常用字符串操作函数
  • upper:转大写

    select upper('low');
    
    
  • lower:转小写

    select lower('low');
    
    
  • length:长度

    select length("atguigu");
    
    
  • trim:前后去空格

    select trim(" atguigu ");
    
    
  • lpad:向左补齐,到指定长度

    select lpad('atguigu',9,'g');
    
    
  • rpad:向右补齐,到指定长度

    select rpad('atguigu',9,'g');
    
    
  • regexp_replace:使用正则表达式匹配目标字符串,匹配成功后替换

    SELECT regexp_replace('2020/10/25', '/', '-');
    
    
  • substring/substr:提取字符串子串

    select substring('abc',1,2);
    
    
2.7.4 集合操作
  • size:集合中元素的个数

    select size(friends) from test3;
    
    
  • map_keys:返回map中的key

    select map_keys(children) from test3;
    
    
  • map_values:返回map中的value

    select map_values(children) from test3;
    
    
  • array_contains:判断array中是否包含某个元素

    select array_contains(friends,'bingbing') from test3;
    
    
  • sort_array:将array中的元素升序排序

    select sort_array(friends) from test3;
    
    
2.8 多维分析函数
  • 语法:

    -- grouping sets():将 group by 的字段按多个组合维度进行聚合统计
    group by a,b grouping sets((a,b), a, b, ())
    --类似于
    group by a,b
    union all
    group by a
    union all
    group by b
    union all
    
    
    --with cube:多维分析
    group by a,b with cube
    --类似于
    group by a,b grouping sets((a,b), a, b, ())
    
    --with rollup:上卷,按照 group by 字段从前往后顺序组合
    group by a,b with rollup
    --类似于
    group by a,b grouping sets((a,b), a, ())
    
    
  • 案例:

    -- 原始数据 staff.txt
    1001,zhangsan,male,10
    1002,lisi,female,10
    1003,Jerry,male,20
    1004,Kitty,female,20
    1005,Jack,male,30
    1006,Rose,female,30
    
    -- 创建表并导入数据
    create table staff
    (
    	id string,
        name string,
        gender string,
        deptId string
    )
    row format delimited fields terminated by ',';
    
    load data inpath '/opt/module/hive/datas/staff.txt' into table staff;
    
    -- 实现:所有员工人数、各部门员工人数、各性别员工人数、各部门各性别员工人数在同一张表展示
    select
    	deptId,
    	gender,
    	count(1) as num
    from staff
    group by deptId,gender
    grouping sets((deptId,gender),deptId,gender,())
    --with cube
    ;
    
    --等价于分别按不同维度分组聚合后再 union all 成一张表
    
    

三、自定义函数

1. 自定义 UDF 函数

所有 UDF 函数的父类是 org.apache.hadoop.hive.ql.udf.generic.GenericUDF

1.1 需求

自定义一个仿 length() 方法的函数

1.2 编码
  • 创建 Maven 工程并引入依赖

    <dependencies>
        <dependency>
            <groupId>org.apache.hive</groupId>
            <artifactId>hive-exec</artifactId>
            <version>3.1.2</version>
        </dependency>
    </dependencies>
    
  • 编写一个类并继承 GenericUDF

    import org.apache.hadoop.hive.ql.exec.UDFArgumentException;
    import org.apache.hadoop.hive.ql.exec.UDFArgumentLengthException;
    import org.apache.hadoop.hive.ql.exec.UDFArgumentTypeException;
    import org.apache.hadoop.hive.ql.metadata.HiveException;
    import org.apache.hadoop.hive.ql.udf.generic.GenericUDF;
    import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector;
    import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorFactory;
    /**
    *  自定义 UDF 函数,需要继承 GenericUDF 类
    *  需求:  计算指定字符串的长度
    */
    public class MyStringLength extends GenericUDF {
        /**
        *
        * @param arguments  输入参数类型的鉴别器对象
        * @return  返回值类型的鉴别器对象
        * @throws UDFArgumentException
        */
        @Override
        public ObjectInspector initialize(ObjectInspector[] arguments) throws UDFArgumentException { 
            //  判断输入参数的个数
            if(arguments.length !=1){
            	throw new UDFArgumentLengthException("Input Args LengthError!!!");
            }
            //  判断输入参数的类型
            if(!arguments[0].getCategory().equals(ObjectInspector.Category.PRIMITIVE))
            {
                throw new UDFArgumentTypeException(0,"Input Args TypeError!!!");
            }
            //函数本身返回值为 int,需要返回 int 类型的鉴别器对象
            return PrimitiveObjectInspectorFactory.javaIntObjectInspector;
        }
        
        /**
        *  函数的逻辑处理
        * @param arguments  输入的参数
        * @return  返回值
        * @throws HiveException
        */
        @Override
        public Object evaluate(DeferredObject[] arguments) throws HiveException {
            if(arguments[0].get() == null){
            	return 0;
            }
            return arguments[0].get().toString().length();
        }
        
        // 执行 explain 时返回的信息
        @Override
        public String getDisplayString(String[] children) {
            return "";
        }
    }
    
  • 将 Maven 工程打成 jar 包

1.3 创建 Hive 函数
  • 将打好的 jar 包传输到 hive 安装目录的 lib 目录下

  • 将 jar 包加载到 hive 的 classpath

    add jar /opt/module/hive/lib/MyStringLength.jar;
    
  • 创建函数与开发好的 java class 关联

    create [temporary] function my_len as "com.demo.hive.MyStringLength";
    
  • 使用测试

    select my_len('hello');
    

1.2 自定义 UDTF 函数

所有 UDTF 函数的父类是 org.apache.hadoop.hive.ql.udf.generic.GenericUDTF

1.2.1 需求

自定义一个 UDTF 实现将一个任意分割符的字符串切割成独立的单词

select myudtf("hello,world,hadoop,hive", ",");
hello
world
hadoop
hive

1.2.2 编码
  • 创建 Maven 工程并引入依赖

    <dependencies>
        <dependency>
            <groupId>org.apache.hive</groupId>
            <artifactId>hive-exec</artifactId>
            <version>3.1.2</version>
        </dependency>
    </dependencies>
    
    
  • 编写一个类并继承 GenericUDTF

    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.PrimitiveObjectIn
    spectorFactory;
    import java.util.ArrayList;
    import java.util.List;
    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);
            //3.最终返回值
            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 {
        }
    }
    
    
  • 将 Maven 工程打成 jar 包

1.2.3 创建 Hive 函数
  • 将打好的 jar 包传输到 hive 安装目录的 lib 目录下

  • 将 jar 包加载到 hive 的 classpath

    add jar /opt/module/hive/lib/MyUDTF.jar;
    
  • 创建函数与开发好的 java class 关联

    create [temporary] function myudtf as "com.demo.hive.MyUDTF";
    
  • 使用测试

    select myudtf("hello,world,hadoop,hive", ",");
    
  • 25
    点赞
  • 10
    收藏
    觉得还不错? 一键收藏
  • 1
    评论

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值