hive实战和源码编译-ag真人游戏

修改完以后分发配置文件到其他集群，然后重新启动hadoop， ./xsync为自定义的集群分发脚本

在我的shell专栏里面

 ./xsync /home/bigdata/module/hadoop-3.2.3/etc/hadoop/capacity-scheduler.xml

 然后重启hadoop就配置完成了

切换成spark

set hive.execution.engine=spark;

 切换成mr

set hive.execution.engine=mr;

hive的基本语法

hive建表语法

create [external] table [if not exists] table_name
  // 定义字段名，字段类型
  [(col_name data_type [comment col_comment], ...)]
  // 给表加上注解
  [comment table_comment]
  // 分区
  [partitioned by (col_name data_type [comment col_comment], ...)]
  // 分桶
  [clustered by (col_name, col_name, ...) 
  // 设置排序字段 升序、降序
  [sorted by (col_name [asc|desc], ...)] into num_buckets buckets]
  [
  	// 指定设置行、列分隔符 
   [row format row_format] 
   // 指定hive储存格式：textfile、rcfile、sequencefile 默认为：textfile
   [stored as file_format]
   
   | stored by 'storage.handler.class.name' [ with serdeproperties (...) ]  (note:  only available starting with 0.6.0)
  ]
  // 指定储存位置
  [location hdfs_path]
  // 跟外部表配合使用，比如：映射hbase表，然后可以使用hql对hbase数据进行查询，当然速度比较慢
  [tblproperties (property_name=property_value, ...)]  (note:  only available starting with 0.6.0)
  [as select_statement]  (note: this feature is only available starting with 0.5.0.)

建表格式1：全部使用默认建表方式

create table students
(
    id bigint,
    name string,
    age int,
    gender string,
    clazz string
)
row format delimited fields terminated by ','; 
// 必选，指定列分隔符 

建表格式2：指定location （这种方式也比较常用）

create table students2
(
    id bigint,
    name string,
    age int,
    gender string,
    clazz string
)
row format delimited fields terminated by ','
location '/input1'; 
// 指定hive表的数据的存储位置，一般在数据已经上传到hdfs，想要直接使用，会指定location，
//通常locaion会跟外部表一起使用，内部表一般使用默认的location

建表格式3：指定存储格式

create table students3
(
    id bigint,
    name string,
    age int,
    gender string,
    clazz string
)
row format delimited fields terminated by ','
stored as rcfile; 
// 指定储存格式为rcfile，inputformat:rcfileinputformat,outputformat:rcfileoutputformat，
//如果不指定，默认为textfile，
//注意：除textfile以外，其他的存储格式的数据都不能直接加载，需要使用从表加载的方式。

建表格式4：create table xxxx as select_statement(sql语句) (这种方式比较常用)

注：

1. 新建表不允许是外部表。
2. select后面表需要是已经存在的表，建表同时会加载数据。
3. 会启动mapreduce任务去读取源表数据写入新表

create table students4 as select * from students2;

建表格式5：create table xxxx like table_name 只想建表，不需要加载数据

create table students5 like students;

hive加载数据

• 使用hdfs dfs -put '本地数据' 'hive表对应的hdfs目录下'
• 使用 load data inpath

从hdfs导入数据，路径可以是目录，会将目录下所有文件导入，但是文件格式必须一致

// 将hdfs上的/input1目录下面的数据 移动至 students表对应的hdfs目录下
// 注意是 移动！移动！移动！
load data inpath '/input1/students.txt' into table students;

// 清空表
truncate table students;

从本地文件系统导入

// 加上 local 关键字 可以将linux本地目录下的文件 上传到 hive表对应hdfs 目录下 原文件不会被删除
load data local inpath '/usr/local/soft/data/students.txt' into table students;
// overwrite 覆盖加载
load data local inpath '/usr/local/soft/data/students.txt' overwrite into table students;

create table xxx as sql语句，表对表加载

create table test.aa as select * from test.bb

insert into table xxxx sql语句 （没有as），表对表加载:

// 将 students表的数据插入到students2 
//这是复制 不是移动 students表中的表中的数据不会丢失
insert into table students2 select * from students;
// 覆盖插入 把into 换成 overwrite
insert overwrite table students2 select * from students;

注：
1，如果建表语句没有指定存储路径，不管是外部表还是内部表，存储路径都是会默认在hive/warehouse/xx.db/表名的目录下。
加载的数据如果在hdfs上会移动到该表的存储目录下。注意是移动，不是复制
2，删除外部表，文件不会删除，对应目录也不会删除

hive 内部表（managed tables）vs 外部表（external tables）

外部表和普通表的区别

1. 外部表的路径可以自定义，内部表的路径需要在 hive/warehouse/目录下
2. 删除表后，普通表数据文件和表信息都删除。外部表仅删除表信息

建表语句：

// 内部表
create table students_internal
(
    id bigint,
    name string,
    age int,
    gender string,
    clazz string
)
row format delimited fields terminated by ','
location '/input2';
// 外部表
create external table students_external
(
    id bigint,
    name string,
    age int,
    gender string,
    clazz string
)
row format delimited fields terminated by ','
location '/input3';

加载数据：

hive> dfs -put /usr/local/soft/data/students.txt /input2/;
hive> dfs -put /usr/local/soft/data/students.txt /input3/;

删除表：

hive> drop table students_internal;
moved: 'hdfs://master:9000/input2' to trash at: hdfs://master:9000/user/root/.trash/current
ok
time taken: 0.474 seconds
hive> drop table students_external;
ok
time taken: 0.09 seconds

1、可以看出，删除内部表的时候，表中的数据（hdfs上的文件）会被同表的元数据一起删除；删除外部表的时候，只会删除表的元数据，而不会删除表中的数据（hdfs上的文件）
2、一般在公司中，使用外部表多一点，因为数据可以需要被多个程序使用，避免误删，通常外部表会结合location一起使用
3、外部表还可以将其他数据源中的数据 映射到 hive中，比如说：hbase，elasticsearch…
4、设计外部表的初衷就是 让 表的元数据 与 数据 解耦

hive 分区

分区表实际上是在表的目录下在以分区命名，建子目录；作用：进行分区裁剪，避免全表扫描，减少mapreduce处理的数据量，提高效率
         一般在公司的hive中，所有的表基本上都是分区表，通常按日期分区、地域分区；分区表在使用的时候记得加上分区字段；分区也不是越多越好，一般不超过3级，根据实际业务衡量

分区的概念和分区表：
分区表指的是在创建表时指定分区空间，实际上就是在hdfs上表的目录下再创建子目录。
在使用数据时如果指定了需要访问的分区名称，则只会读取相应的分区，避免全表扫描，提高查询效率。

建立分区表：

create external table students_pt1
(
    id bigint,
    name string,
    age int,
    gender string,
    clazz string
)
partitioned by(pt string)
row format delimited fields terminated by ',';

增加一个分区：

alter table students_pt1 add partition(pt='20210904');

删除一个分区：

alter table students_pt drop partition(pt='20210904');

查看某个表的所有分区

 // 推荐这种方式（直接从元数据中获取分区信息）
show partitions students_pt;
// 不推荐
select distinct pt from students_pt; 

往分区中插入数据：

insert into table students_pt partition(pt='20210902') select * from students;
load data local inpath '/usr/local/soft/data/students.txt' into table students_pt partition(pt='20210902');

查询某个分区的数据：

// 全表扫描，不推荐，效率低
select count(*) from students_pt;
// 使用where条件进行分区裁剪，避免了全表扫描，效率高
select count(*) from students_pt where pt='20210101';
// 也可以在where条件中使用非等值判断
select count(*) from students_pt where pt<='20210112' and pt>='20210110';

hive动态分区

有的时候我们原始表中的数据里面包含了 ‘‘日期字段 dt’’，我们需要根据dt中不同的日期，分为不同的分区，将原始表改造成分区表。
hive默认不开启动态分区
动态分区：根据数据中某几列的不同的取值 划分 不同的分区

# 表示开启动态分区
hive> set hive.exec.dynamic.partition=true;
# 表示动态分区模式：strict（需要配合静态分区一起使用）、nostrict
# strict： insert into table students_pt partition(dt='anhui',pt) select ......,pt from students;
hive> set hive.exec.dynamic.partition.mode=nostrict;
# 表示支持的最大的分区数量为1000，可以根据业务自己调整
hive> set hive.exec.max.dynamic.partitions.pernode=1000;

建立原始表并加载数据

create table students_dt
(
    id bigint,
    name string,
    age int,
    gender string,
    clazz string,
    dt string
)
row format delimited fields terminated by ',';

建立分区表并加载数据

create table students_dt_p
(
    id bigint,
    name string,
    age int,
    gender string,
    clazz string
)
partitioned by(dt string)
row format delimited fields terminated by ',';

使用动态分区插入数据

// 分区字段需要放在 select 的最后，如果有多个分区字段 同理，
//它是按位置匹配，不是按名字匹配
insert into table students_dt_p partition(dt) select id,name,age,gender,clazz,dt from students_dt;
// 比如下面这条语句会使用age作为分区字段，而不会使用student_dt中的dt作为分区字段
insert into table students_dt_p partition(dt) select id,name,age,gender,dt,age from students_dt;

多级分区

create table students_year_month
(
    id bigint,
    name string,
    age int,
    gender string,
    clazz string,
    year string,
    month string
)
row format delimited fields terminated by ',';
create table students_year_month_pt
(
    id bigint,
    name string,
    age int,
    gender string,
    clazz string
)
partitioned by(year string,month string)
row format delimited fields terminated by ',';
insert into table students_year_month_pt partition(year,month) select id,name,age,gender,clazz,year,month from students_year_month;

hive分桶

分桶实际上是对文件（数据）的进一步切分；hive默认关闭分桶；分桶的作用：在往分桶表中插入数据的时候，会根据 clustered by 指定的字段 进行hash分组 对指定的buckets个数 进行取余，进而可以将数据分割成buckets个数个文件，以达到数据均匀分布，可以解决map端的“数据倾斜”问题，方便我们取抽样数据，提高map join效率；分桶字段 需要根据业务进行设定

开启分桶开关

hive> set hive.enforce.bucketing=true;

建立分桶表

create table students_buks
(
    id bigint,
    name string,
    age int,
    gender string,
    clazz string
)
clustered by (clazz) into 12 buckets
row format delimited fields terminated by ','; 

往分桶表中插入数据

// 直接使用load data 并不能将数据打散
load data local inpath '/usr/local/soft/data/students.txt' into table students_buks;
// 需要使用下面这种方式插入数据，才能使分桶表真正发挥作用
insert into students_buks select * from students;

hive连接jdbc

启动hiveserver2的服务(看过我上一个阶段的小伙伴可以使用脚本操作超级方便)

hive --service hiveserver2 &

新建maven项目并添加两个依赖

    
        org.apache.hadoop
        hadoop-common
        2.7.6
    
    
    
        org.apache.hive
        hive-jdbc
        1.2.1
    

编写java通过jdbc连接hive

import java.sql.*;
public class hivejdbc {
    public static void main(string[] args) throws classnotfoundexception, sqlexception {
        class.forname("org.apache.hive.jdbc.hivedriver");
        connection conn = drivermanager.getconnection("jdbc:hive2://master:10000/test3");
        statement stat = conn.createstatement();
        resultset rs = stat.executequery("select * from students limit 10");
        while (rs.next()) {
            int id = rs.getint(1);
            string name = rs.getstring(2);
            int age = rs.getint(3);
            string gender = rs.getstring(4);
            string clazz = rs.getstring(5);
            system.out.println(id   ","   name   ","   age   ","   gender   ","   clazz);
        }
        rs.close();
        stat.close();
        conn.close();
    }
}

基本数据类型

数值型：

tinyint — 微整型，只占用1个字节，只能存储0-255的整数。
smallint– 小整型，占用2个字节，存储范围–32768 到 32767。
int– 整型，占用4个字节，存储范围-2147483648到2147483647。
bigint– 长整型，占用8个字节，存储范围-2^63到2^63-1。

布尔型

boolean — true/false

浮点型

float– 单精度浮点数。
double– 双精度浮点数。

字符串型

string– 不设定长度。

日期类型

• 时间戳 timestamp
• 日期 date

create table testdate(
    ts timestamp
    ,dt date
) row format delimited fields terminated by ',';
// 2021-01-14 14:24:57.200,2021-01-11

• 时间戳与时间字符串转换

// from_unixtime 传入一个时间戳以及pattern（yyyy-mm-dd） 
//可以将 时间戳转换成对应格式的字符串
select from_unixtime(1630915221,'yyyy年mm月dd日 hh时mm分ss秒')
// unix_timestamp 传入一个时间字符串以及pattern，
//可以将字符串按照pattern转换成时间戳
select unix_timestamp('2021年09月07日 11时00分21秒','yyyy年mm月dd日 hh时mm分ss秒');
select unix_timestamp('2021-01-14 14:24:57.200')

复杂数据类型

主要有三种复杂数据类型：structs，maps，arrays

hive hql使用语法

我们知道sql语言可以分为5大类：
(1）ddl(data definition language) 数据定义语言
用来定义数据库对象：数据库，表，列等。
关键字：create，drap,alter等
( 2）dml(data manipulation language) 数据操作语言
用来对数据库中表的数据进行增删改。
关键字：insert,delete,update等
( 3）dql(data query language)数据查询语言
用来查询数据库表的记录（数据）。
关键字：select,where 等
( 4）dcl(data control language) 数据控制语言
用来定义数据库的访问权限和安全级别，及创建用户。
关键字：grant，revoke等
(5)tcl(transaction control language) 事务控制语言
t cl经常被用于快速原型开发、脚本编程、gui和测试等方面，
关键字: commit、rollback等。

hql语法-ddl

创建数据库 create database xxxxx;
查看数据库 show databases；
删除数据库 drop database tmp;
强制删除数据库：drop database tmp cascade;
查看表：show tables；
查看表的元信息：
    desc test_table;
    describe extended test_table;
    describe formatted test_table;
查看建表语句：show create table table_xxx
重命名表：
    alter table test_table rename to new_table;
修改列数据类型：alter table lv_test change column colxx string;
增加、删除分区：
    alter table test_table add partition (pt=xxxx) 
    alter table test_table drop if exists partition(...);

hql语法-dml

where  用于过滤，分区裁剪，指定条件
join  用于两表关联，left outer join ，join，mapjoin（1.2版本后默认开启）
group by  用于分组聚合，通常结合聚合函数一起使用
order by  用于全局排序，要尽量避免排序，是针对全局排序的，即对所有的reduce输出是有序的
sort by  :当有多个reduce时，只能保证单个reduce输出有序，不能保证全局有序
cluster by = distribute by   sort by
distinct 去重

hive hql使用注意

1. count(1)、count(*)和count(字段名)执行效果上的区别
   • count(*)包括了所有的列，相当于行数，在统计结果的时候，不会忽略列值为null
   • count(1)包括了忽略所有列，用1代表代码行，在统计结果的时候，不会忽略列值为null
   • count(列名)只包括列名那一列，在统计结果的时候，会忽略列值为空（这里的空不是只空字符串或者0，而是表示null）的计数，即某个字段值为null时，不统计。
2. hql 执行优先级：
   from、where、 group by 、having、order by、join、select 、limit
3. where 条件里不支持不等式子查询，实际上是支持 in、not in、exists、not exists
4. hive中大小写不敏感
5. 在hive中，数据中如果有null字符串，加载到表中的时候会变成 null （不是字符串）
   如果需要判断 null，使用 某个字段名 is null 这样的方式来判断;或者使用 nvl() 函数，不能 直接 某个字段名 == null
6. 使用explain查看sql执行计划

hive-常用函数

关系运算

// 等值比较 = == <=>
// 不等值比较 != <>
// 区间比较： select * from default.students where id between 1500100001 and 1500100010;
// 空值/非空值判断：is null、is not null、nvl()、isnull()
// like、rlike、regexp用法

数值计算

取整函数(四舍五入)：round
向上取整：ceil
向下取整：floor

条件函数

 if(表达式,如果表达式成立的返回值,如果表达式不成立的返回值)

select if(1>0,1,0); 
select if(1>0,if(-1>0,-1,1),0);

coalesce

select coalesce(null,'1','2'); // 1 从左往右 一次匹配 直到非空为止
select coalesce('1',null,'2'); // 1

case when … then … else … end

select  score
        ,case when score>120 then '优秀'
              when score>100 then '良好'
              when score>90 then '及格'
        else '不及格'
        end as pingfen
from default.score limit 20;
#  注意条件的顺序

日期函数

select from_unixtime(1610611142,'yyyy/mm/dd hh:mm:ss');
select from_unixtime(unix_timestamp(),'yyyy/mm/dd hh:mm:ss');
// '2021年01月14日' -> '2021-01-14'
select from_unixtime(unix_timestamp('2021年01月14日','yyyy年mm月dd日'),'yyyy-mm-dd');
// "04牛2021数加16逼" -> "2021/04/16"
select from_unixtime(unix_timestamp("04牛2021数加16逼","mm牛yyyy数加dd逼"),"yyyy/mm/dd");

字符串函数

concat('123','456'); // 123456
concat('123','456',null); // null
select concat_ws('#','a','b','c'); // a#b#c
select concat_ws('#','a','b','c',null); // a#b#c 可以指定分隔符，并且会自动忽略null
select concat_ws("|",cast(id as string),name,cast(age as string),gender,clazz) from students limit 10;
select substring("abcdefg",1); // abcdefg hql中涉及到位置的时候 是从1开始计数
// '2021/01/14' -> '2021-01-14'
select concat_ws("-",substring('2021/01/14',1,4),substring('2021/01/14',6,2),substring('2021/01/14',9,2));
select split("abcde,fgh",","); // ["abcde","fgh"]
select split("a,b,c,d,e,f",",")[2]; // c
select explode(split("abcde,fgh",",")); // abcde
										//  fgh
// 解析json格式的数据
select get_json_object('{"name":"zhangsan","age":18,"score":[{"course_name":"math","score":100},{"course_name":"english","score":60}]}',"$.score[0].score"); // 100

hive-高级函数

窗口函数（开窗函数）：用户分组中开窗 

在sql中有一类函数叫做`聚合函数,例如sum()、avg()、max()等等,这类函数可以将多行数据按照规则聚集为一行,一般来讲聚集后的行数是要少于聚集前的行数的.但是有时我们想要既显示聚集前的数据,又要显示聚集后的数据,这时我们便引入了窗口函数。（开创函数，我们一般用于分组中求 topn问题）

样例演示：

数据：
111,69,class1,department1
112,80,class1,department1
113,74,class1,department1
114,94,class1,department1
115,93,class1,department1
121,74,class2,department1
122,86,class2,department1
123,78,class2,department1
124,70,class2,department1
211,93,class1,department2
212,83,class1,department2
213,94,class1,department2
214,94,class1,department2
215,82,class1,department2
216,74,class1,department2
221,99,class2,department2
222,78,class2,department2
223,74,class2,department2
224,80,class2,department2
225,85,class2,department2
建表：
create table new_score(
    id  int
    ,score int
    ,clazz string
    ,department string
) row format delimited fields terminated by ",";

窗口函数入门到精通图解之前我写过了传送门,大家可以使用这个数据，然后根据图解就能举一反三了

hive-窗口函数入门到精通_s1124654的博客-csdn博客

hive 行转列

使用关键字： lateral view explode

样例演示：

建表：
create table testarray2(
    name string,
    weight array
)row format delimited 
fields terminated by '\t'
collection items terminated by ',';
样例数据：
孙悟空	"150","170","180"
唐三藏	"150","180","190"

select name,col1  from testarray2 lateral view explode(weight) t1 as col1;

select key from (select explode(map('key1',1,'key2',2,'key3',3)) as (key,value)) t;

select name,col1,col2  from testarray2 lateral view explode(map('key1',1,'key2',2,'key3',3)) t1 as col1,col2;

select name,pos,col1  from testarray2 lateral view posexplode(weight) t1 as pos,col1;

hive 列转行 

数据：
孙悟空  150
孙悟空  170
孙悟空  180
唐三藏  150
唐三藏  180
唐三藏  190
建表：
create table testlietoline(
    name string,
    col1 int
)row format delimited 
fields terminated by '\t';

测试：

select name,collect_list(col1) from testlietoline group by name;

hive自定义函数userdefinefunction

udf：一进一出

• 创建maven项目，并加入依赖

    
            org.apache.hive
            hive-exec
            1.2.1
        

• 编写代码，继承org.apache.hadoop.hive.ql.exec.udf，实现evaluate方法，在evaluate方法中实现自己的逻辑

import org.apache.hadoop.hive.ql.exec.udf;
public class hiveudf extends udf {
    // hadoop => #hadoop$
    public string evaluate(string col1) {
    // 给传进来的数据 左边加上 # 号 右边加上 $
        string result = "#"   col1   "$";
        return result;
    }
}

• 打成jar包并上传至linux虚拟机(/usr/local/soft/jars/)
• 在hive shell中，使用 add jar 路径将jar包作为资源添加到hive环境中

add jar /usr/local/soft/jars/hiveudf2-1.0.jar;

• 使用jar包资源注册一个临时函数，fxxx1是你的函数名，'myudf’是主类名

create temporary function fxxx1 as 'myudf';

• 使用函数名处理数据

select fxx1(name) as fxx_name from students limit 10;
#施笑槐$
#吕金鹏$
#单乐蕊$
#葛德曜$
#宣谷芹$
#边昂雄$
#尚孤风$
#符半双$
#沈德昌$
#羿彦昌$

udtf：一进多出

样例数据：
"key1:value1,key2:value2,key3:value3"
key1 value1
key2 value2
key3 value3

 方法一：使用 explode split

select split(t.col1,":")[0],split(t.col1,":")[1] 
from (select 
explode(split("key1:value1,key2:value2,key3:value3",",")) as 
col1) t;

自定udtf

//自定义代码
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;
public class hiveudtf extends genericudtf {
    // 指定输出的列名 及 类型
    @override
    public structobjectinspector initialize(structobjectinspector argois) throws udfargumentexception {
        arraylist filednames = new arraylist();
        arraylist filedobj = new arraylist();
        filednames.add("col1");
        filedobj.add(primitiveobjectinspectorfactory.javastringobjectinspector);
        filednames.add("col2");
        filedobj.add(primitiveobjectinspectorfactory.javastringobjectinspector);
        return objectinspectorfactory.getstandardstructobjectinspector(filednames, filedobj);
    }
    // 处理逻辑 my_udtf(col1,col2,col3)
    // "key1:value1,key2:value2,key3:value3"
    // my_udtf("key1:value1,key2:value2,key3:value3")
    public void process(object[] objects) throws hiveexception {
        // objects 表示传入的n列
        string col = objects[0].tostring();
        // key1:value1  key2:value2  key3:value3
        string[] splits = col.split(",");
        for (string str : splits) {
            string[] cols = str.split(":");
            // 将数据输出
            forward(cols);
        }
    }
    // 在udtf结束时调用
    public void close() throws hiveexception {
    }
}

sql:

select my_udtf("key1:value1,key2:value2,key3:value3");

举例说明：

字段：id,col1,col2,col3,col4,col5,col6,col7,col8,col9,col10,col11,col12
共13列
数据：
a,1,2,3,4,5,6,7,8,9,10,11,12
b,11,12,13,14,15,16,17,18,19,20,21,22
c,21,22,23,24,25,26,27,28,29,30,31,32
转成3列：id,hours,value
例如：
a,1,2,3,4,5,6,7,8,9,10,11,12
a,0时,1
a,2时,2
a,4时,3
a,6时,4

建表：
create table udtfdata(
    id string
    ,col1 string
    ,col2 string
    ,col3 string
    ,col4 string
    ,col5 string
    ,col6 string
    ,col7 string
    ,col8 string
    ,col9 string
    ,col10 string
    ,col11 string
    ,col12 string
)row format delimited fields terminated by ',';

 java代码：

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;
public class hiveudtf2 extends genericudtf {
    @override
    public structobjectinspector initialize(structobjectinspector argois) throws udfargumentexception {
        arraylist filednames = new arraylist();
        arraylist fieldobj = new arraylist();
        filednames.add("col1");
        fieldobj.add(primitiveobjectinspectorfactory.javastringobjectinspector);
        filednames.add("col2");
        fieldobj.add(primitiveobjectinspectorfactory.javastringobjectinspector);
        return objectinspectorfactory.getstandardstructobjectinspector(filednames, fieldobj);
    }
    public void process(object[] objects) throws hiveexception {
        int hours = 0;
        for (object obj : objects) {
            hours = hours   1;
            string col = obj.tostring();
            arraylist cols = new arraylist();
            cols.add(hours   "时");
            cols.add(col);
            forward(cols);
        }
    }
    public void close() throws hiveexception {
    }
}

添加jar资源:

add jar /usr/local/soft/hiveudf2-1.0.jar;

注册udtf函数：

create temporary function my_udtf as 'myudtf';

sql:

select id
       ,hours
       ,value from udtfdata lateral view   
my_udtf(col1,col2,col3,col4,col5,col6,col7,col8,col9,col10,col11,col12)
t as hours,value ;

 udaf：多进一出

hive 中的wordcount

建表：
create table words(
    words string
)row format delimited fields terminated by '|';
数据：
hello,java,hello,java,scala,python
hbase,hadoop,hadoop,hdfs,hive,hive
hbase,hadoop,hadoop,hdfs,hive,hive

select word,count(*) from (select explode(split(words,',')) word from words) a group by a.word;

hive 的shell使用 

第一种shell

hive -e "select * from test03.students limit 10"

第二种shell 

hive -f hql文件路径
# 将hql写在一个文件里，再使用 -f 参数指定该文件

源码编译

意义：

如果在使用新版本的时候如果有版本不兼容的问题的时候我们就可以自己编译出能够兼容的版本

hive在linux环境编译比较方便

• 先下载源码
• 配置linux的maven环境

修改maven的镜像

            alimaven
            central
            aliyun maven
            
            https://maven.aliyun.com/repository/central
        
        
                aliyunmaven
                *
                阿里云spring插件仓库
                https://maven.aliyun.com/repository/spring-plugin
        
        
                repo2
                mirror from maven repo2
                https://repo.spring.io/plugins-release/
                central
        

在不修改的情况先编译一遍

mvn clean package -pdist -dskiptests -dmaven.javadoc.skip=true

提升spark版本使得新版本的hive兼容spark3.0.0

参考github提交的代码进行修改

commits · gitlbo/hive · github 

参考下面比较全的文章，然后加上自己知道的，希望能帮助到大家