大数据开发面试题--hive篇(2020最新版)
文章目录
Hive基本概念
- 什么是Hive?
- Hive的优缺点?
- Hive和传统数据库有什么异同？
- Hive架构原理?
- Hive架构简介
- Hive用户接口
- Hive元数据
- Hive的HSQL转换为MapReduce的过程？
- Hive底层与数据库交互原理?
- Hive有哪些方式保存元数据，各有哪些特点？
- Hive如何进行权限控制?
Hive安装部署
- Hive安装部署简介
- Hive安装部署详情
- Hive数据仓库位置配置?
Hive数据类型
- 基本数据类型
- 复杂数据类型
- 类型转换
- 隐式类型转换
- 强制类型转换
Hive常用操作
- Hive最基本操作
- 数据库相关操作
- 创建数据库
- 查询数据库
- 修改数据库
- 删除数据库
- Hive表操作
- Hive建表语法
- Hive修改表语法
- Hive删除表语法
- 内部表和外部表的区别
- 内部表和外部表的转换
- 数据导入和导出
- 数据导入
- 数据导出
- 常规数据导出方式
- 使用sqoop导出数据
- Hive分区
- Hive静态分区
- Hive动态分区
- Hive动态分区和静态分区的区别
- Hive查询操作
- 基本查询操作
- 全表和特定列查询
- 列别名
- 算术运算符
- 聚合函数
- limit语句
- 表别名
- where语句
- 分组
- Join语句
- 笛卡尔积
- Sort By，Order By，Cluster By，Distrbute By的含义?
- 分桶查询
- 空字段赋值
- CASE WHEN
- 行转列
- 列转行
- 窗口函数（开窗函数)
- RANK函数
- 基本查询操作
- 自定义函数
- 自定义UDF函数
- 自定义UDTF函数
- 自定义UDAF函数
Hive压缩和存储
- 压缩
- Hive支持的压缩编码
- 压缩参数配置
- MR过程中进行压缩
- 存储
- TextFile格式
- SequenceFile格式
- RC格式
- ORC格式
- Parquet格式
Hive调优
- Fetch抓取
- 本地模式
- 表的优化
- 大表join小表
- 大表join大表
- 去重优化
- 笛卡尔积
- 行列过滤
- 分区,动态分区
- 分桶
- 合理设置MapReduce个数
- Map个数分析
- 复杂文件增加Map数
- 小文件合并
- 合理设置Reduce个数
- 并行执行
- 严格模式
- JVM重用
- 推测执行(慎用)
- 选择合理的压缩方式和存储格式
Hive实战
- 使用hive实现WordCount
- 使用hive求TOP N
- 使用Hive进行行列转换
- 使用Hive进留存率统计
- 工作中使用Hive遇到的问题
以上内容根据博主2020年找工作时搜寻的相关资料,以及实际面试中遇到的问题整理而成.
难免会有所纰漏,欢迎大家指出. 整理不易, 觉得内容好的记得点个收藏和关注哦~
Hive基本概念
什么是Hive?
hive是基于Hadoop的一个数据仓库工具，用来进行数据提取、转化、加载。可以存储、查询和分析存储在Hadoop中的大规模数据。
hive数据仓库工具能将结构化的数据文件映射为一张数据库表，并提供SQL查询功能，能将SQL语句转变成MapReduce任务来执行。
Hive的优点是学习成本低，可以通过HQL语句实现快速MapReduce统计，使MapReduce变得更加简单，而不必开发专门的MapReduce应用程序。
hive十分适合数据仓库的统计分析。
Hive的优缺点?
优点
- 简单容易上手：提供了类SQL查询语言HQL
- 可扩展：为超大数据集设计了计算/扩展能力（MR作为计算引擎，HDFS作为存储系统）一般情况下不需要重启服务Hive可以自由的扩展集群的规模。
- 提供统一的元数据管理
- 延展性：Hive支持用户自定义函数，用户可以根据自己的需求来实现自己的函数
- 容错：良好的容错性，节点出现问题SQL仍可完成执行
缺点（局限性）
- hive的HQL表达能力有限
- 迭代式算法无法表达，比如pagerank
- 数据挖掘方面，比如kmeans
- hive的效率比较低
- hive自动生成的mapreduce作业，通常情况下不够智能化
- hive调优比较困难，粒度较粗
- hive可控性差
Hive和传统数据库有什么异同？
Hive架构原理?
Hive架构简介
Hive通过给用户提供的一系列交互接口，接收到用户的指令(SQL)，使用自己的Driver，结合元数据(MetaStore)，将这些指令翻译成MapReduce，提交到Hadoop中执行。
最后，将执行返回的结果输出到用户交互接口。
Hive用户接口
包括 : CLI（command-line interface）、JDBC/ODBC(jdbc访问hive)、WEBUI（浏览器访问hive）、
BEELINE：hive客户端链接到hive的一个工具。可以理解成mysql的客户端。如：navite cat 等。
Hive元数据
元数据包括：表名、表所属的数据库（默认是default）、表的拥有者、列/分区字段、表的类型（是否是外部表）、表的数据所在目录等。
一般存储关系型数据库mysql中，在测试阶段也可以用hive内置Derby数据库。
Hive的HSQL转换为MapReduce的过程
过程描述如下：
SQL Parser(解析器) Antlr(是指可以根据输入自动生成语法树并可视化的显示出来的开源语法分析器)定义SQL的语法规则，完成SQL词法，语法解析，将SQL转化为抽象 语法树AST Tree；
Semantic Analyzer(语义分析器)： 遍历AST Tree，抽象出查询的基本组成单元QueryBlock；
Logical plan(逻辑计划)： 遍历QueryBlock，翻译为执行操作树OperatorTree；
Logical plan optimizer(优化器): 逻辑层优化器进行OperatorTree变换，合并不必要的ReduceSinkOperator，减少shuffle数据量；
Physical plan： 遍历OperatorTree，翻译为MapReduce任务；
Logical plan optimizer： 物理层优化器进行MapReduce任务的变换，生成最终的执行计划；
Hive底层与数据库交互原理?
由于Hive的元数据可能要面临不断地更新、修改和读取操作，所以它显然不适合使用Hadoop文件系统进行存储。
目前Hive将元数据存储在RDBMS中，比如存储在MySQL、Derby中。
Hive有哪些方式保存元数据，各有哪些特点？
元数据存储在关系型数据库中。如Derby、MySQL等。
Metastore的作用是：客户端连接metastore服务，metastore再去连接MySQL数据库来存取元数据。
有了metastore服务，就可以有多个客户端同时连接，而且这些客户端不需要知道MySQL数据库的用户名和密码，只需要连接metastore 服务即可。
Hive支持三种不同的元数据存储模式，分别为：内嵌模式、本地模式、远程模式，每种存储方式使用不同的配置参数。
内嵌模式主要用于单元测试，在该模式下每次只有一个进程可以连接到元数据存储，Derby是内嵌式元数据存储的默认数据库。
优点:小巧,无需额外配置metastore服务
缺点:每次只能有一个进程访问元数据,不支持多会话. 内存,不够稳定
本地模式：将元数据保存在本地独立的数据库中（一般是mysql），可以支持多会话连接.
在远程模式下，所有的Hive客户端都将打开一个到元数据服务器的连接，该服务器依次查询元数据，元数据服务器和客户端之间使用Thrift协议通信。避免每个客户端都去安装Mysql数据库
本地元存储和远程元存储的区别是：本地元存储不需要单独起metastore服务，用的是跟hive在同一个进程里的metastore服务。远程元存储需要单独起metastore服务，然后每个客户端都在配置文件里配置连接到该metastore服务。远程元存储的metastore服务和hive运行在不同的进程
Hive如何进行权限控制?
前hive支持简单的权限管理，默认情况下是不开启，这样所有的用户都具有相同的权限，同时也是超级管理员，也就对hive中的所有表都有查看和改动的权利，这样是不符合一般数据仓库的安全原则的。Hive可以是基于元数据的权限管理，也可以基于文件存储级别的权限管理。
为了使用Hive的授权机制，有两个参数必须在hive-site.xml中设置：
<property>
<name>hive.security.authorization.enabled</name>
<value>true</value>
<description>enable or disable the hive client authorization</description>
</property>
<property>
<name>hive.security.authorization.createtable.owner.grants</name>
<value>ALL</value>
<description>the privileges automatically granted to the owner whenever a table gets created. An example like "select,drop" will grant select and drop privilege to the owner of the table</description>
</property>
Hive支持以下权限：
| 权限名称 | 含义 |
|---|---|
| ALL | 所有权限 |
| ALTER | 允许修改元数据(modify metadata data of object) --表信息数据 |
| UPDATE | 允许修改物理数据(modify physical data of object) --实际数据 |
| CREATE | 允许进行CREATE操作 |
| DROP | 允许进行DROP操作 |
| INDEX | 允许建索引(目前还没有实现) |
| LOCK | 当出现并发的时候允许用户进行LOCK和UNLOCK操作 |
| SELECT | 允许用户进行SELECT操作 |
| SHOW_DATABASE | 允许用户查看可用的数据库 |
Hive授权的核心就是用户（user）、组（group）、角色（role）。
Hive的用户和组使用的是Linux机器上的用户和组，而角色必须自己创建。
角色管理：
--创建和删除角色
create role role_name;
drop role role_name;
--展示所有roles
show roles
--赋予角色权限
grant select on database db_name to role role_name;
grant select on [table] t_name to role role_name;
--查看角色权限
show grant role role_name on database db_name;
show grant role role_name on [table] t_name;
--角色赋予用户
grant role role_name to user user_name
--回收角色权限
revoke select on database db_name from role role_name;
revoke select on [table] t_name from role role_name;
--查看某个用户所有角色
show role grant user user_name;
Hive安装部署
Hive安装部署简介
- 准备工作
- 安装对应版本的Hadoop并启动
- 安装Mysql并启动
- 正式安装
- 下载解压hive
- 配置hive环境变量
- 在hadoop下创建hive所需文件夹
- 配置mysql
- 配置hive-env.sh,hive-site.xml,hive-log4j2.properties
- 初始化hive
- 启动hive
- 检测hive是否可用
Hive安装部署详情
具体安装过程可以参考本人博客:
hive2.3.6安装指南
Hive数据仓库位置配置?
1）Default数据仓库的最原始位置是在hdfs上的：/user/hive/warehouse路径下。
2）在仓库目录下，没有对默认的数据库default创建文件夹。如果某张表属于default数据库，直接在数据仓库目录下创建一个文件夹。
3）修改default数据仓库原始位置（将hive-default.xml.template如下配置信息拷贝到hive-site.xml文件中）。
<property>
<name>hive.metastore.warehouse.dir</name>
<value>/user/hive/warehouse</value>
<description>location of default database for the warehouse</description>
</property>
Hive数据类型
基本数据类型
| Hive基本数据类型 | Java数据类型 | 长度 | 例子 |
|---|---|---|---|
| TINYINT | byte | 1byte有符号整数 | 20 |
| SMALINT | short | 2byte有符号整数 | 20 |
| INT | int | 4byte有符号整数 | 20 |
| BIGINT | long | 8byte有符号整数 | 20 |
| BOOLEAN | boolean | 布尔类型，true或者false | TRUE FALSE |
| FLOAT | float | 单精度浮点数 | 3.14159 |
| DOUBLE | double | 双精度浮点数 | 3.14159 |
| STRING | string | 字符系列。可以指定字符集。可以使用单引号或者双引号。 | ‘now is the time’ “for all good men” |
| TIMESTAMP | 时间类型 | 2020-07-23 12:00:00 | |
| BINARY | 字节数组 |
复杂数据类型
| 数据类型 | 描述 | 语法示例 |
|---|---|---|
| STRUCT | 和c语言中的struct类似，都可以通过“点”符号访问元素内容。例如，如果某个列的数据类型是STRUCT{first STRING, last STRING},那么第1个元素可以通过字段.first来引用。 | struct() 例如struct |
| MAP | MAP是一组键-值对元组集合，使用数组表示法可以访问数据。例如，如果某个列的数据类型是MAP，其中键->值对是’first’->’John’和’last’->’Doe’，那么可以通过字段名[‘last’]获取最后一个元素 | map() 例如map |
| ARRAY | 数组是一组具有相同类型和名称的变量的集合。这些变量称为数组的元素，每个数组元素都有一个编号，编号从零开始。例如，数组值为[‘John’, ‘Doe’]，那么第2个元素可以通过数组名[1]进行引用。 | Array() 例如array |
类型转换
隐式类型转换
Hive的原子数据类型是可以进行隐式转换的,类似于Java的类型转换,规则如下:
1）任何整数类型都可以隐式地转换为一个范围更广的类型，如TINYINT可以转换成INT，INT可以转换成BIGINT。
2）所有整数类型、FLOAT和STRING类型都可以隐式地转换成DOUBLE。
3）TINYINT、SMALLINT、INT都可以转换为FLOAT。
4）BOOLEAN类型不可以转换为任何其它的类型。
强制类型转换
可以使用CAST操作显示进行数据类型转换
例如CAST(‘1’ AS INT)将把字符串’1’ 转换成整数1；
如果强制类型转换失败，如执行CAST(‘X’ AS INT)，表达式返回空值 NULL。
Hive常用操作
Hive最基本操作
（1）启动hive
bin/hive
（2）查看数据库
hive> show databases;
（3）打开默认数据库
hive> use default;
（4）显示default数据库中的表
hive> show tables;
（5）创建一张表
hive> create table student(id int, name string);
（6）显示数据库中有几张表
hive> show tables;
（7）查看表的结构
hive> desc student;
（8）向表中插入数据
hive> insert into student values(1000,"ss");
（9）查询表中数据
hive> select * from student;
（10）退出hive
hive> quit;
数据库相关操作
创建数据库
CREATE DATABASE [IF NOT EXISTS] database_name
[COMMENT database_comment]
[LOCATION hdfs_path]
[WITH DBPROPERTIES (property_name=property_value, ...)];
1）创建一个数据库，数据库在HDFS上的默认存储路径是/user/hive/warehouse/*.db。
hive (default)> create database db_hive;
2）避免要创建的数据库已经存在错误，增加if not exists判断。（标准写法）
hive (default)> create database db_hive;
FAILED: Execution Error, return code 1 from org.apache.hadoop.hive.ql.exec.DDLTask. Database db_hive already exists
hive (default)> create database if not exists db_hive;
3）创建一个数据库，指定数据库在HDFS上存放的位置
hive (default)> create database db_hive2 location '/db_hive2.db';
查询数据库
hive> show databases; --显示数据库
hive> show databases like 'db_hive*'; --过滤显示查询的数据库
hive> desc database db_hive; --显示数据库信息
hive> desc database extended db_hive; --使用extended命令显示数据库详细信息
hive (default)> use db_hive; --切换到指定数据库
修改数据库
用户可以使用ALTER DATABASE命令为某个数据库的DBPROPERTIES设置键-值对属性值，来描述这个数据库的属性信息。
数据库的其他元数据信息都是不可更改的，包括数据库名和数据库所在的目录位置。
hive (default)> alter database db_hive set dbproperties('createtime'='20200723');
删除数据库
drop database db_hive2; --删除数据库
drop database if exists db_hive2; --删除数据库前判断数据库是否存在,防止数据库不存在报错
drop database db_hive cascade; --使用cascade命令强制删除非空数据库
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]
[STORED AS file_format]
[LOCATION hdfs_path]
[TBLPROPERTIES (property_name=property_value, ...)]
[AS select_statement]
参数说明:
-- EXTERNAL指定创建外部表
-- COMMENT：为表和列添加注释
-- PARTITIONED BY创建分区表
-- CLUSTERED BY创建分桶表
-- SORTED BY不常用，对桶中的一个或多个列另外排序
-- ROW FORMAT DELIMITED [FIELDS TERMINATED BY char] 按指定的分隔符对字段进行分割
-- STORED AS指定存储文件类型
-- LOCATION ：指定表在HDFS上的存储位置。
-- AS：后跟查询语句，根据查询结果创建表
-- LIKE允许用户复制现有的表结构，但是不复制数据。
Hive修改表语法
ALTER TABLE table_name RENAME TO new_table_name --重命名表
ALTER TABLE table_name CHANGE [COLUMN] col_old_name col_new_name column_type [COMMENT col_comment] [FIRST|AFTER column_name] -- 更新列
ALTER TABLE table_name ADD|REPLACE COLUMNS (col_name data_type [COMMENT col_comment], ...) --增加和替换列
-- ADD是代表新增一字段，字段位置在所有列后面(partition列前)，REPLACE则是表示替换表中所有字段。
Hive删除表语法
drop table dept_partition;
内部表和外部表的区别
创建表
内部表:会将数据移动到数据仓库指向的路径。
外部表: 需在建表时使用EXTERNAL 关键字。
创建表时,仅记录数据所在的路径， 不对数据的位置做任何改变。
删除表
内部表: 元数据和数据会被一起删除。
外部表: 只删除元数据，不删除数据。这样外部表相对来说更加安全些，数据组织也更加灵活，方便共享源数据。
使用场景
内部表 : 不需要共享的计算结果或中间数据
外部表 : 适用于多部门共享数据
内部表和外部表的转换
alter table student2 set tblproperties('EXTERNAL'='TRUE'); -- 修改内部表student2为外部表
alter table student2 set tblproperties('EXTERNAL'='FALSE'); -- 修改外部表student2为内部表
-- 注意:('EXTERNAL'='TRUE')和('EXTERNAL'='FALSE')为固定写法，区分大小写！
数据导入和导出
数据导入
向表中装载数据(Load):
语法:
load data [local] inpath '/opt/module/datas/xxx.txt' [overwrite] into table 表名[partition (partcol1=val1,…)];
-- load data:表示加载数据
-- local : 从本地加载数据到hive表,否则从hdfs加载数据到hive表
-- inpath: 表示加载数据的路径
-- overwrite:表示覆盖已有数据,否则追加
-- into table:加载到哪张表
-- 表名 : 表示具体的表名
-- partition:上传到指定分区
通过查询语句向表中插入数据
insert into table student partition(month='202007') values(1,'xmr'),(2,’rxct’); -- insert into: 以追加数据的方式插入到表或分区,原有数据不会删除 insert不支持插入部分字段
insert overwrite table student partition(month='202006')
select id, name from student where month='202005'; -- insert overwrite:会覆盖表或分区中已存在的数据
使用import,将数据导入到指定Hive表中
import table student2 partition(month='202006') from
'/user/hive/warehouse/export/student';
数据导出
常规数据导出方式
insert overwrite (local) directory '/opt/module/datas/export/student' select * from student; -- 使用insert命令将查询结果导出(本地 有local)或HDFS(没有Local)
dfs -get /user/hive/warehouse/student/month=202007/000000_0
/opt/module/datas/export/student3.txt; --使用hdfs命令将数据导出到本地
bin/hive -e 'select * from default.student;' > /opt/module/datas/export/student4.txt; --使用hive -f/-e 执行语句或者脚本
export table default.student to
'/user/hive/warehouse/export/student'; -- 使用export命令导出到HDFS上
使用sqoop导出数据
# 首先设置关系数据库相关配置
database_connection="jdbc:postgresql://192.168.0.2:8080/db_name" #数据库连接uri
database_username="user" #用户名
database_password="pass" #密码
databaseTableName="test2" #表名
databaseColums="a1,a2,a3" #需要的列
#将数据写到一个临时表中
hive -v -e "
set mapred.job.queue.name=${queueName};
USE hive_db_name;
INSERT OVERWRITE TABLE test3
select a1,a2,a3 from test1 where y='2020' and m='07' and d='25';
";
if [[ $? != 0 ]]; then
print_log "hive执行失败!"
exit 1
fi
# 设置hdfs路径
exportHdfsPath="hdfs:///user/hive/warehouse/sqoop/test3"
sqoop export -Dmapred.job.queue.name=$queueName \ //mr的队列
--connect $database_connection \ //关系型数据库的连接
--username $database_username \ //关系型数据库的用户名
--password $database_password \ //关系型数据的密码
--export-dir $exportHdfsPath \ //hive表的hdfs路径
--verbose \
--table $databaseTableName \ //要写到的表名
--columns $databaseColums \ //要写过去的字段名
--input-fields-terminated-by '\001' \ //hive表的分割符，注意表一定是行式存储的表才能导出，一般是text后缀的表
--input-lines-terminated-by '\n' \ //每行的分割符
--input-null-string '\\N' \ //空值处理
--input-null-non-string '\\N' //空值处理
if [[ $? != 0 ]]; then
print_log "sqoop导出失败!"
exit 1
fi
Hive分区
分区表实际上就是对应一个HDFS文件系统上的独立的文件夹，该文件夹下是该分区所有的数据文件。
Hive中的分区就是分目录，把一个大的数据集根据业务需要分割成小的数据集。
在查询时通过WHERE子句中的表达式选择查询所需要的指定的分区，通过减少查询的数据量来提高查询效率。
Hive静态分区和动态分区公用操作如下:
# 创建分区表
create table dept_partition(
deptno int, dname string, loc string
)
partitioned by (month string)
row format delimited fields terminated by '\t';
-- 注意:根据创建的表中某个字段进行分区操作时,创建表时不可添加这个字段,例如:以month分区,建表的字段不能包含month
# 操作分区表
select * from dept_partition where month='202007'; -- 查询分区表中数据
alter table dept_partition add partition(month='202006') ; -- 增加单个分区
alter table dept_partition add partition(month='202005') partition(month='202004'); -- 增加多个分区
alter table dept_partition drop partition (month='202007'); -- 删除单个分区
alter table dept_partition drop partition (month='202005'), partition (month='202006'); -- 删除多个分区
show partitions dept_partition; -- 查看分区表有多少分区
desc formatted dept_partition; -- 查看分区表结构
Hive静态分区
# 静态分区使用load方式导入数据
load data local inpath '/opt/module/datas/dept.txt' into table default.dept_partition partition(month='202007'); --加载数据到分区表
# 静态分区使用insert方式导入数据
insert into default.dept_partition partition(month='202007') select deptno, dname , loc from partition_test where month = '202007';
-- 注意查询的字段要与创建分区表时的字段一致
-- 产生一级子目录，需手动创建每一个分区，当分区较多时，操作比较麻烦
# 产生二级子目录
insert into empar partition (year=2015,month=11) select name,id,number from employee_hr where year(start_date)=2015 and month(start_date)=11;
load data local inpath '/opt/datas/dept.txt' into table dept_partition2 partition(year='2019', month='12');
Hive动态分区
关系型数据库中，对分区表Insert数据时候，数据库自动会根据分区字段的值，将数据插入到相应的分区中，Hive中也提供了类似的机制，即动态分区(Dynamic Partition)，只不过，使用Hive的动态分区，需要进行相应的配置。
# 开启动态分区功能（默认true，开启）
hive.exec.dynamic.partition=true
# 设置为非严格模式（动态分区的模式，默认strict，表示必须指定至少一个分区为静态分区，nonstrict模式表示允许所有的分区字段都可以使用动态分区。）
hive.exec.dynamic.partition.mode=nonstrict
# 在所有执行MR的节点上，最大一共可以创建多少个动态分区。默认1000
hive.exec.max.dynamic.partitions=1000
# 在每个执行MR的节点上，最大可以创建多少个动态分区。该参数需要根据实际的数据来设定。比如：源数据中包含了一年的数据，即day字段有365个值，那么该参数就需要设置成大于365，如果使用默认值100，则会报错。
hive.exec.max.dynamic.partitions.pernode=100
# 整个MR Job中，最大可以创建多少个HDFS文件。默认100000
hive.exec.max.created.files=100000
# 当有空分区生成时，是否抛出异常。一般不需要设置。默认false
hive.error.on.empty.partition=false
# 不需要手动一个一个分区，可以根据关键字自动分区。
# 此时select中的字段要和创建表时的字段加上partition的关键字的一致。根据一个字段分区
insert into dept_partition partition(month) select * from partition_test;
# 根据两个字段分区
insert into empar partition(year,month) select name,id,number,year(start_date),month(start_date) from employee_hr;
Hive动态分区和静态分区的区别
- Hive是默认开启动态分区的,但是想要更好的利用动态分区特性,需要进行必要的设置
- 静态分区是手动指定，而动态分区是通过数据来进行判断。详细来说，静态分区的列是在编译时期，通过用户传递来决定的；动态分区只有在SQL执行时才能决定。
- 静态分区支持load和insert两种插入方式,动态分区只支持insert方式
Hive查询操作
# 查询操作语法
SELECT [ALL | DISTINCT] select_expr, select_expr, ...
FROM table_reference
[WHERE where_condition]
[GROUP BY col_list]
[ORDER BY col_list]
[CLUSTER BY col_list
| [DISTRIBUTE BY col_list] [SORT BY col_list]
]
[LIMIT number]
基本查询操作
全表和特定列查询
select * from tablename; --全表查询
select col1,col2 from tablename; --选择特定列查询
# 注意事项
# SQL 语言大小写不敏感。
# SQL 可以写在一行或者多行
# 关键字不能被缩写也不能分行
# 各子句一般要分行写。
# 使用缩进提高语句的可读性。
列别名
列别名: 通过对列重命名来提高SQL语句的可读性
select ename AS name, deptno dn from emp; -- 查询名称和部门
算术运算符
# + - * / 加减乘除四则运算
# &(取余) &(按位与) |(按位取或) ^(按位异或) ~(按位取反)
# 示例:
select sal +10000 from emp; --将所有员工的薪水加10000显示
聚合函数
聚合函数是hive内置函数，聚合函数对一组值执行计算，并返回单个值。
select count(*) cnt from emp; -- 求总行数(count)
select max(sal) max_sal from emp; --最大值（max）
select min(sal) min_sal from emp; --最小值（min）
select sum(sal) sum_sal from emp; --求和（sum）
select avg(sal) avg_sal from emp; --求平均值
limit语句
LIMIT子句用于限制返回的行数。
select * from emp limit 5; --只返回5条结果
表别名
好处
（1）使用别名可以简化查询。
（2）使用表名前缀可以提高执行效率。
select e.empno, e.ename, d.deptno from emp e join dept d on e.deptno = d.deptno; --合并员工表和部门表
where语句
1）使用WHERE 子句，将不满足条件的行过滤掉。
2）WHERE 子句紧随 FROM 子句。
使用比较运算符
# 比较运算符
<, <=, =, >=, >, !=(<>) --常规比较运算符
is null, in not null --空或非空
A [NOT] BETWEEN B AND C -- 如果A，B或者C任一为NULL，则结果为NULL。如果A的值大于等于B而且小于或等于C，则结果为TRUE，反之为FALSE。如果使用NOT关键字则可达到相反的效果。
in(值1,值2) --使用 IN运算显示列表中的值
A [NOT] LIKE B --A与正则表达式B匹配，则返回TRUE；反之返回FALSE。
A RLIKE B, A REGEXP B --B是基于java的正则表达式，如果A与其匹配，则返回TRUE；反之返回FALSE。
#实操:
select * from emp where sal =5000; --查询薪水为5000的员工
select * from emp where sal between 500 and 1000; --查询工资在500到1000的员工信息
select * from emp where comm is null; --查询comm为空的所有员工信息
select * from emp where sal IN (1500, 5000); --查询工资是1500或5000的员工信息
Like和RLike
1）使用LIKE运算选择类似的值
2）选择条件可以包含字符或数字:
% 代表零个或多个字符(任意个字符)。
_ 代表一个字符。
3）RLIKE子句是Hive中这个功能的一个扩展，其可以通过Java的正则表达式这个更强大的语言来指定匹配条件。
#实操:
select * from emp where sal LIKE '2%'; --查找以2开头薪水的员工信息
select * from emp where sal LIKE '_2%'; --查找第二个数值为2的薪水的员工信息
select * from emp where sal RLIKE '[2]'; --查找薪水中含有2的员工信息
逻辑运算符（And/Or/Not）
| 操作符 | 含义 |
|---|---|
| AND | 逻辑与 |
| OR | 逻辑或 |
| NOT | 逻辑非 |
hive (default)> select * from emp where sal>1000 and deptno=30; --查询薪水大于1000，部门是30
hive (default)> select * from emp where sal>1000 or deptno=30; --查询薪水大于1000，或者部门是30
hive (default)> select * from emp where deptno not IN(30, 20); --查询除了20部门和30部门以外的员工信息
分组
Group By语句
GROUP BY语句通常会和聚合函数一起使用，按照一个或者多个列队结果进行分组，然后对每个组执行聚合操作。
select t.deptno, avg(t.sal) avg_sal from emp t group by t.deptno; --计算emp表每个部门的平均工资
Having语句
having与where不同点
（1）where后面不能写分组函数，而having后面可以使用分组函数。
（2）having只用于group by分组统计语句。
select deptno, avg(sal) avg_sal from emp group by deptno having
avg_sal > 2000; --求平均薪水大于2000的部门
Join语句
等值Join: Hive支持通常的SQL JOIN语句，但是只支持等值连接，不支持非等值连接。
内连接： 只有进行连接的两个表中都存在与连接条件相匹配的数据才会被保留下来。
select e.empno, e.ename, d.deptno, d.dname from emp e join dept d on e.deptno = d.deptno; --根据员工表和部门表中的部门编号相等，查询员工编号、员工名称和部门名称；
左外连接： JOIN操作符左边表中符合WHERE子句的所有记录将会被返回。
select e.empno, e.ename, d.deptno from emp e left join dept d on e.deptno = d.deptno;
右外连接： JOIN操作符右边表中符合WHERE子句的所有记录将会被返回。
select e.empno, e.ename, d.deptno from emp e right join dept d on e.deptno = d.deptno;
满外连接： 将会返回所有表中符合WHERE语句条件的所有记录。如果任一表的指定字段没有符合条件的值的话，那么就使用NULL值替代。
select e.empno, e.ename, d.deptno from emp e full join dept d on e.deptno
= d.deptno;
多表连接:
注意：连接 n个表，至少需要n-1个连接条件。例如：连接三个表，至少需要两个连接条件。
SELECT e.ename, d.dname, l.loc_name
FROM emp e
JOIN dept d
ON d.deptno = e.deptno
JOIN location l
ON d.loc = l.loc;
多数情况下，Hive会对每对JOIN连接对象启动一个MapReduce任务。
本例中会首先启动一个MapReduce job对表e和表d进行连接操作，然后会再启动一个MapReduce job将第一个MapReduce job的输出和表l;进行连接操作。
注意：为什么不是表d和表l先进行连接操作呢？这是因为Hive总是按照从左到右的顺序执行的。
优化：当对3个或者更多表进行join连接时，如果每个on子句都使用相同的连接键的话，那么只会产生一个MapReduce job。
笛卡尔积
笛卡尔集会在下面条件下产生
（1）省略连接条件
（2）连接条件无效
（3）所有表中的所有行互相连接
缺点: 非常消耗资源,除非极其特殊情况,否则不要在生产中使用
# 实例
select empno, dname from emp, dept;
Sort By，Order By，Cluster By，Distrbute By的含义?
order by：会对输入做全局排序，因此只有一个reducer（多个reducer无法保证全局有序）。只有一个reducer，会导致当输入规模较大时，需要较长的计算时间。
sort by：不是全局排序，其在数据进入reducer前完成排序。
distribute by：按照指定的字段对数据进行划分输出到不同的reduce中。distribute by的分区规则是根据分区字段的hash码与reduce的个数进行模除后，余数相同的分到一个区。Hive要求DISTRIBUTE BY语句要写在SORT BY语句之前.
cluster by：除了具有 distribute by 的功能外还兼具 sort by 的功能。如sort by和 distribute by 的字段相同,那么cluster by与二者等价,但是cluster by不支持降序操作, 即不能使用DESC操作
分桶查询
分区提供一个隔离数据和优化查询的便利方式。不过，并非所有的数据集都可形成合理的分区。
对于一张表或者分区，Hive 可以进一步组织成桶，也就是更为细粒度的数据范围划分。
分桶是将数据集分解成更容易管理的若干部分的另一个技术。
分区针对的是数据的存储路径；分桶针对的是数据文件。
创建分桶表
首先要设置属性:
set hive.enforce.bucketing=true; # 建表前需要设置强制分桶,分桶才会生效
create table stu_buck(id int, name string)
clustered by(id)
into 4 buckets
row format delimited fields terminated by '\t'; --创建分桶表
分桶规则：
Hive的分桶采用对分桶字段的值进行哈希，然后除以桶的个数求余的方式决定该条记录存放在哪个桶当中
分桶抽样查询
对于非常大的数据集，有时用户需要使用的是一个具有代表性的查询结果而不是全部结果。
Hive可以通过对表进行抽样来满足这个需求。
#查询表stu_buck中的数据。
select * from stu_buck tablesample(bucket 1 out of 4 on id);
--注：tablesample是抽样语句，语法：TABLESAMPLE(BUCKET x OUT OF y) 。y必须是table总bucket数的倍数或者因子。hive根据y的大小，决定抽样的比例。
-- 例如，table总共分了4份，当y=2时，抽取(4/2=)2个bucket的数据，当y=8时，抽取(4/8=)1/2个bucket的数据。
--x表示从哪个bucket开始抽取，如果需要取多个分区，以后的分区号为当前分区号加上y。
-- 例如，table总bucket数为4，tablesample(bucket 1 out of 2)，表示总共抽取（4/2=）2个bucket的数据，抽取第1(x)个和第3(x+y)个bucket的数据。
-- 注意：x的值必须小于等于y的值
空字段赋值
NVL：给值为NULL的数据赋值，它的格式是NVL( value，default_value)。
它的功能是如果value为NULL，则NVL函数返回default_value的值，否则返回value的值，如果两个参数都为NULL ，则返回NULL。
select comm,nvl(comm, -1) from emp; --如果员工的comm为NULL，则用-1代替
CASE WHEN
简单Case函数 :
# 格式
case 列名
when 条件值1 then 选择项1
when 条件值2 then 选项2.......
else 默认值 end
# 实例
select
case job_level
when '1' then '水平1'
when '2' then '水平2'
when '3' then '水平3'
else '其他' end
from dbo.employe
Case搜索函数:
#格式说明
case
when 列名= 条件值1 then 选择项1
when 列名=条件值2 then 选项2.......
else 默认值 end
# 实例
update employee
set e_wage =
case
when job_level = '1' then e_wage*1.97
when job_level = '2' then e_wage*1.07
when job_level = '3' then e_wage*1.06
else e_wage*1.05 end
行转列
相关函数说明:
| 函数名称 | 函数作用 |
|---|---|
| CONCAT(string A/col, string B/col…) | 返回输入字符串连接后的结果，支持任意个输入字符串 |
| CONCAT_WS(separator, str1, str2,…) | 它是一个特殊形式的 CONCAT()。第一个参数剩余参数间的分隔符。分隔符可以是与剩余参数一样的字符串。如果分隔符是 NULL，返回值也将为 NULL。这个函数会跳过分隔符参数后的任何 NULL 和空字符串。分隔符将被加到被连接的字符串之间 |
| COLLECT_SET(col) | 函数只接受基本数据类型，它的主要作用是将某字段的值进行去重汇总，产生array类型字段。 |
| COLLECT_LIST(col) | 函数只接受基本数据类型，它的主要作用是将某字段的值进行汇总(不去重)，产生array类型字段。 |
实操:
数据准备:
| name | constellation | blood_type |
|---|---|---|
| 孙悟空 | 白羊座 | A |
| 大海 | 射手座 | A |
| 宋宋 | 白羊座 | B |
| 猪八戒 | 白羊座 | A |
| 凤姐 | 射手座 | A |
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; --将星座和血型一样的人归类到一起
结果如下:
射手座,A 大海|凤姐
白羊座,A 孙悟空|猪八戒
白羊座,B 宋宋
列转行
函数说明:
**EXPLODE(col)：**将hive一列中复杂的array或者map结构拆分成多行。
LATERAL VIEW
用法：LATERAL VIEW udtf(expression) tableAlias AS columnAlias
解释：用于和split, explode等UDTF一起使用，它能够将一列数据拆成多行数据，在此基础上可以对拆分后的数据进行聚合。
实操
数据准备:
| movie | category |
|---|---|
| 《疑犯追踪》 | 悬疑,动作,科幻,剧情 |
| 《Lie to me》 | 悬疑,警匪,动作,心理,剧情 |
| 《战狼2》 | 战争,动作,灾难 |
select
movie,
category_name
from
movie_info lateral view explode(category) table_tmp as category_name; --将电影分类中的数组数据展开
结果如下:
《疑犯追踪》 悬疑
《疑犯追踪》 动作
《疑犯追踪》 科幻
《疑犯追踪》 剧情
《Lie to me》 悬疑
《Lie to me》 警匪
《Lie to me》 动作
《Lie to me》 心理
《Lie to me》 剧情
《战狼2》 战争
《战狼2》 动作
《战狼2》 灾难
窗口函数（开窗函数)
相关函数说明
| 函数名称 | 函数说明 |
|---|---|
| OVER() | 指定分析函数工作的数据窗口大小，这个数据窗口大小可能会随着行的变而变化。 |
| CURRENT ROW | 当前行 |
| n PRECEDING | 往前n行数据 |
| n FOLLOWING | 往后n行数据 |
| UNBOUNDED | 起点，UNBOUNDED PRECEDING 表示从前面的起点， UNBOUNDED FOLLOWING表示到后面的终点 |
| LAG(col,n,default_val) | 往前第n行数据 |
| LEAD(col,n, default_val) | 往后第n行数据 |
| NTILE(n) | 把有序分区中的行分发到指定数据的组中，各个组有编号，编号从1开始，对于每一行，NTILE返回此行所属的组的编号。注意：n必须为int类型。 |
实际操作
数据准备:
| name | orderdate | cost |
|---|---|---|
| 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 |
select name,count(*) over ()
from business
where substring(orderdate,1,7) = '2017-04'
group by name; --查询在2017年4月份购买过的顾客及总人数
select name,orderdate,cost,sum(cost) over(partition by month(orderdate)) from
business; --查询顾客的购买明细及月购买总额
# 上述的场景, 将每个顾客的cost按照日期进行累加
select name,orderdate,cost,
sum(cost) over() as sample1,--所有行相加
sum(cost) over(partition by name) as sample2,--按name分组，组内数据相加
sum(cost) over(partition by name order by orderdate) as sample3,--按name分组，组内数据累加
sum(cost) over(partition by name order by orderdate rows between UNBOUNDED PRECEDING and current row ) as sample4 ,--和sample3一样,由起点到当前行的聚合
sum(cost) over(partition by name order by orderdate rows between 1 PRECEDING and current row) as sample5, --当前行和前面一行做聚合
sum(cost) over(partition by name order by orderdate rows between 1 PRECEDING AND 1 FOLLOWING ) as sample6,--当前行和前边一行及后面一行
sum(cost) over(partition by name order by orderdate rows between current row and UNBOUNDED FOLLOWING ) as sample7 --当前行及后面所有行
from business;
-- rows必须跟在Order by 子句之后，对排序的结果进行限制，使用固定的行数来限制分区中的数据行数量
select name,orderdate,cost,
lag(orderdate,1,'1900-01-01') over(partition by name order by orderdate ) as time1, lag(orderdate,2) over (partition by name order by orderdate) as time2
from business; --查看顾客上次的购买时间
select * from (
select name,orderdate,cost, ntile(5) over(order by orderdate) sorted
from business
) t
where sorted = 1; --查询前20%时间的订单信息
RANK函数
函数说明
| 函数名称 | 函数作用 |
|---|---|
| RANK() | 排序相同时会重复，总数不会变 |
| DENSE_RANK() | 排序相同时会重复，总数会减少 |
| ROW_NUMBER() | 会根据顺序计算 |
自定义函数
Hive 自带了一些函数，比如：max/min等，但是数量有限，用户可以通过自定义UDF来方便的扩展。
适用场景: 当Hive提供的内置函数无法满足业务处理需要时，此时就可以考虑使用用户自定义函数（UDF：user-defined function）。
分类:
用户自定义函数类别分为以下三种：
| 种类 | 特征 |
|---|---|
| UDF（User-Defined-Function) | 一进一出 |
| UDAF（User-Defined Aggregation Function） | 聚集函数，多进一出 类似于：count/max/min |
| UDTF（User-Defined Table-Generating Functions） | 一进多出 |
自定义UDF函数
编程步骤：
（1）继承org.apache.hadoop.hive.ql.exec.UDF
（2）需要实现evaluate函数；evaluate函数支持重载；
（3）在hive的命令行窗口创建函数
a）添加jar add jar linux_jar_path
b）创建function create [temporary] function [dbname.]function_name AS class_name;
（4）在hive的命令行窗口删除函数 Drop [temporary] function [if exists] [dbname.]function_name;
创建一个Maven工程Hive
导入依赖
<dependencies>
<dependency>
<groupId>org.apache.hivegroupId>
<artifactId>hive-execartifactId>
<version>1.2.1version>
dependency>
dependencies>
创建一个类继承UDF,重写evaluate方法
package com.atguigu.hive;
import org.apache.hadoop.hive.ql.exec.UDF;
public class Lower extends UDF {
public String evaluate (final String s) {
if (s == null) {
return null;
}
return s.toLowerCase();
}
}
打成jar包上传到服务器
/opt/module/jars/udf.jar
将jar包添加到hive的classpath
hive (default)> add jar /opt/module/datas/udf.jar;
创建临时函数与开发好的java class关联
hive (default)> create temporary function mylower as "com.atguigu.hive.Lower";
在hql中使用自定义的函数
hive (default)> select ename, mylower(ename) lowername from emp;
自定义UDTF函数
编程步骤：
1)继承org.apache.hadoop.hive.ql.udf.generic.GenericUDTF,实现initialize, process, close三个方法。
2)UDTF首先会调用initialize方法，此方法返回UDTF的返回行的信息加粗样式（返回个数，类型）。
3)初始化完成后，会调用process方法,真正的处理过程在process函数中，在process中，每一次forward()调用产生一行；如果产生多列可以将多个列的值放在一个数组中，然后将该数组传入到forward()函数。
4)最后close()方法调用，对需要清理的方法进行清理。
操作实例:
切分”key:value;key:value;”这种字符串，返回结果为key, value两个字段
import java.util.ArrayList;
import org.apache.hadoop.hive.ql.udf.generic.GenericUDTF;
import org.apache.hadoop.hive.ql.exec.UDFArgumentException;
import org.apache.hadoop.hive.ql.exec.UDFArgumentLengthException;
import org.apache.hadoop.hive.ql.metadata.HiveException;
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;
public class ExplodeMap extends GenericUDTF{
@Override
public void close() throws HiveException {
}
@Override
public StructObjectInspector initialize(ObjectInspector[] args)
throws UDFArgumentException {
if (args.length != 1) {
throw new UDFArgumentLengthException("ExplodeMap takes only one argument");
}
if (args[0].getCategory() != ObjectInspector.Category.PRIMITIVE) {
throw new UDFArgumentException("ExplodeMap takes string as a parameter");
}
ArrayList<String> fieldNames = new ArrayList<String>();
ArrayList<ObjectInspector> fieldOIs = new ArrayList<ObjectInspector>();
fieldNames.add("col1");
fieldOIs.add(PrimitiveObjectInspectorFactory.javaStringObjectInspector);
fieldNames.add("col2");
fieldOIs.add(PrimitiveObjectInspectorFactory.javaStringObjectInspector);
return ObjectInspectorFactory.getStandardStructObjectInspector(fieldNames,fieldOIs);
}
@Override
public void process(Object[] args) throws HiveException {
String input = args[0].toString();
String[] test = input.split(";");
for(int i=0; i<test.length; i++) {
try {
String[] result = test[i].split(":");
forward(result);
} catch (Exception e) {
continue;
}
}
}
}
使用方式
UDTF有两种使用方法，一种直接放到select后面，一种和lateral view一起使用。
- 直接select中使用
select explode_map(properties) as (col1,col2) from src;
- 和lateral view一起使用
select src.id, mytable.col1, mytable.col2 from src lateral view explode_map(properties) mytable as col1, col2;
自定义UDAF函数
实现步骤
-
引入如下两下类
import org.apache.hadoop.hive.ql.exec.UDAF
import org.apache.hadoop.hive.ql.exec.UDAFEvaluator -
函数类需要继承UDAF类，计算类Evaluator实现UDAFEvaluator接口
Evaluator需要实现UDAFEvaluator的init、iterate、terminatePartial、merge、terminate这几个函数。a）init函数实现接口UDAFEvaluator的init函数。
b）iterate接收传入的参数，并进行内部的迭代。其返回类型为boolean。
c）terminatePartial无参数，其为iterate函数遍历结束后，返回遍历得到的数据，terminatePartial类似于 hadoop的Combiner。
d）merge接收terminatePartial的返回结果，进行数据merge操作，其返回类型为boolean。
e）terminate返回最终的聚集函数结果。
应用实例:
计算平均数:
package hive.udaf;
import org.apache.hadoop.hive.ql.exec.UDAF;
import org.apache.hadoop.hive.ql.exec.UDAFEvaluator;
public class Avg extends UDAF {
public static class AvgState {
private long mCount;
private double mSum;
}
public static class AvgEvaluator implements UDAFEvaluator {
AvgState state;
public AvgEvaluator() {
super();
state = new AvgState();
init();
}
/**
* init函数类似于构造函数，用于UDAF的初始化
*/
public void init() {
state.mSum = 0;
state.mCount = 0;
}
/**
* iterate接收传入的参数，并进行内部的轮转。其返回类型为boolean * * @param o * @return
*/
public boolean iterate(Double o) {
if (o != null) {
state.mSum += o;
state.mCount++;
}
return true;
}
/**
* terminatePartial无参数，其为iterate函数遍历结束后，返回轮转数据， * terminatePartial类似于hadoop的Combiner * * @return
*/
public AvgState terminatePartial() {
// combiner
return state.mCount == 0 ? null : state;
}
/**
* merge接收terminatePartial的返回结果，进行数据merge操作，其返回类型为boolean * * @param o * @return
*/
public boolean merge(AvgState avgState) {
if (avgState != null) {
state.mCount += avgState.mCount;
state.mSum += avgState.mSum;
}
return true;
}
/**
* terminate返回最终的聚集函数结果 * * @return
*/
public Double terminate() {
return state.mCount == 0 ? null : Double.valueOf(state.mSum / state.mCount);
}
}
}
使用UDAF
- 将java文件编译成udaf_avg.jar
- 进入hive客户端添加jar包
hive>add jar /home/hadoop/udaf_avg.jar
3)创建临时函数
hive>create temporary function udaf_avg 'hive.udaf.Avg'
4)查询语句
hive>select udaf_avg(people.age) from people
5)销毁临时函数
hive>drop temporary function udaf_avg
Hive压缩和存储
压缩
Hive支持的压缩编码
| 压缩格式 | 工具 | 算法 | 文件扩展名 | 是否可切分 | 对应的编码/解码器 |
|---|---|---|---|---|---|
| DEFLATE | 无 | DEFLATE | .deflate | 否 | org.apache.hadoop.io.compress.DefaultCodec |
| Gzip | gzip | DEFLATE | .gz | 否 | org.apache.hadoop.io.compress.GzipCodec |
| bzip2 | bzip2 | bzip2 | .bz2 | 是 | org.apache.hadoop.io.compress.BZip2Codec |
| LZO | lzop | LZO | .lzo | 是 | com.hadoop.compression.lzo.LzopCodec |
| Snappy | 无 | Snappy | .snappy | 否 | org.apache.hadoop.io.compress.SnappyCodec |
压缩性能的对比
下面是一份源数据1.4G的文件，各类压缩格式的比率和时间对比
数据压缩后大小：
从上面对比可以看出：
在压缩数据比上：
Snappy、LZ4、LZO可以压缩到50%左右
GZIP、BZIP2可以压缩到30%左右
在压缩和解压时间上：
Snappy、LZ4、LZO 的压缩时间非常接近，范围6-8秒内；Snappy的解压时间是最高的，是压缩时间的3倍，其次是LZO，LZ4解压时间最低
GZIP、BZIP2 的压缩和解压时间都非常高。
总结一句话就是：压缩比率高的，压缩和解压时间花费就比较长。
那么该如何选择合适的压缩方式?
Snappy： 压缩速度快；支持hadoop native库
缺点：不支持split；压缩比低；hadoop本身不支持，需要安装；linux系统下没有对应的命令.
LZO： 压缩/解压速度也比较快，合理的压缩率；支持split，是hadoop中最流行的压缩格式；
支持hadoop native库；需要在linux系统下自行安装lzop命令，使用方便
缺点： 压缩率比gzip要低；
lzo虽然支持split，但需要对lzo文件建索引，否则hadoop也是会把lzo文件看成一个普通文件
GZIP： 压缩比较高；hadoop本身支持，在应用中处理gzip格式的文件就和直接处理文本一样；
有hadoop native库；大部分linux系统都自带gzip命令，使用方便
缺点： 不支持split
BZIP2 ： 支持split；具有很高的压缩率，比gzip压缩率都高；
hadoop本身支持，但不支持native；在linux系统下自带bzip2命令，使用方便
缺点：压缩/解压速度慢；不支持native
压缩参数配置
要在Hadoop中启用压缩，可以配置如下参数（mapred-site.xml文件中）：
| 参数 | 默认值 | 阶段 | 建议 |
|---|---|---|---|
| io.compression.codecs （在core-site.xml中配置） | org.apache.hadoop.io.compress.DefaultCodec, org.apache.hadoop.io.compress.GzipCodec, org.apache.hadoop.io.compress.BZip2Codec,org.apache.hadoop.io.compress.Lz4Codec | 输入压缩 | Hadoop使用文件扩展名判断是否支持某种编解码器 |
| mapreduce.map.output.compress | false | mapper输出 | 这个参数设为true启用压缩 |
| mapreduce.map.output.compress.codec | org.apache.hadoop.io.compress.DefaultCodec | mapper输出 | 使用LZO、LZ4或snappy编解码器在此阶段压缩数据 |
| mapreduce.output.fileoutputformat.compress | false | reducer输出 | 这个参数设为true启用压缩 |
| mapreduce.output.fileoutputformat.compress.codec | org.apache.hadoop.io.compress. DefaultCodec | reducer输出 | 使用标准工具或者编解码器，如gzip和bzip2 |
| mapreduce.output.fileoutputformat.compress.type | RECORD | reducer输出 | SequenceFile输出使用的压缩类型：NONE和BLOCK |
MR过程中进行压缩
开启Map输出阶段压缩
开启map输出阶段压缩可以减少job中map和Reduce task间数据传输量。具体配置如下：
案例实操：
1．开启hive中间传输数据压缩功能
hive (default)>set hive.exec.compress.intermediate=true;
2．开启mapreduce中map输出压缩功能
hive (default)>set mapreduce.map.output.compress=true;
3．设置mapreduce中map输出数据的压缩方式
hive (default)>set mapreduce.map.output.compress.codec=
org.apache.hadoop.io.compress.SnappyCodec;
4．执行查询语句
hive (default)> select count(ename) name from emp;
开启Reduce输出阶段压缩
当Hive将输出写入到表中时，输出内容同样可以进行压缩。属性hive.exec.compress.output控制着这个功能。
用户可能需要保持默认设置文件中的默认值false，这样默认的输出就是非压缩的纯文本文件了。
用户可以通过在查询语句或执行脚本中设置这个值为true，来开启输出结果压缩功能。
案例实操：
1．开启hive最终输出数据压缩功能
hive (default)>set hive.exec.compress.output=true;
2．开启mapreduce最终输出数据压缩
hive (default)>set mapreduce.output.fileoutputformat.compress=true;
3．设置mapreduce最终数据输出压缩方式
hive (default)> set mapreduce.output.fileoutputformat.compress.codec =
org.apache.hadoop.io.compress.SnappyCodec;
4．设置mapreduce最终数据输出压缩为块压缩
hive (default)> set mapreduce.output.fileoutputformat.compress.type=BLOCK;
5．测试一下输出结果是否是压缩文件
hive (default)> insert overwrite local directory
'/opt/module/datas/distribute-result' select * from emp distribute by deptno sort by empno desc;
存储
文件存储格式:
Hive支持的存储数据的格式主要有：TEXTFILE 、SEQUENCEFILE、ORC、PARQUET。
列式存储和行式存储
- 行存储的特点
查询满足条件的一整行数据的时候，列存储则需要去每个聚集的字段找到对应的每个列的值，行存储只需要找到其中一个值，其余的值都在相邻地方，所以此时行存储查询的速度更快。 - 列存储的特点
因为每个字段的数据聚集存储，在查询只需要少数几个字段的时候，能大大减少读取的数据量；每个字段的数据类型一定是相同的，列式存储可以针对性的设计更好的设计压缩算法。
TEXTFILE和SEQUENCEFILE的存储格式都是基于行存储的；
ORC和PARQUET是基于列式存储的。
TextFile格式
默认格式，存储方式为行存储，数据不做压缩，磁盘开销大，数据解析开销大。
可结合Gzip、Bzip2使用(系统自动检查，执行查询时自动解压)，但使用这种方式，压缩后的文件不支持split，Hive不会对数据进行切分，从而无法对数据进行并行操作。
并且在反序列化过程中，必须逐个字符判断是不是分隔符和行结束符，因此反序列化开销会比SequenceFile高几十倍。
优点:查看编辑简单
SequenceFile格式
SequenceFile是Hadoop API提供的一种二进制文件支持，它将数据以
这种二进制文件内部使用Hadoop 的标准的Writable 接口实现序列化和反序列化。Hive 中的SequenceFile 继承自Hadoop API 的SequenceFile，不过它的key为空，使用value 存放实际的值， 这样是为了避免MR 在运行map 阶段的排序过程。
存储方式为行存储，其具有使用方便、可分割、可压缩的特点。
SequenceFile支持三种压缩选择：NONE，RECORD，BLOCK。Record压缩率低，一般建议使用BLOCK压缩。
优势是文件和hadoop api中的MapFile是相互兼容的
缺点:本地查看不方便
RC格式
存储方式：数据按行分块，每块按列存储。结合了行存储和列存储的优点：
首先，RCFile 保证同一行的数据位于同一节点，因此元组重构的开销很低；
其次，像列存储一样，RCFile 能够利用列维度的数据压缩，并且能跳过不必要的列读取；
RCFile的一个行组包括三个部分：
第一部分是行组头部的【同步标识】，主要用于分隔 hdfs 块中的两个连续行组
第二部分是行组的【元数据头部】，用于存储行组单元的信息，包括行组中的记录数、每个列的字节数、列中每个域的字节数
第三部分是【表格数据段】，即实际的列存储数据。在该部分中，同一列的所有域顺序存储。
从图可以看出，首先存储了列 A 的所有域，然后存储列 B 的所有域等。
数据追加：RCFile 不支持任意方式的数据写操作，仅提供一种追加接口，这是因为底层的 HDFS当前仅仅支持数据追加写文件尾部。
行组大小：行组变大有助于提高数据压缩的效率，但是可能会损害数据的读取性能，因为这样增加了 Lazy 解压性能的消耗。而且行组变大会占用更多的内存，这会影响并发执行的其他MR作业。 考虑到存储空间和查询效率两个方面，Facebook 选择 4MB 作为默认的行组大小，当然也允许用户自行选择参数进行配置。
ORC格式
Orc (Optimized Row Columnar)是Hive 0.11版里引入的新的存储格式。
如图所示可以看到每个Orc文件由1个或多个stripe组成，每个stripe一般为HDFS的块大小，每一个stripe包含多条记录，这些记录按照列进行独立存储，对应到Parquet中的row group的概念。每个Stripe里有三部分组成，分别是Index Data，Row Data，Stripe Footer：
1）Index Data： 一个轻量级的index，默认是每隔1W行做一个索引。这里做的索引应该只是记录某行的各字段在Row Data中的offset。
2）Row Data： 存的是具体的数据，先取部分行，然后对这些行按列进行存储。对每个列进行了编码，分成多个Stream来存储。
3）Stripe Footer： 存的是各个Stream的类型，长度等信息。
每个文件有一个File Footer，这里面存的是每个Stripe的行数，每个Column的数据类型信息等；每个文件的尾部是一个PostScript，这里面记录了整个文件的压缩类型以及FileFooter的长度信息等。在读取文件时，会seek到文件尾部读PostScript，从里面解析到File Footer长度，再读FileFooter，从里面解析到各个Stripe信息，再读各个Stripe，即从后往前读。
Parquet格式
Parquet文件是以二进制方式存储的，所以是不可以直接读取的，文件中包括该文件的数据和元数据，因此Parquet格式文件是自解析的。
- 行组(Row Group)： 每一个行组包含一定的行数，在一个HDFS文件中至少存储一个行组，类似于orc的stripe的概念。
- 列块(Column Chunk)： 在一个行组中每一列保存在一个列块中，行组中的所有列连续的存储在这个行组文件中。一个列块中的值都是相同类型的，不同的列块可能使用不同的算法进行压缩。
- 页(Page)： 每一个列块划分为多个页，一个页是最小的编码的单位，在同一个列块的不同页可能使用不同的编码方式。
通常情况下，在存储Parquet数据的时候会按照Block大小设置行组的大小，由于一般情况下每一个Mapper任务处理数据的最小单位是一个Block，这样可以把每一个行组由一个Mapper任务处理，增大任务执行并行度。
上图展示了一个Parquet文件的内容，一个文件中可以存储多个行组，文件的首位都是该文件的Magic Code，用于校验它是否是一个Parquet文件.
Footer length记录了文件元数据的大小，通过该值和文件长度可以计算出元数据的偏移量，文件的元数据中包括每一个行组的元数据信息和该文件存储数据的Schema信息。
除了文件中每一个行组的元数据，每一页的开始都会存储该页的元数据，在Parquet中，有三种类型的页：数据页、字典页和索引页。
数据页用于存储当前行组中该列的值.
字典页存储该列值的编码字典，每一个列块中最多包含一个字典页.
索引页用来存储当前行组下该列的索引，目前Parquet中还不支持索引页。
存储文件的压缩比总结：
ORC > Parquet > textFile
ORC存储文件默认采用ZLIB压缩，ZLIB采用的是deflate压缩算法。比snappy压缩的小。
在实际的项目开发当中，hive表的数据存储格式一般选择：orc或parquet。压缩方式一般选择snappy，lzo。
Hive调优
Fetch抓取
Fetch抓取是指，Hive中对某些情况的查询可以不必使用MapReduce计算。例如：SELECT * FROM employees;在这种情况下，Hive可以简单地读取employee对应的存储目录下的文件，然后输出查询结果到控制台。
在hive-default.xml.template文件中hive.fetch.task.conversion默认是more，老版本hive默认是minimal，该属性修改为more以后，在全局查找、字段查找、limit查找等都不走mapreduce。
<property>
<name>hive.fetch.task.conversionname>
<value>morevalue>
<description>
Expects one of [none, minimal, more].
Some select queries can be converted to single FETCH task minimizing latency.
Currently the query should be single sourced not having any subquery and should not have any aggregations or distincts (which incurs RS), lateral views and joins.
0. none : disable hive.fetch.task.conversion
1. minimal : SELECT STAR, FILTER on partition columns, LIMIT only
2. more : SELECT, FILTER, LIMIT only (support TABLESAMPLE and virtual columns)
description>
property>
案例实操：
1）把hive.fetch.task.conversion设置成none，然后执行查询语句，都会执行mapreduce程序。
hive (default)> set hive.fetch.task.conversion=none;
hive (default)> select * from emp;
hive (default)> select ename from emp;
hive (default)> select ename from emp limit 3;
2）把hive.fetch.task.conversion设置成more，然后执行查询语句，如下查询方式都不会执行mapreduce程序。
hive (default)> set hive.fetch.task.conversion=more;
hive (default)> select * from emp;
hive (default)> select ename from emp;
hive (default)> select ename from emp limit 3;
本地模式
大多数的Hadoop Job是需要Hadoop提供的完整的可扩展性来处理大数据集的。不过，有时Hive的输入数据量是非常小的。
在这种情况下，为查询触发执行任务消耗的时间可能会比实际job的执行时间要多的多。
对于大多数这种情况，Hive可以通过本地模式在单台机器上处理所有的任务。对于小数据集，执行时间可以明显被缩短。
用户可以通过设置hive.exec.mode.local.auto的值为true，来让Hive在适当的时候自动启动这个优化，默认是false。
set hive.exec.mode.local.auto=true; //开启本地mr
//设置local mr的最大输入数据量，当输入数据量小于这个值时采用local mr的方式，默认为134217728，即128M
set hive.exec.mode.local.auto.inputbytes.max=50000000;
//设置local mr的最大输入文件个数，当输入文件个数小于这个值时采用local mr的方式，默认为4
set hive.exec.mode.local.auto.input.files.max=10;
案例实操:
案例实操：
1）开启本地模式，并执行查询语句
hive (default)> set hive.exec.mode.local.auto=true;
hive (default)> select * from emp cluster by deptno;
Time taken: 1.328 seconds, Fetched: 14 row(s)
2）关闭本地模式，并执行查询语句
hive (default)> set hive.exec.mode.local.auto=false;
hive (default)> select * from emp cluster by deptno;
Time taken: 20.09 seconds, Fetched: 14 row(s)
表的优化
大表join小表
如果不指定MapJoin或者不符合MapJoin的条件，那么Hive解析器会将Join操作转换成Common Join，即：在Reduce阶段完成join。
容易发生数据倾斜。可以用MapJoin把小表全部加载到内存在map端进行join，避免reducer处理。
开启MapJoin参数设置
（1）设置自动选择Mapjoin
set hive.auto.convert.join = true; 默认为true
（2）大表小表的阈值设置（默认25M一下认为是小表）：
set hive.mapjoin.smalltable.filesize=25000000;
下图为Map join工作机制
大表join大表
- 空KEY过滤或者转换:
空KEY过滤 key is not null
有时join超时是因为某些key对应的数据太多，而相同key对应的数据都会发送到相同的reducer上，从而导致内存不够。
此时我们应该仔细分析这些异常的key，很多情况下，这些key对应的数据是异常数据，我们需要在SQL语句中进行过滤。
空KEY转换:
有时虽然某个key为空对应的数据很多，但是相应的数据不是异常数据，必须要包含在join的结果中，此时我们可以表a中key为空的字段赋一个随机的值，使得数据随机均匀地分不到不同的reducer上。
例:
# 本例使用了concat结合rand函数来进行空key转换,防止空Key导致的数据倾斜问题,提高效率
insert overwrite table jointable
select n.* from nullidtable n full join ori o on
case when n.id is null then concat('hive', rand()) else n.id end = o.id;
- 开启Map端聚合,开启负载均衡
默认情况下，Map阶段同一Key数据分发给一个reduce，当一个key数据过大时就倾斜了。
并不是所有的聚合操作都需要在Reduce端完成，很多聚合操作都可以先在Map端进行部分聚合，最后在Reduce端得出最终结果。
参数配置:
（1）是否在Map端进行聚合，默认为True
set hive.map.aggr = true
（2）在Map端进行聚合操作的条目数目
set hive.groupby.mapaggr.checkinterval = 100000
（3）有数据倾斜的时候进行负载均衡（默认是false）
set hive.groupby.skewindata = true
当选项设定为 true，生成的查询计划会有两个MR Job。
第一个MR Job中，Map的输出结果会随机分布到Reduce中，每个Reduce做部分聚合操作，并输出结果，这样处理的结果是相同的Group By Key有可能被分发到不同的Reduce中，从而达到负载均衡的目的；
第二个MR Job再根据预处理的数据结果按照Group By Key分布到Reduce中（这个过程可以保证相同的Group By Key被分布到同一个Reduce中），最后完成最终的聚合操作。
去重优化
数据量小的时候无所谓，数据量大的情况下，由于COUNT DISTINCT的全聚合操作，即使设定了reduce task个数，
set mapred.reduce.tasks=100；hive也只会启动一个reducer。
这就造成一个Reduce处理的数据量太大，导致整个Job很难完成，一般COUNT DISTINCT使用先GROUP BY再COUNT的方式替换：
select count(distinct id) from bigtable; #不推荐,数据量很大时只有一个reducer
select count(id) from (select id from bigtable group by id) a; #使用group by 去重id 虽然会多用一个Job来完成，但在数据量大的情况下，这个绝对是值得的。
笛卡尔积
尽量避免笛卡尔积，join的时候不加on条件，或者无效的on条件，Hive只能使用1个reducer来完成笛卡尔积。
行列过滤
列处理：在SELECT中，只拿需要的列，如果有，尽量使用分区过滤，少用SELECT *。
行处理：在分区剪裁中，当使用外关联时，如果将副表的过滤条件写在Where后面，那么就会先全表关联，之后再过滤
案例实操
1．测试先关联两张表，再用where条件过滤
hive (default)> select o.id from bigtable b
join ori o on o.id = b.id
where o.id <= 10;
Time taken: 34.406 seconds, Fetched: 100 row(s)
2．通过子查询后，再关联表
hive (default)> select b.id from bigtable b
join (select id from ori where id <= 10 ) o on b.id = o.id;
Time taken: 30.058 seconds, Fetched: 100 row(s)
分区,动态分区
此部分优化可参考文章前面涉及到的分区,动态分区的内容
分桶
此部分优化可参考文章前面涉及到的分桶内容
合理设置MapReduce个数
Map个数分析
1）通常情况下，作业会通过input的目录产生一个或者多个map任务。
主要的决定因素有：input的文件总个数，input的文件大小，集群设置的文件块大小。
2）是不是map数越多越好？
答案是否定的。如果一个任务有很多小文件（远远小于块大小128m），则每个小文件也会被当做一个块，用一个map任务来完成，而一个map任务启动和初始化的时间远远大于逻辑处理的时间，就会造成很大的资源浪费。而且，同时可执行的map数是受限的。
3）是不是保证每个map处理接近128m的文件块，就高枕无忧了？
答案也是不一定。比如有一个127m的文件，正常会用一个map去完成，但这个文件只有一个或者两个小字段，却有几千万的记录，如果map处理的逻辑比较复杂，用一个map任务去做，肯定也比较耗时。
针对上面的问题2和3，我们需要采取两种方式来解决：即减少map数和增加map数；
复杂文件增加Map数
当input的文件都很大，任务逻辑复杂，map执行非常慢的时候，可以考虑增加Map数，来使得每个map处理的数据量减少，从而提高任务的执行效率。
增加map的方法为：根据
computeSliteSize(Math.max(minSize,Math.min(maxSize,blocksize)))=blocksize=128M
公式，调整maxSize最大值。让maxSize最大值低于blocksize就可以增加map的个数。设置方式如下:
set mapreduce.input.fileinputformat.split.maxsize=10000; #设置最大切片值为10000字节
小文件合并
（1）在map执行前合并小文件，减少map数：CombineHiveInputFormat具有对小文件进行合并的功能（系统默认的格式）。HiveInputFormat没有对小文件合并功能。
set hive.input.format= org.apache.hadoop.hive.ql.io.CombineHiveInputFormat;
（2）在Map-Reduce的任务结束时合并小文件的设置：
SET hive.merge.mapfiles = true; # 在map-only任务结束时合并小文件，默认true
SET hive.merge.mapredfiles = true; # 在map-reduce任务结束时合并小文件，默认false
SET hive.merge.size.per.task = 268435456; #合并文件的大小，默认256M
SET hive.merge.smallfiles.avgsize = 16777216; # 当输出文件的平均大小小于该值时，启动一个独立的map-reduce任务进行文件merge
合理设置Reduce个数
1．调整reduce个数方法一
（1）每个Reduce处理的数据量默认是256MB
hive.exec.reducers.bytes.per.reducer=256000000
（2）每个任务最大的reduce数，默认为1009
hive.exec.reducers.max=1009
（3）计算reducer数的公式
N=min(参数2，总输入数据量/参数1)
2．调整reduce个数方法二
在hadoop的mapred-default.xml文件中修改
设置每个job的Reduce个数
set mapreduce.job.reduces = 15;
3．reduce个数并不是越多越好
1）过多的启动和初始化reduce也会消耗时间和资源；
2）另外，有多少个reduce，就会有多少个输出文件，如果生成了很多个小文件，那么如果这些小文件作为下一个任务的输入，则也会出现小文件过多的问题；
在设置reduce个数的时候也需要考虑这两个原则：处理大数据量利用合适的reduce数；使单个reduce任务处理数据量大小要合适；
并行执行
Hive会将一个查询转化成一个或者多个阶段。这样的阶段可以是MapReduce阶段、抽样阶段、合并阶段、limit阶段。
或者Hive执行过程中可能需要的其他阶段。默认情况下，Hive一次只会执行一个阶段。不过，某个特定的job可能包含众多的阶段，而这些阶段可能并非完全互相依赖的，也就是说有些阶段是可以并行执行的，这样可能使得整个job的执行时间缩短。
不过，如果有更多的阶段可以并行执行，那么job可能就越快完成。
通过设置参数hive.exec.parallel值为true，就可以开启并发执行。不过，在共享集群中，需要注意下，如果job中并行阶段增多，那么集群利用率就会增加。
set hive.exec.parallel=true; //打开任务并行执行
set hive.exec.parallel.thread.number=16; //同一个sql允许最大并行度，默认为8。
当然，得是在系统资源比较空闲的时候才有优势，否则，没资源，并行也起不来。
严格模式
Hive提供了一个严格模式，可以防止用户执行那些可能意想不到的不好的影响的查询。
通过设置属性hive.mapred.mode值为默认是非严格模式nonstrict 。
开启严格模式需要修改hive.mapred.mode值为strict，开启严格模式可以禁止3种类型的查询。
<property>
<name>hive.mapred.modename>
<value>strictvalue>
<description>
The mode in which the Hive operations are being performed.
In strict mode, some risky queries are not allowed to run. They include:
Cartesian Product.
No partition being picked up for a query.
Comparing bigints and strings.
Comparing bigints and doubles.
Orderby without limit.
description>
property>
- 对于分区表，除非where语句中含有分区字段过滤条件来限制范围，否则不允许执行。换句话说，就是用户不允许扫描所有分区。
进行这个限制的原因是，通常分区表都拥有非常大的数据集，而且数据增加迅速。
没有进行分区限制的查询可能会消耗令人不可接受的巨大资源来处理这个表。 - 对于使用了order by语句的查询，要求必须使用limit语句。
因为order by为了执行排序过程会将所有的结果数据分发到同一个Reducer中进行处理，强制要求用户增加这个LIMIT语句可以防止Reducer额外执行很长一段时间。 - 限制笛卡尔积的查询。对关系型数据库非常了解的用户可能期望在执行JOIN查询的时候不使用ON语句而是使用where语句，这样关系数据库的执行优化器就可以高效地将WHERE语句转化成那个ON语句。
不幸的是，Hive并不会执行这种优化，因此，如果表足够大，那么这个查询就会出现不可控的情况。
JVM重用
JVM重用是Hadoop调优参数的内容，其对Hive的性能具有非常大的影响，特别是对于很难避免小文件的场景或task特别多的场景，这类场景大多数执行时间都很短。
Hadoop的默认配置通常是使用派生JVM来执行map和Reduce任务的。这时JVM的启动过程可能会造成相当大的开销，尤其是执行的job包含有成百上千task任务的情况。
JVM重用可以使得JVM实例在同一个job中重新使用N次。N的值可以在Hadoop的mapred-site.xml文件中进行配置。通常在10-20之间，具体多少需要根据具体业务场景测试得出。
<property>
<name>mapreduce.job.jvm.numtasksname>
<value>10value>
<description>How many tasks to run per jvm. If set to -1, there is
no limit.
description>
property>
这个功能的缺点是，开启JVM重用将一直占用使用到的task插槽，以便进行重用，直到任务完成后才能释放。
如果某个“不平衡的”job中有某几个reduce task执行的时间要比其他Reduce task消耗的时间多的多的话，那么保留的插槽就会一直空闲着却无法被其他的job使用，直到所有的task都结束了才会释放。
推测执行(慎用)
在分布式集群环境下，因为程序Bug（包括Hadoop本身的bug），负载不均衡或者资源分布不均等原因，会造成同一个作业的多个任务之间运行速度不一致，有些任务的运行速度可能明显慢于其他任务（比如一个作业的某个任务进度只有50%，而其他所有任务已经运行完毕），则这些任务会拖慢作业的整体执行进度。
为了避免这种情况发生，Hadoop采用了推测执行（Speculative Execution）机制，它根据一定的法则推测出“拖后腿”的任务，并为这样的任务启动一个备份任务，让该任务与原始任务同时处理同一份数据，并最终选用最先成功运行完成任务的计算结果作为最终结果。
设置开启推测执行参数：Hadoop的mapred-site.xml文件中进行配置，默认是true
<property>
<name>mapreduce.map.speculativename>
<value>truevalue>
<description>If true, then multiple instances of some map tasks
may be executed in parallel.description>
property>
<property>
<name>mapreduce.reduce.speculativename>
<value>truevalue>
<description>If true, then multiple instances of some reduce tasks
may be executed in parallel.description>
property>
<property>
<name>hive.mapred.reduce.tasks.speculative.executionname>
<value>truevalue>
<description>Whether speculative execution for reducers should be turned on. description>
property>
关于调优这些推测执行变量，还很难给一个具体的建议。如果用户对于运行时的偏差非常敏感的话，那么可以将这些功能关闭掉。如果用户因为输入数据量很大而需要执行长时间的map或者Reduce task的话，那么启动推测执行造成的浪费是非常巨大大。
选择合理的压缩方式和存储格式
压缩方式和存储格式的选取可以参照博客上面对这一部分的介绍
Hive实战
在实际的面试或者笔试中,经常会出现需要手写hive sql的笔试或者面试官给出指定的场景来让我们编写SQL语句.
因此,除了基本的理论知识,我们还要有一定的Hive实战能力,才能保证有备无患
我这里给出几种常考的面试题,仅做抛砖引玉
使用hive实现WordCount
1.创建数据库
create database wordcount;
2.创建外部表
create external table word_data(line string) row format delimited fields terminated by ',' location '/home/hadoop/worddata';
3.映射数据表
load data inpath '/home/hadoop/worddata' into table word_data;
4.这里假设我们的数据存放在hadoop下，路径为：/home/hadoop/worddata，里面主要是一些单词文件，内容大概为：
hello man
what are you doing now
my running
hello
kevin
hi man
执行了上述hql就会创建一张表src_wordcount，内容是这些文件的每行数据，每行数据存在字段line中，select * from word_data;就可以看到这些数据
5.根据MapReduce的规则，我们需要进行拆分，把每行数据拆分成单词，这里需要用到一个hive的内置表生成函数（UDTF）：explode(array)，参数是array，其实就是行变多列：
create table words(word string);
insert into table words select explode(split(line, " ")) as word from word_data;
6.查看words表内容
OK
hello
man
what
are
you
doing
now
my
running
hello
kevin
hi
man
split是拆分函数，跟java的split功能一样，这里是按照空格拆分，所以执行完hql语句，words表里面就全部保存的单个单词
7.group by统计单词
select word, count(*) from wordcount.words group by word;
wordcount.words 库名称.表名称，group by word这个word是create table words(word string) 命令创建的word string
结果：
are 1
doing 1
hello 2
hi 1
kevin 1
man 2
my 1
now 1
running 1
what 1
you 1
使用hive求TOP N
rank() over()
dense_rank() over()
row_number() over()
使用Hive进行行列转换
１、问题
hive如何将
a b 1
a b 2
a b 3
c d 4
c d 5
c d 6
变为：
a b 1,2,3
c d 4,5,6
-------------------------------------------------------------------------------------------
２、数据
test.txt
a b 1
a b 2
a b 3
c d 4
c d 5
c d 6
-------------------------------------------------------------------------------------------
３、答案
1.建表
drop table tmp_jiangzl_test;
create table tmp_jiangzl_test
(
col1 string,
col2 string,
col3 string
)
row format delimited fields terminated by '\t'
stored as textfile;
-- 加载数据
load data local inpath '/home/jiangzl/shell/test.txt' into table tmp_jiangzl_test;
2.处理
select col1,col2,concat_ws(',',collect_set(col3))
from tmp_jiangzl_test
group by col1,col2;
---------------------------------------------------------------------------------------
二、列转行
１、问题
hive如何将
a b 1,2,3
c d 4,5,6
变为：
a b 1
a b 2
a b 3
c d 4
c d 5
c d 6
---------------------------------------------------------------------------------------------
2、答案
1.建表
drop table tmp_jiangzl_test;
create table tmp_jiangzl_test
(
col1 string,
col2 string,
col3 string
)
row format delimited fields terminated by '\t'
stored as textfile;
处理：
select col1, col2, col5
from tmp_jiangzl_test a
lateral view explode(split(col3,',')) b AS col5;
使用Hive进留存率统计
游戏公司等会很关注用户留存率问题,这里给出一个模板
SET mapreduce.job.queuename=xxx;
SET mapreduce.job.name=xxx;
set mapreduce.job.reduces=19;
select '日期', '注册用户数', '次日留存率', '2日留存率', '3日留存率', dim_date
,total_cnt
,concat_ws('% | ', cast(round(dif_1cnt*100/total_cnt, 2) as string), cast(dif_1cnt as string))
,concat_ws('% | ', cast(round(dif_2cnt*100/total_cnt, 2) as string), cast(dif_2cnt as string))
,concat_ws('% | ', cast(round(dif_3cnt*100/total_cnt, 2) as string), cast(dif_3cnt as string))
,concat_ws('% | ', cast(round(dif_4cnt*100/total_cnt, 2) as string), cast(dif_4cnt as string))
from
(
select p1.state dim_date
,p1.device_os
,count(distinct p1.user_id) total_cnt
,count(distinct if(datediff(p3.state,p1.state) = 1, p1.user_id, null)) dif_1cnt
,count(distinct if(datediff(p3.state,p1.state) = 2, p1.user_id, null)) dif_2cnt
,count(distinct if(datediff(p3.state,p1.state) = 3, p1.user_id, null)) dif_3cnt
,count(distinct if(datediff(p3.state,p1.state) = 4, p1.user_id, null)) dif_4cnt
from
(
select
from_unixtime(unix_timestamp(cast(partition_date as string), 'yyyyMMdd'), 'yyyy-MM-dd') state,
user_id
from user_active_day
where partition_date between date1 and date2
and user_is_new = 1
group by 1,2
)p1 --日新增用户名单(register_date,user_id)
left outer join
(
select
from_unixtime(unix_timestamp(cast(partition_date as string), 'yyyyMMdd'), 'yyyy-MM-dd') state,
user_id
from active_users
where partition_date between date1 and date2
group by 1,2
)p3 --期间活跃用户(active_date,user_id)
on (p3.user_id = p1.user_id)
group by 1,2
) p4;
工作中使用Hive遇到的问题
- 内存溢出
map阶段
解决：一般存在MapJoin，设置参数set hive.auto.convert.join = false转成reduce端的Common Join。
shuffle阶段
解决：减少每个reduce处理的数据量，调整参数：hive.exec.reducers.bytes.per.reducer，默认300000000。或调整放在内存里的最大片段所占百分比（set mapreduce.reduce.shuffle.memory.limit.percent=0.10)。
reduce阶段
解决：减少每个reduce处理的数据量，调整参数：hive.exec.reducers.bytes.per.reducer，默认300000000。如果存在数据倾斜，单纯增加reduce个数没有用，参考“Hive优化方法.ppt”进行数据倾斜优化。
- 执行动态分区HQL报错，报错信息类似如下：
org.apache.hadoop.hive.ql.metadata.HiveException: Hive Runtime Error: Unable to deserialize reduce input key from x1x128x0x0x19x1x255 with properties {
columns=reducesinkkey0,reducesinkkey1,reducesinkkey2,reducesinkkey3, serialization.lib=org.apache.hadoop.hive.serde2.binarysortable.BinarySortableSerDe, serialization.sort.order=++++++, columns.types=int,int,int,int,string,bigint}
解决：设置参数set hive.optimize.sort.dynamic.partition=false。
- Hive创建文件数过多问题，报错信息类似如下：
total number of created files now is 100130, which exceeds 100000. Killing the job
解决：调大参数hive.exec.max.created.files。
- Hive使用过多的变量替换，报错信息如下：
FAILED: IllegalStateException Variable substitution depth too large: 40
解决：调大参数hive.variable.substitute.depth。
- select * 使用MR而不使用fetchtask
解决：set hive.fetch.task.conversion=minimal。
-
分区表分区字段是日期类型时限制分区条件使用to_unix_timestamp方法，如果使用unix_timestamp方法仍会扫全表。
Causedby:org.apache.hadoop.ipc.RemoteException(org.apache.hadoop.hdfs.protocol.FSLimitException$PathComponentTooLongException): The maximum path component name limit of ...Could not find status of job:job_id...这个问题是job name过长导致，一般任务运行成功，但看不到日志，historyserver提示任务not found。
解决：设置job 的名称set mapreduce.job.name=XXX;
- 使用动态分区时碰到如下报错信息：
Failed with exception Number of dynamic partitions created is 1191, which is more than 1000. To solve this try to set hive.exec.max.dynamic.partitions to at least 1191
参数hive.exec.max.dynamic.partitions限制了所允许的最大分区个数，默认值是1000。
解决：调大参数hive.exec.max.dynamic.partitions。
9)往rcfile格式的表insert数据时报错:
“Caused by: java.lang.UnsupportedOperationException: Currently the writer can only accept BytesRefArrayWritable”
解决：修改rcfile 表 serde 属性
alter table table_name set serde 'org.apache.hadoop.hive.serde2.columnar.ColumnarSerDe';
- 任务执行报“Caused by: java.io.IOException: Split metadata size exceeded 10000000. Aborting job XXX”
job.splitmetainfo文件大小超过默认值10000000（10M)。
解决：调大参数mapreduce.jobtracker.split.metainfo.maxsize。
- Hive执行报“FAILED: ParseException line ”
解决：Hive语法问题，请检查自己的语句，如有不确定请查阅Hive语法。
- Hive任务执行过程中失败，报“Caused by: java.io.FileNotFoundException: File does not exist: XXX”
原因：任务运行过程中依赖的表发生了变化，可能是表被删了、表重建了或者表数据重新生成之类的等等情况。譬如，报错：“Caused by: java.io.FileNotFoundException: File does not exist: hdfs://XXX/user/A/hive/warehouse/A.db/trec_season2_coupon_info_pc/000000_0”，则是因为任务运行过程中，依赖的表A.trec_season2_coupon_info_pc发生了变化。
- 对于Hive里的分区表，新增字段后，通过insert overwrite等方式重新生成历史分区的数据，发现新增字段仍旧是null值。
解决：Hive分区表新增字段后，需要对历史老分区进行重建才能查询新增字段，但是对于新增字段后新生成的分区是不受影响的，能正常查询数据。
- FAILED: RuntimeException MetaException(message:java.lang.ClassNotFoundException Class org.openx.data.jsonserde.JsonSerDe not found)
解决：确认是否对json-serde.jar执行了add jar。
- FAILED: SemanticException [Error 10087]: The same output cannot be present multiple times
原因：使用多重insert（multi insert)时，结果是非分区表则不能是同一个，分区表必须是不同分区，结果是hdfs目录的也必须不同。
- 任务运行正常，在最后move数据阶段报错：
Failed with exception Unable to move source XXX to destination XXX
FAILED: Execution Error, return code 1 from org.apache.hadoop.hive.ql.exec.MoveTask
解决：set hive.exec.copyfile.maxsize=10000000000;
- FAILED: SemanticException Line 0:-1 Invalid column reference '$f1’
解决：set hive.cbo.enable=false;
- 重复列名，报错关键字Ambiguous column reference * in * .
解决：去掉重复的字段
示例：select t.id from (select dummy,dummy from default.dual)t;
FAILED: SemanticException [Error 10007]: Ambiguous column reference dummy in t
去掉子查询里的一个dummy字段。
- union all的子句里不支持orderByClause、clusterByClause、distributeByClause、sortByClause或limitClause
解决：改造hql，去掉union all子查询里的orderByClause、clusterByClause、distributeByClause、sortByClause和limitClause语句
示例：select t.id from (select dummy from default.dual limit 1 union all select dummy from default.dual limit 1)t;
去掉两个子查询里的limit 1;
- 建表列名不允许包含.或:，报错如下：ParseException line 1:45 Failed to recognize predicate ‘)’. Failed rule: ‘[., :] can not be used in column name in create table statement.’ in column specification
解决：检查建表语句，将字段名中包含的.或: 去掉。
- Cannot modify hive.conf.restricted.list at runtime. It is in the listof parameters that can’t be modified at runtime
原因：对hive.exec.max.dynamic.partitions,hive.exec.max.dynamic.partitions.pernode,hive.exec.max.created.files三个参数值进行了限制，用户自定义设置不生效，不影响任务的执行，除非动态创建的分区数和任务创建的文件数在任务运行过程中超过了限制值，任务才会失败。
- interval 是hive-1.2版本里新增的关键字，不可作为表字段名、别名。
示例1：select dummy as interval from dual; 查询报错
NoViableAltException(142@[134:7: ( ( ( KW_AS )? identifier ) | ( KW_AS LPAREN identifier ( COMMA identifier )* RPAREN ) )?])
FAILED: ParseException line 1:16 cannot recognize input near 'as' 'interval' 'from' in selection target
示例2：create table test_interval(interval string);
NoViableAltException(142@[])
at org.apache.hadoop.hive.ql.parse.HiveParser_IdentifiersParser.identifier(HiveParser_IdentifiersParser.java:10858)
FAILED: ParseException line 1:27 cannot recognize input near 'interval' 'string' ')' in column specification