Hive 数据仓库技术

HIve 的基本使用

1.概述

Hive 是建立在Hadoop上的数据仓库基础构架。用于进行数据的ETL（Extract、Translation、Load）提取、转化、加载。不提供OLTP（在线事务处理），多使用在大数据集的批处理作业。

2.架构

特性：

① Hive存储文件的系统使用的HDFS。
② Hive计算模型使用的是 MapReduce。
③ 实时性很差。
④ 容易扩展自己的存储能力和计算能力。

3.安装使用

3.1 前置条件：

·1. 可用的MySQL服务
MySQL数据库的编码必须是Latin1编码

·2. 正常运行的HDFS、YARN
必须配置HADOOP_HOME环境变量，这样Hive可以通过HADOOP_HOME环境变量感知用户的Hadoop计算集群的位置和规模。

3.2 安装步骤

① 解压安装包

② hive-site.xml

进入conf/文件夹，创建hive-site.xml文件。

<?xml version="1.0"?>
<?xml-stylesheet type="text/xsl" href="configuration.xsl"?>

<configuration>
  
  <property>
    <name>javax.jdo.option.ConnectionURL</name>
    <value>jdbc:mysql://你的主机名:3306/hive?createDatabaseIfNotExist=true</value>
  </property>
  
  <property>
    <name>javax.jdo.option.ConnectionDriverName</name>
    <value>com.mysql.jdbc.Driver</value>
  </property>
  
  <property>
    <name>javax.jdo.option.ConnectionUserName</name>
    <value>root</value>
  </property>
  
  <property>
    <name>javax.jdo.option.ConnectionPassword</name>
    <value>root</value>
  </property>

</configuration>

③ 将MySQL的驱动jar拷贝到lib目录下

cp ~/mysql-connector-java-5.1.10-bin.jar lib/

• 注意 ： 尽量不要使用 mysql-connector-java-5.1.18.jar 会出现各种错误。

④ 配置HIVE_HOME环境变量

4.启动

单用户模式

hive

多用户模式

• 后台启动服务

hiveserver2 >/dev/null 2>&1 &  

• 进入控制台

beeline -u jdbc:hive2://你的主机名:10000 -n root 

5.DDL

5.1 数据类型

Hive支持原始数据类型和复杂类型，原始类型包括数值型，Boolean，字符串，时间戳。复杂类型包括数组，map，struct。下面是Hive数据类型的一个总结：

原始类型

类型	描述	字面量示例
BOOLEAN	布尔值，可选值true/false	true
TINYINT	1字节的有符号整数 -128~127	1Y
SMALLINT	2个字节的有符号整数，-32768~32767	1S
INT	4个字节的带符号整数	1
BIGINT	8字节带符号整数	1L
FLOAT	4字节单精度浮点数1.0
DOUBLE	8字节双精度浮点数	1.0
DEICIMAL	任意精度的带符号小数	1.0
STRING	字符串，变长	“Abc”
VARCHAR	变长字符串	“Aac”
CHAR	固定长度字符串	“a”,’b’
BINARY	字节数组
TIMESTAMP	时间戳，纳秒精度	122327493795
DATE	日期	‘2020-01-01

复杂类型

类型	描述	字面量示例
ARRAY	有序的的同类型的集合	array(1,2)
MAP	key-value,key必须为原始类型，value可以任意类型	map(‘a’,1,’b’,2)
STRUCT	字段集合,类型可以不同	struct(‘1’,1,1.0), named_stract(‘col1’,’1’,’col2’,1,’clo3’,1.0)

5.2 库操作

• ① 查看所有库

show databases;

• ② 创建库

create database 库名;

指定位置的创建库(schema 等价 database)
关键字： location

create schema if not exists 库名 location 'hdfs:///指定的位置';

• ③ 使用库

use 库名;

• ④ 查看当前库

select current_database();

查看当前库详细信息

desc database 库名;

• ⑤ 删除库
  默认直接删除 关键字：restrict

drop database 库名 ;

级联删除 关键字：cascade

drop database 表名 cascade;

5.3 表操作

默认分隔符

在创建完表之后，需要准备数据，其中hive默认的字段分割符号如下,因此上述建表等价写法如下：

分隔符	描述
\n	对于文本文件而言，一行表示一条文本记录，因此可以使用\n表示
^A(Ctrl+A)	用于分割字符的列，在创建表的时候可以使用八进制’\001’表示
^B(Ctrl+B)	用于分割ARRAY、STRUCT或者MAP中的元素，在创建表的时候可以使用八进制’\002’表示
^C(Ctrl+C)	用于分割MAP中的key,value，在创建表的时候可以使用八进制’\003’表示

• 数据样本：
  

①创建表

• 使用不同分隔符：

# 默认分隔符格式（可省略）
create table if not exists 表名 (
  id int,
  name varchar(32),
  age int,
  salary double,
  birthDay date,
  hobbies array<string>,
  address struct<street:string,country:string>,
  detail map<string,double>
)
row format delimited
fields terminated by '\001'
collection items terminated by '\002'
map keys terminated by '\003'
lines terminated by '\n'
stored as textfile;
# -------------------------------------------------------------------

#自定义分隔符
create table if not exists 表名(
  id int,
  name string,
  sex boolean,
  age int,
  salary double,
  hobbies array<string>,
  card map<string,string>,
  address struct<country:string,city:string>
)
row format delimited
fields terminated by ','
collection items terminated by '|'
map keys terminated by '>'
lines terminated by '\n'
stored as textfile;

# 数据样本：
1,zhangsan,true,18,15000,TV|Game,001>建设|002>招商,china|bj 
2,lisi,true,28,15000,TV|Game,001>建设|002>招商,china|bj 
3,wangwu,false,38,5000,TV|Game,001>建设|002>招商,china|sh

#--------------------------------------------------------------------

#正则格式
create table if not exists 表名(
     ip string,
     app varchar(32),
     service string,
     last_time timestamp
)
ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.RegexSerDe'
WITH SERDEPROPERTIES (
  "input.regex"="^(.*)\\s(.*)\\s(.*)\\s(.*\\s.*)$"
);

#数据样本：
192.168.0.1 qq com.xx.xx.XxxService#xx 2018-10-10 10:10:00
192.168.2.1 qq com.xx.xx.XxxService#xx 2018-10-10 10:10:00
192.168.0.1 xx com.xx.xx.XxxService#xx 2018-10-10 10:10:00
192.168.202.1 qq com.xx.xx.XxxService#xx 2018-10-10 10:10:00

#--------------------------------------------------------------------

#CSV格式（无限制表格）
CREATE TABLE if not exists 表名(
  id int,
  item string,
  count int,
  price double
)
ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.OpenCSVSerde'
WITH SERDEPROPERTIES (
   "separatorChar" = ",",
   "escapeChar"    = "\\"
);

#数据样本：
1,apple,3,20.5
2,orange,2,21.5
3,pear,2,22.5
4,banana,1,23.0

#--------------------------------------------------------------------

#JSON格式
# 注意：使用JSON格式，需要先执行添加jar包的命令：
add  jar /你的安装目录/apache-hive-1.2.2-bin/hcatalog/share/hcatalog/hive-hcatalog-core-1.2.2.jar

#第二步再建表（注意：删除json表，需要先执行delete命令删除jar包）
create table if not exists 表名(
   id int,
   name varchar(32),
   sex boolean,
   register date,
   score double
)ROW FORMAT SERDE 'org.apache.hive.hcatalog.data.JsonSerDe';

#数据样本：
{"id":1,"name":"zhangsan","sex":true,"register":"1991-02-08","score":100.0}
{"id":2,"name":"lisi","sex":true,"register":"1991-02-08","score":80.0}

表的 5 大类型：

1. 内部表（managed_table 管理表) 默认类型
   删除表时，会删除表数据以及元数据

create table if not exists 表名(...)

2. 外部表 (external_table)
   删除表时，只会删除元数据不会删除表数据

create external table if not exists 表名()

3. 分区表
   表可以包含一个或多个分区列，程序会为分区列中的每个不同值组合创建单独的数据目录。查询数据时，就不必要每次都扫描整张表，从而提升查询性能。

• 分区表是为了将文件按照分区文件夹进行粗粒度文件隔离
  关键字：partitioned by

create external table 表名(
....
)
 partitioned by (某一字段 + 字段属性)
 ....;   

4. 分桶表

• 分桶表是将数据按照某个字段进行hash计算出所属的桶，然后在对桶内的数据进行排序 。
  关键字： clustered by (…)sorted by(…) into * buckets

create external table 表名(
...
)
clustered by(字段名) sorted by(字段名) into 数量 buckets;

注意：对桶表插入数据需要先执行

#强制使用桶
set hive.enforce.bucketing = true;

5. 临时表（temporary_table）
   临时表的数据将存储在用户的暂存目录中，并在会话结束后删除
   不支持分区列 不支持创建索引

create temporary table if not exists 表名(...);

Creat as 创建表

• 拷贝表内容不包含结构(关键字：create as)

create temporary table 表名 as select * from 表名 ;

• 复制表结构(关键字：create like)

create temporary  table 表名 like 表名 location '指定路径'

②修改表

• 关键字： alter

重命名

alter table 表名 rename to 新名

修改列类型

alter table 表名 change 字段名 字段名 字段新类型;

修改列顺序

alter table 表名 change 字段名 字段名 字段类型 after 另一字段名;

新增列

alter table 表名 add columns (列名 列类型);

③删除表

截断表（清空表）

关键字：truncate
注意：要求被截断的表必须是管理表（内部表）
[ ]为可选内容

truncate table 表名 [partition(字段名=具体数字)];

删除表（不清空数据,只删除映射关系）

关键字：drop
[ ]为可选内容

drop table 表名 [purge];

另： purge 直接删除数据，不进入回收站（管理表）

• 在core-site.xml中配置回收站保留时间：

<property>
  <name>fs.trash.interval</name>
  <value>5</value> #最多允许数据在垃圾回收站保留5分钟
</property>

查看表

desc 表名;

查看表信息

desc formatted 表名;

列出所有表

show tables in 库名;

查看分区

show partitions 表名;

查看建表语句

show create table 表名;

6.DML

①自动执行

单用户模式下启动hive,可附加指令，将自动执行。
注：-e: 执行 -f : 执行某个文件

hive -e 'show tables';

hive -f '本地的sql文件'

②写操作

数据加载

[ ]为可选内容
local 表示 本地文件 ，不选择则为HDFS文件

load data [local] inpath '文件路径' overwrite into table 表名 [partition(字段名=数值)];

查询结果插入已知表中

• 覆盖

insert overwrite table 表名	[partition(字段名=数值)] select ...from 表名 [partition(字段名=数值)];

• 追加

insert into table 表名	[partition(字段名=数值)] select ...from 表名 [partition(字段名=数值)];

• 插入多个表中

from 表名
insert overwrite table 新表名1 partition(字段名=数值1) select ...  where 字段名=数值1
insert overwrite table 新表名 partition(字段名=数值2) select ...  where 字段名=数值2
insert overwrite table 新表名 partition(字段名=数值3) select ...  where 字段名=数值3;

• 插入动态分区

先执行开启动态分区：

set hive.exec.dynamic.partition.mode=nonstrict;

再执行插入数据

insert overwrite table 表名 partition(属性名) select ...from 表名2;

③读操作

0. 查询结果写出到文件系统

[ ]为可选内容
local 为本地文件系统，不选择则为HDFS

insert overwrite [local] directory '目录名' [row format delimited fields terminated by ',' stored as textfile] select ... from 表名;

1. 普通查询

select ...from 表名;

2. where 查询

select ... from 表名 where 

3. 去重查询 distinct

select distinct(属性名) from 表名;

4. 限制(分页)查询 limit

select ... from 表名  limit 数量;

5. group by 查询

hive.map.aggr控制程序如何进行聚合。默认值为false。如果设置为true，Hive会在map阶段就执行一次聚合。这可以提高聚合效率，但需要消耗更多内存。

set hive.map.aggr=true;

再执行 group by

select ... from 表名 group by 属性名;

6. 排序查询

order by 与 sort by

• order by 全局排序

select ... from 表名 order by 属性名 排序规则;

由于ORDER BY的时间可能很长，如果你设置了严格模式(hive.mapred.mode = strict)，则其后面必须再跟一个limit子句。

set hive.mapred.mode = strict;

select ... from 表名  order by 属性名 排序规则 limit 数量;

• sort by 每个reduce局部排序 ,可以保证每个Reducer的输出数据是有序的，但不能保证全局有序。

set mapreduce.job.reduces=数量;

select ... from  表名 sort by 属性名 排序规则;

7. 过滤查询

having

select ... from 表名 group by 属性名 having 过滤条件;

8. 规则散列查询

把具有相同Key值的数据分发到同一个Reducer进行处理，这就需要使用DISTRIBUTE BY字句。
distribute by

select ... from 表名 distribute by 字段名;

9.cluster by 查询

如果SORT BY和DISTRIBUTE BY指定的是相同字段，且SORT BY排序规则是ASC 升序，此时可以使用CLUSTER BY进行替换。
分发策略和排序策略一致，可选。

select ... from 表名 cluster by 

10. 表连接

Hive支持内连接，外连接，左外连接，右外连接，笛卡尔连接，这和传统数据库中的概念是一致的。

• 内连接

select ... from 左表 join 右表 on 连接条件;

• 外连接

select ... from 左表 left outer join 右表 on 连接条件;
select ... from 左表 right outer join 右表 on 连接条件;
select ... from 左表 full outer join 右表 on 连接条件;

• 左半连接
  JOIN 子句中右边的表只能在 ON 子句中设置过滤条件;
  查询结果只包含左边表的数据，所以只能SELECT左表中的列;

select ... from 左表 left semi join 右表 on 连接条件;

join 优化
在多表进行join的时候，如果每个ON子句都使用到共同的列，此时Hive会进行优化，将多表JOIN在同一个map / reduce作业上进行。同时假定查询的最后一个表是最大的一个表，在对每行记录进行JOIN操作时，它将尝试将其他的表缓存起来，然后扫描最后那个表进行计算。因此用户需要保证查询的表的大小从左到右是依次增加的。

相关链接参考：join优化
streamtable
然而用户并非需要总是把最大的表放在查询语句的最后面，Hive提供了/*+ STREAMTABLE() */标志，使用该标识来指出大表，能避免数据表过大导致占用内存过多而产生的问题。

示例如下:

select /*+ streamtable(e) */ e.empno,e.ename,d.dname,d.deptno FROM t_employee e JOIN t_dept d ON e.deptno = d.deptno WHERE job='CLERK';

mapjoin
如果在进行join操作时，有一个表很小，则可以将join操作调整到map阶段执行。这就是典型的极大表和极小表关联问题。
有两种解决方式：

• 1.增加/*+ MAPJOIN(b) */标示；
• 2.设置参数hive.optimize.bucketmapjoin = true(使用桶)

示例如下：

select /*+ MAPJOIN(d) */ e.empno, e.ename,d.dname FROM t_employee e  JOIN t_dept d ON d.deptno = e.deptno;

11. 开窗函数

跳出本体，看全局。
关键字：over(partition by 字段名)

select ... over(partition by 字段名）from 表名;

• 排行榜(紧密排名) 不会出现并列

select ...dense_rank() over(partition by 字段名 order by 字段名 desc) as rank from 表名;

• 统计前几名

select ... sum(1) over (partition by 字段名1 order by 字段名2 desc rows between unbounded preceding and unbounded following) from 表名 order by 字段名3

#----------------------
rows between  unbounded(无限的) preceding(前面) and unbounded following(后面);

rows between unbounded preceding and current row(当前行);

rows between -1 preceding(前一个) and 1 following(后一个);

12. cube 分析 （多维度计算）

聚合函数 group by 多字段、多维度、各种组合分析
关键字： with cube

select e.deptno,e.job,avg(e.sal) avg,max(e.sal) max,min(e.sal) min from t_employee e group by e.deptno,e.job with cube;

13. 行转列

可以将 列存储 的文件转换为 行存储 的形式输出展示。

• 示例：

#建表语句
CREATE TABLE student(
    id INT,
    course STRING,
    score double)
row format delimited
fields terminated by ','
collection items terminated by '|'
map keys terminated by '>'
lines terminated by '\n'
stored as textfile;

#---------------------------------
#数据样本：
1,语文,100
1,数学,100
1,英语,100
2,数学,79
2,语文,80
2,英语,100

• 执行列转行前查询：

select * from student;

+---------------+-------------------+------------------+--+
| t_student.id  | t_student.course  | t_student.score  |
+---------------+-------------------+------------------+--+
| 1             | 语文                | 100.0            |
| 1             | 数学                | 100.0            |
| 1             | 英语                | 100.0            |
| 2             | 数学                | 79.0             |
| 2             | 语文                | 80.0             |
| 2             | 英语                | 100.0            |
+---------------+-------------------+------------------+--+

• 执行列转行后的查询：

select id,max(case course when '语文' then score else 0 end) as chinese,max(case course when '数学' then score else 0 end ) as math,max(case course when '英语' then score else 0 end ) as english from t_student group by id ;

+-----+----------+--------+----------+--+
| id  | chinese  |  math  | english  |
+-----+----------+--------+----------+--+
| 1   | 100.0    | 100.0  | 100.0    |
| 2   | 80.0     | 79.0   | 100.0    |
+-----+----------+--------+----------+--+

数据倾斜

当我们在执行HiveQL或者运行MapReduce作业时候，如果遇到一直卡在map100%,reduce99%一般就是遇到了数据倾斜的问题。

解决方案：

set hive.map.aggr=true
set hive.groupby.skewindata=true

• hive.map.aggr=true 这个配置项代表是否在map端进行聚合
• hive.groupby.skwindata=true 当选项设定为 true，生成的查询计划会有两个 MR Job。第一个 MR Job 中，Map 的输出结果集合会随机分布到 Reduce 中，每个 Reduce 做部分聚合操作，并输出结果，这样处理的结果是相同的 Group By Key 有可能被分发到不同的 Reduce 中，从而达到负载均衡的目的；第二个 MR Job 再根据预处理的数据结果按照 Group By Key 分布到 Reduce 中（这个过程可以保证相同的 Group By Key 被分布到同一个 Reduce 中），最后完成最终的聚合操作。
  原作者：麦田里的守望者·

Hive On Hbase

使用hive 操作 hbase 的数据。在hive建立映射关系表，映射hbase的表。

示例：

• 首先 ，在测试时，先执行删除所有的hbase的所有的zookmapper 与 hadoop相关文件。

hbase clean --cleanAll

然后建立映射表, * 注：此时的hbase中应已经存在目标表。

create external table t_employee_hbase(empno INT,
    ename STRING,
    job STRING,
    mgr INT,
    hiredate TIMESTAMP,
    sal DECIMAL(7,2),
    comm DECIMAL(7,2),
    deptno INT)
STORED BY 'org.apache.hadoop.hive.hbase.HBaseStorageHandler'
WITH SERDEPROPERTIES("hbase.columns.mapping" = ":key,cf1:name,cf1:job,cf1:mgr,cf1:hiredate,cf1:sal,cf1:comm,cf1:deptno") 
TBLPROPERTIES("hbase.table.name" = "baizhi:t_employee");

这时执行各种查询语句，即读的操作应该全部正常。

• 当执行写操作时，即向 hbase 中写数据时会报错：
  
  查看日志：NoSuchMethodError，出现此问题的原因是：Hive 和 Hbase的兼容性问题
  此时的解决方案是：替换hive-hbase-handler-1.2.2.jar
• 具体操作：原文链接
  ①创建一个Maven项目，添加以下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.myporject</groupId>
    <artifactId>hive-hbase-handler</artifactId>
    <version>1.2.2</version>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>6</source>
                    <target>6</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

    <dependencies>
        <dependency>
            <groupId>org.apache.hive</groupId>
            <artifactId>hive-serde</artifactId>
            <version>1.2.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hive</groupId>
            <artifactId>hive-jdbc</artifactId>
            <version>1.2.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hive</groupId>
            <artifactId>hive-service</artifactId>
            <version>1.2.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hive</groupId>
            <artifactId>hive-common</artifactId>
            <version>1.2.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hive</groupId>
            <artifactId>hive-exec</artifactId>
            <version>1.2.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-common</artifactId>
            <version>2.9.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-client</artifactId>
            <version>1.2.4</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-server</artifactId>
            <version>1.2.4</version>
        </dependency>
    </dependencies>

</project>

②将hbase-handler源码拷贝到项目的src目录下
③执行mvn package指令，打包生成hive-hbase-handler-1.2.2.jar,然后将该jar替换HIVE_HOME/lib下的hive-hbase-handler-1.2.2.jar下。

• 下面放上已经准备好的jar包，同时还有已改的源码文件供参考。
• 获取密码：5ahc
  点击获取

UDF（User Define Function）

#查看库中已建立的函数
show functions;

UDF函数其实就是一个简单的函数，执行过程就是在Hive转换成MapReduce程序后，执行java方法，类似于像MapReduce执行过程中加入一个插件，方便扩展。
UDF：针对单行数据操作，需要继承UDF

• pom.xml:

		<dependency>
           <groupId>org.apache.hive</groupId>
           <artifactId>hive-exec</artifactId>
           <version>1.2.2</version>
       </dependency>

       <dependency>
           <groupId>org.apache.hadoop</groupId>
           <artifactId>hadoop-common</artifactId>
           <version>2.9.2</version>
       </dependency>

• 继承 UDF

示例：(功能：实现给部门编号添加 “部门” 二字)

package com.baizhi;
import org.apache.hadoop.hive.ql.exec.UDF;

//evaluate方法的参数和返回值需要用户根据自己的需求定义
public class UDFDept extends UDF {
   public String  evaluate(Integer deptno){
       return "["+deptno+"] 部门";
   }
}

打包并部署

• 测试shell：

#添加此jar包
add jar /root/hive-function-1.0-SNAPSHOT.jar;
#加载此函数
create temporary function dept_fun as 'com.baizhi.DeptUDF';
#执行测试
select dept_fun(20);

UDTF

UDTF:操作一个数据行，产生多个数据行或者是多个列，需要用户继承GenericUDTF
UDAF:操作多个数据行，产生一个数据行,主要用以聚合统计，需要继承AbstractGenericUDAFResolver (Hive本身提供的已足够强大)

• 继承 GenericUDTF

示例：(功能：实现将一行员工的信息 拆分为 id ,name ,sex)

package com.baizhi;

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.Arrays;
import java.util.List;

public class UserUDTF extends GenericUDTF {
    @Override
    public StructObjectInspector initialize(StructObjectInspector argOIs) throws UDFArgumentException {
        List<ObjectInspector> objectInspectors=new ArrayList<ObjectInspector>();
        
        objectInspectors.add(PrimitiveObjectInspectorFactory.javaIntObjectInspector);
        objectInspectors.add(PrimitiveObjectInspectorFactory.javaStringObjectInspector);
        objectInspectors.add(PrimitiveObjectInspectorFactory.javaBooleanObjectInspector);

        //返回的类型参数
        return ObjectInspectorFactory.getStandardStructObjectInspector(Arrays.asList("id","name","sex"),objectInspectors);
    }

    public void process(Object[] args) throws HiveException {

        String value = args[0].toString();//获取一行的全部信息
        String sep= args[1].toString();//获取分隔符
        String[] tokens = value.split(sep);
        forward(Arrays.asList(Integer.parseInt(tokens[0]),tokens[1],Boolean.valueOf(tokens[2])));

    }

    public void close() throws HiveException {

    }
}

打包并部署

• 测试：

#添加此jar包
add jar /root/hive-function-1.0-SNAPSHOT.jar;
#加载此函数
create temporary function user_fun as 'com.baizhi.UserUDTF';
#执行函数测试
select user_fun('1,zhangsan,true',',');

• 测试的第二种方法
  创建 sql 文件，使用单用户模式启动。

#执行此命令，在 sql 文件中可以不用写再添加 jar 包的命令
hive -f function.sql --auxpath /root/hive-function-1.0-SNAPSHOT.jar 

• 以下已提供打包好的测试jar 包 及 源码文件
  获取密码：qk3t
  点击获取

https://cwiki.apache.org/confluence/display/Hive/LanguageManual+UDF 获取更多函数