Hive SQL中的重要函数练习

最新推荐文章于 2024-04-22 13:33:52 发布

DevinKim

最新推荐文章于 2024-04-22 13:33:52 发布

阅读量921

点赞数 3

分类专栏： Hive 文章标签： Hive SQL UDF Hive函数 Hive窗口函数自定义UDF

本文链接：https://blog.csdn.net/Yanxu_Jin/article/details/99618737

版权

Hive 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

Hive Function

文章目录

- Hive Function

一.取整函数

(一)round四舍五入取整

select round(3.14);

(二)指定精度取整

select round(3.1415926,4);

(三)rfloor向下取整函数

select floor(3.8);

(四)ceil向上取整

select ceil(3.1415);
select ceiling(3.1415);

(五)取(0~1)随机数

select rand();

二.日期函数(重点)

(一)转化UNIX时间戳(起始时间: 1970-01-01 00:00:00 UTC)

select from_unixtime(1323308943,'yyyy-MM-dd');

(二)获取当前UNIX时间戳

select unix_timestamp();

(三)日期转换为UNIX时间
默认使用"yyyy-MM-dd HH:mm:ss"的日期格式

select unix_timestamp('2019-08-06 17:07:15');
select unix_timestamp('2019年08月06日 17时07分15秒','yyyy年MM月dd日 HH时mm分ss秒');

(四)提取时间中的信息

select to_date('2019-08-06 17:13:01');
select year('2019-08-06 17:13:01');
select month('2019-08-06 17:13:01');
select day('2019-08-06 17:13:01');
select hour('2019-08-06 17:13:01');
select minute('2019-08-06 17:13:01');
select second('2019-08-06 17:13:01');

(五)提取日期所在的周数

select weekofyear('2019-08-06 17:13:01');

(六)日期比较函数

select datediff('2019-8-6','2019-4-29');

(七)日期增加/减少天数

select date_add('2019-8-6',10);
select date_sub('2019-8-6',10);

三.条件函数

(一)if函数

select if(1=2,100,200);

(二)case函数(重点)

#创建数据库
create database hive_function;
use hive_function;

create table students(id int,name String);

insert into students values (1,'zhangsan'),(2,'lisi'),(3,'wangwu');

select 
case id 
when 1 then '奇数' 
when 2 then '偶数' 
else '大于2' 
end as result 
from students;

四.字符串函数(重点)

(一)字符串长度

select length('hello,Hive!');

(二)字符串反转

select reverse('abcdefg');

(三)字符串拼接

#不使用分隔符拼接
select concat('My ','name ','is ','DevinKim.');

#使用分隔符拼接
select concat_ws('---','t_001','zhangsan','beijing');

(四)字符串截取

#从第3个字符截至最后, 索引从1开始, 结果cdefg
select substr('abcdefg',3);

#从第三个字符开始截取, 截取2个字符, 结果cd
select substr('abcdefg',3,2);

(五)字符串大小写转换

#小写转大写
select upper('aBcDeF');
select ucase('aBcDeF');

#大写转小写
select lower('aBcDeF');
select lcase('aBcDeF');

(六)去字符串前后空格

select trim('  a b c  ');

(七)URL解析函数parse_url
语法: parse_url(string urlString, string partToExtract [, string keyToExtract])

partToExtract参数的取值有: HOST, PATH, QUERY, REF, PROTOCOL, AUTHORITY, FILE, and USERINFO

select parse_url(
'https://www.tableName.com/path1/p.php?k1=v1&k2=v2#Ref1',
'HOST');

(八)json解析get_json_object
语法: get_json_object(string json_string, string path)

#解析json的字符串json_string,返回path指定的内容。如果输入的json字符串无效，那么返回NULL。
select  get_json_object('{"store":{"fruit":[{"weight":8,"type":"apple"},{"weight":9,"type":"pear"}],"bicycle":{"price":19.95,"color":"red"} },"email":"amy@only_for_json_udf_test.net","owner":"amy"}','$.email');

五.复合函数(重点)

Map类型:	{1:"tom",2:"jerry",3:"tim"}
Array类型:	["tom","jerry","tim"]
struct类型:	{"col1":"tom","col2":"jerry","col3":"tim"}

(一)Map类型(重点)

1.Map类型构建

#根据输入的key和value对构建map类型
select map(1,'tom',2,'jerry',3,'tim');
#列名为stu
create table map_tab as 
select map(1,'tom',2,'marry',3,'tim') as name;

2.Map类型访问操作

select name[1],name[2] from map_tab;

3.Map类型长度统计函数

select size(name) from map_tab;

(二)Array类型(重点)

1.Array类型构建

select array('tom','jerry','tim');
create table arr_tab as 
select array('tom','jerry','tim') name;

2.Array类型访问操作

select name[0],name[1] from arr_tab;

3.Array类型长度统计函数

select size(name) from arr_tab;

(三)Struct(了解)

1.Struct类型构建

select struct('tom','jerry','tim');
create table struct_tab as 
select struct('tom','jerry','tim') name;

2.Struct类型访问操作

select name.col1,name.col2 from struct_tab;

六.explorde函数(重点)

(一)使用explode函数将hive表中的Map和Array字段数据进行拆分

step1: 准备数据到文件中

#创建文件
cd /export/temp
vim funcdata1.txt

zhangsan	child1,child2,child3,child4	k1:v1,k2:v2
lisi	child5,child6,child7,child8	k3:v3,k4:v4

step2: 创建hive表，使用explode拆分map和array

#创建表
create table explode_1
(name string, children array<string>, address map<string,string>)
row format delimited fields terminated by '\t'
collection items terminated by ','
map keys terminated by ':'
stored as textFile;

#向表中加载数据
load data local inpath '/export/temp/funcdata1.txt' into table explode_1;

step3: 使用explode将hive当中数据拆开查询

将array当中的数据拆开

select explode(children) as child from explode_1;

将map当中的数据拆分开

select explode(address) as (mykey, myvalue) from explode_1;

(二)使用explode函数将hive表中的json字段进行拆分

step1: 准备数据到文件中

#创建文件
cd /export/temp
vim funcdata2.txt

a:shandong,b:beijing,c:hebei|1,2,3,4,5,6,7,8,9|[{"source":"7fresh","monthSales":4900,"userCount":1900,"score":"9.9"},{"source":"jd","monthSales":2090,"userCount":78981,"score":"9.8"},{"source":"jdmart","monthSales":6987,"userCount":1600,"score":"9.0"}]

step2: 创建hive表

create table explode_lateral_view
(`area` string, `goods_id` string, `sale_info` string)
row format delimited fields terminated by '|'
stored as textFile;

load data local inpath '/export/temp/funcdata2.txt' 
into table explode_lateral_view;

step3:使用explode将hive当中数据拆开查询

使用explode拆分Array

select explode(split(goods_id,',')) as goods_id from explode_lateral_view;

使用explode拆解Map

select explode(split(area,',')) as area from explode_lateral_view;

拆解json字段

select explode(split(regexp_replace(regexp_replace(sale_info,'\\[\\{',''),'}]',''),'},\\{')) as sale_info from explode_lateral_view;

#函数解析:
                         regexp_replace( sale_info, '\\[\\{', '' )
         regexp_replace( ________________________________________, '}]', '' )
  split( ____________________________________________________________________, '},\\{' )

在这里插入图片描述查询结果如下:

+--------------------------------------------------------------------+--+
|                             sale_info                              |
+--------------------------------------------------------------------+--+
| "source":"7fresh","monthSales":4900,"userCount":1900,"score":"9.9" |
| "source":"jd","monthSales":2090,"userCount":78981,"score":"9.8"    |
| "source":"jdmart","monthSales":6987,"userCount":1600,"score":"9.0" |
+--------------------------------------------------------------------+--+

==step4: 用get_json_object来获取key为monthSales的数据 ==

#下面代码会报错!!!
select get_json_object(explode(split(regexp_replace(regexp_replace(sale_info,'\\[\\{',''),'}]',''),'},\\{')) ,'$.monthSales') as sale_info from explode_lateral_view;

报错内容: UDTF’s are not supported outside the SELECT clause, nor nested in expressions

译为: UDTF explode不能写在别的函数内

解决办法: 使用lateral view

#lateral view explode(split(goods_id,','))goods相当于一个虚拟表，
#与原表explode_lateral_view笛卡尔积关联, 可以多重使用
select goods_id2,sale_info,area2 
       from explode_lateral_view 
       LATERAL VIEW explode(split(goods_id,','))goods as goods_id2 
       LATERAL VIEW explode(split(area,','))area as area2;

select get_json_object(concat('{',sale_info_1,'}'),'$.source') as source,
                    get_json_object(concat('{',sale_info_1,'}'),'$.monthSales') as monthSales,
                    get_json_object(concat('{',sale_info_1,'}'),'$.userCount') as userCount, 
                    get_json_object(concat('{',sale_info_1,'}'),'$.score') as score from explode_lateral_view 
                    LATERAL VIEW explode(split(regexp_replace(regexp_replace(sale_info,'\\[\\{',''),'}]',''),'},\\{'))sale_info as sale_info_1;

总结:
1.explode：炸开函数，只能炸开集合, 不能放在其他函数里面。
2.lateral view :粘贴的作用，创建一张虚拟表出来，粘贴到主表上面去，会产生笛卡尔积。

七.行转列练习(重点)

需求: 有如下数据, 把星座和血型一样的人归类到一起。

cd /export/temp/
vim constellation.txt

孙悟空	白羊座	A
老王	射手座	A
宋宋	白羊座	B
猪八戒	白羊座	A
凤姐	射手座	A

处理后数据:
	射手座,A	老王|凤姐
	白羊座,A	孙悟空|猪八戒
	白羊座,B	宋宋

创建Hive表并加载数据

create table person_info(
  name string,
  constellation string,
  blood_type string
) row format delimited fields terminated by '\t';

load data local inpath '/export/temp/constellation.txt' into table person_info;

新出现的函数: collect_set(列名): 函数只接受基本数据类型，将某字段的值进行去重汇总，产生array类型字段。

select blood_type, collect_set(name) from person_info group by blood_type;

按需求查数据:

select t1.base, concat_ws('|', collect_set(t1.name)) name from
 (select name, concat(constellation, "," , blood_type) base from person_info) t1 
 group by t1.base;

八.列转行练习(重点)

需求: 有如下数据, 将电影分类中的数组数据展开。

cd /export/temp/
vim movie.txt

《疑犯追踪》	悬疑,动作,科幻,剧情
《Lie to me》	悬疑,警匪,动作,心理,剧情
《战狼2》	战争,动作,灾难

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

创建Hive表并加载数据

create table movie_info
(movie string, category array<string>) 
row format delimited fields terminated by '\t'
collection items terminated by ',';

load data local inpath '/export/temp/movie.txt' into table movie_info;

按需求查数据:

select movie_info.movie, temp_table.new_category from movie_info 
lateral view explode(category) temp_table as new_category;

九.反射函数(重点)

reflect函数可以支持在sql中调用java中的自带函数，秒杀一切udf函数。
(一)使用java.lang.Math当中的Max求两列当中的最大值

#创建Hive表:
create table test_udf(col1 int, col2 int) 
row format delimited fields terminated by '\t';

#插入数据
insert into table test_udf values (1,2), (4,3), (6,4), (7,5), (5,6);

#使用java.lang.Math当中的Max求两列当中的最大值
select reflect("java.lang.Math","max",col1,col2) from test_udf;

(二)不同记录执行不同的java内置函数

#创建Hive表:
create table test_udf2
(class_name string,method_name string,col1 int , col2 int) 
row format delimited fields terminated by ',';

#插入数据
insert into table test_udf2 values ('java.lang.Math','min',1,2), 
('java.lang.Math','max',2,3);

#使用java.lang.Math当中的Max求两列当中的最大值
select reflect(class_name,method_name,col1,col2) from test_udf2;

(三)判断是否为数字

#使用apache commons中的函数，commons下的jar已经包含在hadoop的classpath中，所以可以直接使用。
select reflect("org.apache.commons.lang.math.NumberUtils","isNumber","123");

学习窗口函数前的准备工作:

#创建Hive表:
create table score_tab
(name string,class string,score Int)
row format delimited fields terminated by ',';

#加载数据
cd /export/temp
vim score_data.csv

张三,1,80
赵六,1,95
田七,1,92
小钱,2,76
小李,2,72
jerry,3,54
jack,3,76
王五,1,95
小赵,2,99
tom,3,100
小孙,2,92
李四,1,78

load data local inpath '/export/temp/score_data.csv' into table score_tab;

十.开窗函数(掌握)

开窗函数介绍
开窗函数的引入是为了既显示聚集前的数据，又显示聚集后的数据。即在每一行的最后一列添加聚合函数的结果。开窗用于为行定义一个窗口(这里的窗口是指运算将要操作的行的集合)，它对一组值进行操作，不需要使用 GROUP BY 子句对数据进行分组，能够在同一行中同时返回基础行的列和聚合列。
聚合函数和开窗函数区别
① 聚合函数是将多行变成一行，count,avg…
② 开窗函数是将一行变成多行；
③ 聚合函数如果要显示其他的列必须将列加入到group by中；
④ 开窗函数可以不使用group by，直接将所有信息显示出来。
开窗函数分类
①聚合开窗函数:
格式: 聚合函数(列名) OVER(选项)，选项不可以是 order by 子句。
②排序开窗函数
格式: 排序函数(列名) OVER(选项)，选项不可以是 partition by 子句。

(一)聚合开窗函数(重要)

①over 关键字表示把聚合函数当成聚合开窗函数而不是聚合函数。

#查询一共有多少学生, 并将查询结果作为新的字段加在原表之后
select name, class, score, count(name) over() as name_count from score_tab;

②over (partition by class) 表示对结果集按照 class 进行分区，并且计算当前行所属的分区的聚合计算结果。

select name, class, score, count(name) over(partition by class) name_count from score_tab;

(二)排序开窗函数(重要)

①全局排序
row_number() 表示从1开始，按照顺序，生成分组内记录的序列, 全局排序没分组(即所有数据都在一个组内)。

#按成绩进行排序, 生成排名名次, 显示排名前三的学生
select name, class, score, row_number() over(order by score desc) as rank 
from score_tab limit 3;

②分区排序

row_number() 表示从1开始，按照顺序，生成分组内记录的序列。

#按班级进行分组, 并显示每个学生的班级排名
select name, class, score, row_number() 
over(partition by class order by score desc) class_rank 
from score_tab;

③跳跃排序
rank() 生成数据项在分组中的排名，排名结果可以并列，排名相等会在名次中留下空位。

#比如第一名有两位同学, 排名结果会是: 1,1,3,4
select name, class, score, rank() 
over(partition by class order by score desc) class_rank 
from score_tab;

④连续排序
dense_rank() 生成数据项在分组中的排名，排名结果可以并列，排名相等会在名次中不会留下空位。

#比如第一名有两位同学, 排名结果会是: 1,1,2,3
select name, class, score, dense_rank() 
over(partition by class order by score desc) class_rank 
from score_tab;

⑤分片排序
ntile(n)用于将分组数据按照顺序切分成n片，返回当前行所对应的切片值，如果切片不均匀，默认增加第一个切片的分布。

select name, class, score, 
ntile(3) over(partition by class order by score desc) class_rank 
from score_tab;

(三)其他函数(知道)

①cume_dist() 小于等于当前值的行数/分组内总行数。比如，统计小于等于当前薪水的人数，所占总人数的比例

②percent_rank() 分组内当前行的rank值-1/分组内总行数-1

(四)增强聚合函数

①grouping set() 在一个group by查询中，根据不同的维度组合进行聚合。等价于将不同维度的group by结果集进行UNION ALL, 其中的grouping__id，表示结果属于哪一个分组集合。

注意: grouping__id是关键字，不能改成别的，下划线有两条 。

# 统计各班学生数量;按分数分组,统计每个分数对应的学生数量, 用一张表输出
select class, score, count(name) as stu_num, grouping__id 
from score_tab 
group by class, score 
grouping sets(class, score) 
order by grouping__id;

# 扩展: 按照class，score，以及class+score，分别进行分组求取统计数据
select 
  class, 
  score, 
  count(name) as stu_num, 
  grouping__id 
from score_tab 
  group by class, score 
  grouping sets(class, score, (class, score)) 
  order by grouping__id;

②cube 根据group by的维度的所有组合进行聚合。

依旧是上述扩展案例: 根据class, score这两个纬度(字段)组合形成的所有情况进行分组
(0)不进行任何的分组，即直接count(name)
(1)class，只按class进行分组，即count(name) group by class
(2)score，只按score进行分组, 即count(name) group by score
(3)class+score，按class, score进行分组, 即count(name) group by class, score
所以,结果会比上述扩展案例多统计一行结果, 即不分组, 统计所有学生的的数量。

# with cube
select 
  class, 
  score, 
  count(name) as stu_num, 
  grouping__id 
from score_tab 
  group by class, score 
  with cube
  order by grouping__id;

②rollup 是cube的子集，以最左侧的维度为主，从该维度进行层级聚合。

依旧是上述扩展案例: 使用rollup代替cube, 分组的情况少了一种: 只按score排序。
(0)不进行任何的分组，即直接count(name)
(1)class，只按class进行分组，即count(name) group by class
(2)class+score，按class, score进行分组, 即count(name) group by class, score

# with rollup
select 
  class, 
  score, 
  count(name) as stu_num, 
  grouping__id 
from score_tab 
  group by class, score 
  with rollup
  order by grouping__id;

十一.自定义函数

1）Hive 自带了一些函数，比如：max/min等，但是数量有限，可以通过自定义UDF来方便的扩展。

2）当Hive提供的内置函数无法满足你的业务处理需要时，此时就可以考虑使用用户自定义函数（UDF：user-defined function）。

常问的面试题:

Hive的用户自定义函数类分为三种：UDF、UDAF、UDTF, 它们之间的区别是什么？

UDF（User-Defined-Function）输入一行，输出一行, 如select upper(name) from t_person
UDAF（User-Defined Aggregation Function）用户自定义聚合函数，多进一出,如count, avg
UDTF（User-Defined Table-Generating Functions）用户自定义生成函数, 一进多出, 如explode,lateral view

(一)自定义UDF开发实例

开发步骤:
第一步：创建maven工程, 导入jar包
第二步：继承org.apache.hadoop.hive.ql.UDF, 重写evaluate方法，必须得要有返回值
第三步：打包，放到hive/lib目录下
第四步：在hive的客户端添加我们的jar包
第五步：设置函数与我们的自定义函数关联
第六步：使用自定义函数

注意:

方法名一定要叫evaluate
UDF必须要有返回类型，可以返回null，但是返回类型不能为void
UDF中常用Text/LongWritable等类型，不推荐使用java类型

①创建maven java 工程，并导入jar包

<repositories>
    <repository>
        <id>cloudera</id>
 <url>https://repository.cloudera.com/artifactory/cloudera-repos/</url>
    </repository>
</repositories>
<dependencies>
    <dependency>
        <groupId>org.apache.hadoop</groupId>
        <artifactId>hadoop-common</artifactId>
        <version>2.6.0-cdh5.14.0</version>
    </dependency>
    <dependency>
        <groupId>org.apache.hive</groupId>
        <artifactId>hive-exec</artifactId>
        <version>1.1.0-cdh5.14.0</version>
    </dependency>
</dependencies>
<build>
<plugins>
    <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.0</version>
        <configuration>
            <source>1.8</source>
            <target>1.8</target>
            <encoding>UTF-8</encoding>
        </configuration>
    </plugin>
     <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-shade-plugin</artifactId>
         <version>2.2</version>
         <executions>
             <execution>
                 <phase>package</phase>
                 <goals>
                     <goal>shade</goal>
                 </goals>
                 <configuration>
                     <filters>
                         <filter>
                             <artifact>*:*</artifact>
                             <excludes>
                                 <exclude>META-INF/*.SF</exclude>
                                 <exclude>META-INF/*.DSA</exclude>
                               <exclude>META-INF/*/RSA</exclude>
                             </excludes>
                         </filter>
                     </filters>
                 </configuration>
             </execution>
         </executions>
     </plugin>
</plugins>
</build>

②继承org.apache.hadoop.hive.ql.UDF, 重写evaluate方法，必须得要有返回值

package cn.mytest.udfdemo;

import org.apache.hadoop.hive.ql.exec.UDF;
import org.apache.hadoop.io.Text;
//需求：传入字符串，然后将字符串小写转大写,并反转后返回
public class MyHiveUDF extends UDF {
    //- 方法名一定要叫evaluate
    //- UDF必须要有返回类型，可以返回null，但是返回类型不能为void
    //- UDF中常用Text/LongWritable等类型，不推荐使用java类型
    public Text evaluate(String s) {
        if (s == null) {
            return null;
        } else {
            StringBuffer sb = new StringBuffer(s.toUpperCase());
            return new Text(sb.reverse().toString());
        }
    }
}

③将这个maven项目打包，放到/export/servers/hive-1.1.0-cdh5.14.0/lib/目录下

#改一下jar包的名字
mv original-hive_udf-1.0-SNAPSHOT.jar my_hive_udf1.jar

④在hive的客户端添加我们的jar包

add jar /export/servers/hive-1.1.0-cdh5.14.0/lib/my_hive_udf1.jar;

⑤设置函数与我们的自定义函数关联

create temporary function upper_reverse as 'cn.mytest.udfdemo.MyHiveUDF';

注意: temporary关键字创建的是临时函数, 退出客户端就会失效。

(二)创建永久函数

先介绍这一中方法

1、在${HIVE_HOME}下创建auxlib目录，将UDF文件放到这个辅助Jar包目录中，这样hive在启动时
会将其中的jar文件加载到classpath中。
	cd /export/servers/hive-1.1.0-cdh5.14.0
	mkdir -p auxlib
	mv /export/servers/hive-1.1.0-cdh5.14.0/lib/my_hive_udf1.jar auxlib/

2、指定数据库，将我们的函数创建到指定的数据库下面
	use myhive;

3、创建永久函数，与我们的函数进行关联
	create function upper_reverse as 'cn.mytest.udfdemo.MyHiveUDF';

4、查看myhive数据库下的永久函数
	show functions like 'myhive*';

5、使用永久函数(重进客户端和重启Hive后均可继续使用)
	select myhive.upper_reverse('abcd');

6、删除永久函数
	drop function myhive.upper_reverse;

(三)练习:自定义UDF解析Json

#加载数据
cd /export/temp/
vim json_tab.csv


{"movie":"1193","rate":"5","timeStamp":"978300760","uid":"1"}
{"movie":"661","rate":"3","timeStamp":"978302109","uid":"1"}
{"movie":"914","rate":"3","timeStamp":"978301968","uid":"1"}
{"movie":"3408","rate":"4","timeStamp":"978300275","uid":"1"}
{"movie":"2355","rate":"5","timeStamp":"978824291","uid":"1"}
{"movie":"1197","rate":"3","timeStamp":"978302268","uid":"1"}
{"movie":"1287","rate":"5","timeStamp":"978302039","uid":"1"}

use hive_function;
create table json_tab (info String);
load data local inpath '/export/temp/json_tab.csv' into table json_tab;

自定义UDF

<!--导入fastjson用于解析json数据-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.47</version>
</dependency>

package cn.mytest.udfdemo;

import com.alibaba.fastjson.JSONObject;
import org.apache.hadoop.hive.ql.exec.UDF;
import org.apache.hadoop.io.Text;

public class MyHiveUDF2 extends UDF {
    public Text evaluate(Text s) {
        //{"movie":"1287","rate":"5","timeStamp":"978302039","uid":"1"}
        String str = s.toString();
        Info info = JSONObject.parseObject(str, Info.class);
        return new Text(info.toString());
    }

    class Info{
        //{"movie":"1287","rate":"5","timeStamp":"978302039","uid":"1"}
        private String movie;
        private String rate;
        private String timeStamp;
        private String uid;

        public Info() {}

        public Info(String movie, String rate, String timeStamp, String uid) {
            this.movie = movie;
            this.rate = rate;
            this.timeStamp = timeStamp;
            this.uid = uid;
        }

        public String getMovie() {
            return movie;
        }

        public void setMovie(String movie) {
            this.movie = movie;
        }

        public String getRate() {
            return rate;
        }

        public void setRate(String rate) {
            this.rate = rate;
        }

        public String getTimeStamp() {
            return timeStamp;
        }

        public void setTimeStamp(String timeStamp) {
            this.timeStamp = timeStamp;
        }

        public String getUid() {
            return uid;
        }

        public void setUid(String uid) {
            this.uid = uid;
        }

        @Override
        public String toString() {
            return movie +"\t"+ rate +"\t"+ timeStamp +"\t"+ uid;
        }
    }

}

#因为使用了fastjson来解析, 所以要使用hive_udf-1.0-SNAPSHOT.jar这个包, 这个包把fastjson包装进去了
cd /export/servers/hive-1.1.0-cdh5.14.0/auxlib/
mv hive_udf-1.0-SNAPSHOT.jar my_hive_udf2.jar

#hive客户端执行
add jar /export/servers/hive-1.1.0-cdh5.14.0/auxlib/my_hive_udf2.jar;
create temporary function parse_json as 'cn.mytest.udfdemo.MyHiveUDF2';
select parse_json(info) from json_tab;

insert overwrite directory '/export/exporjson/' 
select parse_json(info) from json_tab;

更好的解决方案

#直接使用get_json_object函数查询
create table json_result as
select 
get_json_object(info,'$.movie') as movie,
get_json_object(info,'$.rate') as rate,
get_json_object(info,'$.timeStamp') as timeStamp,
get_json_object(info,'$.uid') as uid
from json_tab;