Hadoop生态之Hive（完结篇）

一直连载的Hive篇也即将完结了，Hive作为Hadoop中必不可少的数据仓库工具.
相对于传统关系型数据库来说做出了一部分改变，但是跟那些关系型数据库相比也是仍然有一些缺点。
番薯今天会在文末给诸佬们奉上一些面试题。诸佬们复习跟学习多多少少都会有点帮助。

7.分区表和分桶表

7.1 分区表

分区表实际上就是对应一个 HDFS 文件系统上的独立的文件夹，该文件夹下是该分区所有的数据文件。Hive 中的分区就是分目录，把一个大的数据集根据业务需要分割成小的数据集。在查询时通过 WHERE 子句中的表达式选择查询所需要的指定的分区，这样的查询效率会提高很多。

7.1.1 分区表基本操作

1）引入分区表（需要根据日期对日志进行管理, 通过部门信息模拟）

dept_20200401.log
dept_20200402.log
dept_20200403.log

2）创建分区表语法

hive (default)> create table dept_partition(
deptno int, 
dname string, 
loc string
)
partitioned by (day string)
row format delimited fields terminated by '\t';

注意：分区字段不能是表中已经存在的数据，可以将分区字段看作表的伪列。
3）加载数据到分区表中
（1） 数据准备

dept_20200401.log
10 ACCOUNTING 1700
20 RESEARCH 1800
dept_20200402.log
30 SALES 1900
40 OPERATIONS 1700
dept_20200403.log
50 TEST 2000
60 DEV 1900

（2） 加载数据

hive (default)> load data local inpath '/opt/module/hive/datas/dept_20200401.log' into table dept_partition partition(day='20200401');
hive (default)> load data local inpath '/opt/module/hive/datas/dept_20200402.log' into table dept_partition partition(day='20200402');
hive (default)> load data local inpath '/opt/module/hive/datas/dept_20200403.log' into table dept_partition 
partition(day='20200403');

注意：分区表加载数据时，必须指定分区

4）查询分区表中数据
单分区查询

hive (default)> select * from dept_partition where day='20200401';

多分区联合查询

hive (default)> select * from dept_partition where day='20200401'
 union
 select * from dept_partition where day='20200402'
 union
 select * from dept_partition where day='20200403';
hive (default)> select * from dept_partition where day='20200401' or
 day='20200402' or day='20200403'; 

5）增加分区

创建单个分区
hive (default)> alter table dept_partition add partition(day='20200404');

同时创建多个分区
hive (default)> alter table dept_partition add partition(day='20200405') 
partition(day='20200406');

6）删除分区

删除单个分区
hive (default)> alter table dept_partition drop partition 
(day='20200406');

同时删除多个分区
hive (default)> alter table dept_partition drop partition 
(day='20200404'), partition(day='20200405');

7）查看分区表有多少分区

hive> show partitions dept_partition;

8）查看分区表结构

hive> desc formatted dept_partition;

#Partition Information
#col_name data_type comment month string

7.1.2 二级分区

诸佬们可以思考一下如果一天的日志数据量也很大，如何再将数据拆分?

1）#创建二级分区表
hive (default)> create table dept_partition2(
 deptno int, dname string, loc string
 )
 partitioned by (day string, hour string)
 row format delimited fields terminated by '\t';

2）正常的加载数据

（1）#加载数据到二级分区表中
hive (default)> load data local inpath '/opt/module/hive/datas/dept_20200401.log' into table
dept_partition2 partition(day='20200401', hour='12');

（2）#查询分区数据
hive (default)> select * from dept_partition2 where day='20200401' and 
hour='12';

3）把数据直接上传到分区目录上，让分区表和数据产生关联的三种方式
（1）方式一：上传数据后修复

#上传数据
hive (default)> dfs -mkdir -p
/user/hive/warehouse/mydb.db/dept_partition2/day=20200401/hour=13;
hive (default)> dfs -put /opt/module/datas/dept_20200401.log 
/user/hive/warehouse/mydb.db/dept_partition2/day=20200401/hour=13;

#查询数据（查询不到刚上传的数据）
hive (default)> select * from dept_partition2 where day='20200401' and 
hour='13';

#执行修复命令
hive> msck repair table dept_partition2;

#再次查询数据
hive (default)> select * from dept_partition2 where day='20200401' and 
hour='13';

（2）方式二：上传数据后添加分区

#上传数据
hive (default)> dfs -mkdir -p
/user/hive/warehouse/mydb.db/dept_partition2/day=20200401/hour=14;
hive (default)> dfs -put /opt/module/hive/datas/dept_20200401.log 
/user/hive/warehouse/mydb.db/dept_partition2/day=20200401/hour=14;

#执行添加分区
hive (default)> alter table dept_partition2 add 
partition(day='201709',hour='14');

#查询数据
hive (default)> select * from dept_partition2 where day='20200401' and 
hour='14';

（3）方式三：创建文件夹后 load 数据到分区

#创建目录
hive (default)> dfs -mkdir -p /user/hive/warehouse/mydb.db/dept_partition2/day=20200401/hour=15;

#上传数据
hive (default)> load data local inpath '/opt/module/hive/datas/dept_20200401.log' into table
dept_partition2 partition(day='20200401',hour='15');

#查询数据
hive (default)> select * from dept_partition2 where day='20200401' and 
hour='15';

7.1.3 动态分区调整

关系型数据库中，对分区表 Insert 数据时候，数据库自动会根据分区字段的值，将数据插入到相应的分区中，Hive 中也提供了类似的机制，即动态分区(Dynamic Partition)，只不过，使用 Hive 的动态分区，需要进行相应的配置。
1）开启动态分区参数设置
（1）开启动态分区功能（默认 true，开启）

hive.exec.dynamic.partition=true

（2）设置为非严格模式（动态分区的模式，默认 strict，表示必须指定至少一个分区为
静态分区，nonstrict 模式表示允许所有的分区字段都可以使用动态分区。）

hive.exec.dynamic.partition.mode=nonstrict

（3）在所有执行 MR 的节点上，最大一共可以创建多少个动态分区。默认 1000

hive.exec.max.dynamic.partitions=1000

（4）在每个执行 MR 的节点上，最大可以创建多少个动态分区。该参数需要根据实际
的数据来设定。比如：源数据中包含了一年的数据，即 day 字段有 365 个值，那么该参数就
需要设置成大于 365，如果使用默认值 100，则会报错。

hive.exec.max.dynamic.partitions.pernode=100

（5）整个 MR Job 中，最大可以创建多少个 HDFS 文件。默认 100000

hive.exec.max.created.files=100000

（6）当有空分区生成时，是否抛出异常。一般不需要设置。默认 false

hive.error.on.empty.partition=false

7.2 分桶表

分区提供一个隔离数据和优化查询的便利方式。不过，并非所有的数据集都可形成合理的分区。对于一张表或者分区，Hive 可以进一步组织成桶，也就是更为细粒度的数据范围划分。
分桶是将数据集分解成更容易管理的若干部分的另一个技术。

分区针对的是数据的存储路径；分桶针对的是数据文件。
（1）创建分桶表

create table stu_buck(id int, name string)
clustered by(id) 
into 4 buckets
row format delimited fields terminated by '\t';

（2）查看表结构

hive (default)> desc formatted stu_buck;
Num Buckets: 4 

（3）导入数据到分桶表中，load 的方式

hive (default)> load data inpath '/student.txt' into table stu_buck;

（4）查看创建的分桶表中是否分成 4 个桶
（5）查询分桶的数据

hive(default)> select * from stu_buck;

（6）分桶规则：
根据结果可知：Hive 的分桶采用对分桶字段的值进行哈希，然后除以桶的个数求余的方式决定该条记录存放在哪个桶当中
2）分桶表操作需要注意的事项:
（1）reduce 的个数设置为-1,让 Job 自行决定需要用多少个 reduce 或者将 reduce 的个数设置为大于等于分桶表的桶数
（2）从 hdfs 中 load 数据到分桶表中，避免本地文件找不到问题
（3）不要使用本地模式
3）insert 方式将数据导入分桶表

hive(default)>insert into table stu_buck select * from student_insert;

7.3 抽样查询

对于非常大的数据集，有时用户需要使用的是一个具有代表性的查询结果而不是全部结果。Hive 可以通过对表进行抽样来满足这个需求。
语法:

 TABLESAMPLE(BUCKET x OUT OF y)

查询表 stu_buck 中的数据。

hive (default)> select * from stu_buck tablesample(bucket 1 out of 4 on 
id);

注意：x 的值必须小于等于 y 的值
否则：

FAILED: SemanticException [Error 10061]: Numerator should not be
bigger than denominator in sample clause for table stu_buck

8. 函数

8.1 系统内置函数

1）查看系统自带的函数

hive> show functions;

2）显示自带的函数的用法

hive> desc function upper;

3）详细显示自带的函数的用法

hive> desc function extended upper;

8.2 常用内置函数

8.2.1 空字段赋值

1）函数说明
NVL：给值为 NULL 的数据赋值，它的格式是 NVL( value，default_value)。
它的功能是如果 value 为 NULL，则 NVL 函数返default_value 的值，否则返回 value 的值，如果两个参数都为 NULL ，则返回 NULL。

8.2.2 CASE WHEN THEN ELSE END

8.2.3 行转列

1）相关函数说明

CONCAT(string A/col, string B/col…)：返回输入字符串连接后的结果，支持任意个输入字符串;
CONCAT_WS(separator, str1, str2,…)：它是一个特殊形式的 CONCAT()。第一个参数剩余参数间的分隔符。分隔符可以是与剩余参数一样的字符串。如果分隔符是 NULL，返回值也将为 NULL。这个函数会跳过分隔符参数后的任何 NULL 和空字符串。分隔符将被加到被连接
的字符串之间;
注意: CONCAT_WS must be "string or array
COLLECT_SET(col)：函数只接受基本数据类型，它的主要作用是将某字段的值进行去重汇总，产生 Array 类型字段。

8.2.4 列转行

1）函数说明

EXPLODE(col)：将 hive 一列中复杂的 Array 或者 Map 结构拆分成多行。

LATERAL VIEW

用法：LATERAL VIEW udtf(expression) tableAlias AS columnAlias
解释：用于和 split, explode 等 UDTF 一起使用，它能够将一列数据拆成多行数据，在此
基础上可以对拆分后的数据进行聚合。

8.2.5 窗口函数（开窗函数）
1）相关函数说明

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 类型。

8.2.6 Rank

1）函数说明

RANK() 排序相同时会重复，总数不会变
DENSE_RANK() 排序相同时会重复，总数会减少
ROW_NUMBER() 会根据顺序计算

8.2.7 其他常用函数

常用日期函数
unix_timestamp:返回当前或指定时间的时间戳 select unix_timestamp();
select unix_timestamp(“2020-10-28”,‘yyyy-MM-dd’);

from_unixtime：将时间戳转为日期格式 select from_unixtime(1603843200);

current_date：当前日期 select current_date;

current_timestamp：当前的日期加时间 select current_timestamp;

to_date：抽取日期部分 select to_date(‘2020-10-28 12:12:12’);

year：获取年 select year(‘2020-10-28 12:12:12’);

month：获取月 select month(‘2020-10-28 12:12:12’);

day：获取日 select day(‘2020-10-28 12:12:12’);

hour：获取时 select hour(‘2020-10-28 12:12:12’);

minute：获取分 select minute(‘2020-10-28 12:12:12’);

second：获取秒 select second(‘2020-10-28 12:12:12’);

weekofyear：当前时间是一年中的第几周 select weekofyear(‘2020-10-28 12:12:12’);

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

months_between： 两个日期间的月份 select
months_between(‘2020-04-01’,‘2020-10-28’);

add_months：日期加减月 select add_months(‘2020-10-28’,-3);

datediff：两个日期相差的天数 select datediff(‘2020-11-04’,‘2020-10-28’);

date_add：日期加天数 select date_add(‘2020-10-28’,4);

date_sub：日期减天数 select date_sub(‘2020-10-28’,-4);

last_day：日期的当月的最后一天 select last_day(‘2020-02-30’);

date_format(): 格式化日期 select date_format(‘2020-10-28
12:12:12’,‘yyyy/MM/dd HH:mm:ss’);

常用取整函数 round： 四舍五入 select round(3.14); select round(3.54);

ceil： 向上取整 select ceil(3.14); select ceil(3.54);

floor： 向下取整 select floor(3.14); select floor(3.54);

常用字符串操作函数 upper： 转大写 select upper(‘low’);

lower： 转小写 select lower(‘low’);

length： 长度 select length(“atguigu”);

trim： 前后去空格 select trim(" atguigu ");

lpad： 向左补齐，到指定长度 select lpad(‘atguigu’,9,‘g’);

rpad： 向右补齐，到指定长度 select rpad(‘atguigu’,9,‘g’);

regexp_replace：使用正则表达式匹配目标字符串，匹配成功后替换！ SELECT
regexp_replace(‘2020/10/25’, ‘/’, ‘-’);

集合操作 size： 集合中元素的个数 select size(friends) from test3;

map_keys： 返回map中的key select map_keys(children) from test3;

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

array_contains: 判断array中是否包含某个元素 select
array_contains(friends,‘bingbing’) from test3;

sort_array： 将array中的元素排序 select sort_array(friends) from test3;

grouping_set:多维分析

8.3 自定义函数

1）Hive 自带了一些函数，比如：max/min 等，但是数量有限，自己可以通过自定义 UDF 来方便的扩展。
2）当 Hive 提供的内置函数无法满足你的业务处理需要时，此时就可以考虑使用用户自定义
函数（UDF：user-defined function）。
3）根据用户自定义函数类别分为以下三种：

（1）UDF（User-Defined-Function） 一进一出 （2）UDAF（User-Defined Aggregation
Function） 聚集函数，多进一出 类似于：count/max/min （3）UDTF（User-Defined
Table-Generating Functions） 一进多出 如 lateral view explode()

4）官方文档地址
https://cwiki.apache.org/confluence/display/Hive/HivePlugins
5）编程步骤：
（1）继承 Hive 提供的类
org.apache.hadoop.hive.ql.udf.generic.GenericUDF
org.apache.hadoop.hive.ql.udf.generic.GenericUDTF;
（2）实现类中的抽象方法
（3）在 hive 的命令行窗口创建函数
添加 jar

add jar linux_jar_path

创建 function

create [temporary] function [dbname.]function_name AS class_name;

（4）在 hive 的命令行窗口删除函数

drop [temporary] function [if exists] [dbname.]function_name;

8.4 自定义 UDF 函数

0）需求:
自定义一个 UDF 实现计算给定字符串的长度，
例如：
hive(default)> select my_len(“abcd”); 4 1）创建一个 Maven 工程 Hive
2）导入依赖

<dependencies>
<dependency>
<groupId>org.apache.hivegroupId>
<artifactId>hive-execartifactId>
<version>3.1.2version>
dependency>
dependencies>

3）创建一个类

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

4）打成 jar 包上传到服务器

/opt/module/data/myudf.jar

5）将 jar 包添加到 hive 的 classpath

hive (default)> add jar /opt/module/data/myudf.jar;

6）创建临时函数与开发好的 java class 关联

hive (default)> create temporary function my_len as "com.atguigu.hive.MyStringLength";

7）即可在 hql 中使用自定义的函数

hive (default)> select ename,my_len(ename) ename_len from emp;

8.5 自定义 UDTF 函数

0）需求
自定义一个 UDTF 实现将一个任意分割符的字符串切割成独立的单词，例如：

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

hello
world
hadoop
hive

1）代码实现

package com.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;
import java.util.List;
public class MyUDTF extends GenericUDTF {
 private ArrayList<String> outList = new ArrayList<>();
 @Override
 public StructObjectInspector initialize(StructObjectInspector argOIs) throws UDFArgumentException {
 //1.定义输出数据的列名和类型
 List<String> fieldNames = new ArrayList<>();
 List<ObjectInspector> fieldOIs = new ArrayList<>();
 //2.添加输出数据的列名和类型
 fieldNames.add("lineToWord");
 
fieldOIs.add(PrimitiveObjectInspectorFactory.javaStringObjectInspector);
 return 
ObjectInspectorFactory.getStandardStructObjectInspector(fieldNames, fieldOIs);
 }
 @Override
 public void process(Object[] args) throws HiveException {
 
 //1.获取原始数据
 String arg = args[0].toString();
 //2.获取数据传入的第二个参数，此处为分隔符
 String splitKey = args[1].toString();
 //3.将原始数据按照传入的分隔符进行切分
 String[] fields = arg.split(splitKey);
 //4.遍历切分后的结果，并写出
 for (String field : fields) {
 //集合为复用的，首先清空集合
 outList.clear();
 //将每一个单词添加至集合
 outList.add(field);
 //将集合内容写出
 forward(outList);
 }
 }
 @Override
 public void close() throws HiveException {
 }
  } 

2）打成 jar 包上传到服务器

/opt/module/hive/data/myudtf.jar

3）将 jar 包添加到 hive 的 classpath 下

hive (default)> add jar /opt/module/hive/data/myudtf.jar;

4）创建临时函数与开发好的 java class 关联

hive (default)> create temporary function myudtf as "com.atguigu.hive.MyUDTF";

5）使用自定义的函数

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

9. 压缩和存储

9.1 Hadoop 压缩配置

9.1.1 MR 支持的压缩编码

压缩格式	算法	文件扩展名	是否可切分
DEFLATE	DEFLATE	deflate	否
Gzip	DEFLATE	.gz	否
bzip2	bzip2	.bz2	是
LZO	LZO	.lzo	是
Snappy	Snappy	.snappy	否

为了支持多种压缩/解压缩算法，Hadoop 引入了编码/解码器，如下表所示：

压缩格式	对应的编码/解码器
DEFLATE	org.apache.hadoop.io.compress.DefaultCodec
gzip	org.apache.hadoop.io.compress.GzipCodec
bzip2	org.apache.hadoop.io.compress.BZip2Codec
LZO	com.hadoop.compression.lzo.LzopCodec
Snappy	org.apache.hadoop.io.compress.SnappyCodec

各个压缩方式压缩性能的比较：

压缩算法	原始文件大小	压缩文件大小	压缩速度	解压速度
gzip	8.3GB	1.8GB	17.5MB/s	58MB/s
bzip2	8.3GB	1.1GB	2.4MB/s	9.5MB/s
LZO	8.3GB	2.9GB	49.3MB/s	74.6MB/s

关于压缩方式诸佬们可以看看在GitHub上的文档来帮助自己学习

http://google.github.io/snappy/
On a single core of a Core i7processor in 64-bit mode, Snappy compresses at about 250 MB/sec or more and decompresses at about 500 MB/sec or more.

9.1.2 压缩参数配置

要在 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.com press	false	mapper 输出	这个参数设为 true 启用压缩
mapreduce.map.output.com press.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.fileoutput format.compress.type	RECORD	reducer 输出	SequenceFile 输出使用的压缩类型：NONE和 BLOCK

9.2 开启 Map 输出阶段压缩（MR 引擎）

开启 map 输出阶段压缩可以减少 job 中 map 和 Reduce task 间数据传输量。具体配置如下：
1）案例实操：
（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;

9.3 开启 Reduce 输出阶段压缩

当 Hive 将 输 出 写 入 到 表 中 时 ， 输出内容同样可以进行压缩。属性hive.exec.compress.output控制着这个功能。用户可能需要保持默认设置文件中的默认值false，这样默认的输出就是非压缩的纯文本文件了。用户可以通过在查询语句或执行脚本中设置这
个值为 true，来开启输出结果压缩功能。
1）案例实操：
（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/data/distribute-result' select * from emp distribute by deptno sort by empno desc;

9.4 文件存储格式

Hive 支持的存储数据的格式主要有：TEXTFILE 、SEQUENCEFILE、ORC、PARQUET。

9.4.1 列式存储和行式存储

如图所示左边为逻辑表，右边第一个为行式存储，第二个为列式存储。

1）行存储的特点 查询满足条件的一整行数据的时候，列存储则需要去每个聚集的字段找到对应的每个列的值，
行存储只需要找到其中一个值，其余的值都在相邻地方，所以此时行存储查询的速度更快。
2）列存储的特点
因为每个字段的数据聚集存储，在查询只需要少数几个字段的时候，能大大减少读取的数据量；
每个字段的数据类型一定是相同的，列式存储可以针对性的设计更好的设计压缩算法。 TEXTFILE 和 SEQUENCEFILE
的存储格式都是基于行存储的； ORC 和 PARQUET 是基于列式存储的。

9.4.2 TextFile 格式

默认格式，数据不做压缩，磁盘开销大，数据解析开销大。可结合 Gzip、Bzip2 使用， 但使用 Gzip 这种方式，
hive不会对数据进行切分，从而无法对数据进行并行操作。

9.4.3 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，即从后 往前读。

9.4.4 Parquet 格式

Parquet 文件是以二进制方式存储的，所以是不可以直接读取的，文件中包括该文件的
数据和元数据，因此 Parquet 格式文件是自解析的。

（1）行组(Row Group)：每一个行组包含一定的行数，在一个 HDFS 文件中至少存储一 个行组，类似于 orc 的 stripe 的概念。
（2）列块(Column Chunk)：在一个行组中每一列保存在一个列块中，行组中的所有列连续的存储在这个行组文件中。一个列块中的值都是相同类型的，不同的列块可能使用不同的 算法进行压缩。
（3）页(Page)：每一个列块划分为多个页，一个页是最小的编码的单位，在同一个列块 的不同页可能使用不同的编码方式。 通常情况下，在存储Parquet 数据的时候会按照 Block 大小设置行组的大小，由于一般 情况下每一个 Mapper 任务处理数据的最小单位是一Block，这样可以把每一个行组由一 个 Mapper 任务处理，增大任务执行并行度。Parquet 文件的格式。

上图展示了一个 Parquet 文件的内容，一个文件中可以存储多个行组，文件的首位都是该文件的 Magic Code，用于校验它是否是一个 Parquet 文件，Footer length 记录了文件元数据的大小，通过该值和文件长度可以计算出元数据的偏移量，文件的元数据中包括每一个行
组的元数据信息和该文件存储数据的 Schema 信息。除了文件中每一个行组的元数据，每一页的开始都会存储该页的元数据，在 Parquet 中，有三种类型的页：数据页、字典页和索引页。数据页用于存储当前行组中该列的值，字典页存储该列值的编码字典，每一个列块中最
多包含一个字典页，索引页用来存储当前行组下该列的索引，目前 Parquet 中还不支持索引页。

9.4.5 主流文件存储格式对比实验

从存储文件的压缩比和查询速度两个角度对比。

存储文件的压缩比测试：
1）测试数据
2）TextFile
（1）创建表，存储数据格式为 TEXTFILE

create table log_text (
track_time string,
url string,
session_id string,
referer string,
ip string,
end_user_id string,
city_id string
)
row format delimited fields terminated by '\t'
stored as textfile;

（2）向表中加载数据

hive (default)> load data local inpath '/opt/module/hive/datas/log.data' into table log_text ;

（3）查看表中数据大小

hive (default)> dfs -du -h /user/hive/warehouse/log_text;
18.13 M /user/hive/warehouse/log_text/log.data

3）ORC
（1）创建表，存储数据格式为 ORC

create table log_orc(
track_time string,
url string,
session_id string,
referer string,
ip string,
log.data
end_user_id string,
city_id string
)
row format delimited fields terminated by '\t'
stored as orc
tblproperties("orc.compress"="NONE"); -- 设置 orc 存储不使用压缩

（2）向表中加载数据

hive (default)> insert into table log_orc select * from log_text;

（3）查看表中数据大小

hive (default)> dfs -du -h /user/hive/warehouse/log_orc/ ;
7.7 M /user/hive/warehouse/log_orc/000000_0

4）Parquet
（1）创建表，存储数据格式为 parquet

create table log_parquet(
track_time string,
url string,
session_id string,
referer string,
ip string,
end_user_id string,
city_id string
)
row format delimited fields terminated by '\t'
stored as parquet;

（2）向表中加载数据

hive (default)> insert into table log_parquet select * from log_text;

（3）查看表中数据大小

hive (default)> dfs -du -h /user/hive/warehouse/log_parquet/;
13.1 M /user/hive/warehouse/log_parquet/000000_0

存储文件的对比总结：

ORC > Parquet > textFile

存储文件的查询速度测试：
（1）TextFile

hive (default)> insert overwrite local directory '/opt/module/data/log_text' select substring(url,1,4) from log_text;

（2）ORC

hive (default)> insert overwrite local directory '/opt/module/data/log_orc' select substring(url,1,4) from log_orc;

（3）Parquet

hive (default)> insert overwrite local directory '/opt/module/data/log_parquet' select substring(url,1,4) from log_parquet;

存储文件的查询速度总结：查询速度相近。

9.5 存储和压缩结合

9.5.1 测试存储和压缩

官网：https://cwiki.apache.org/confluence/display/Hive/LanguageManual+ORC
ORC 存储方式的压缩：

Key Default Notes orc.compress ZLIB high level compression (one of NONE, ZLIB, SNAPPY) orc.compress.size 262,144 number of bytes in each compression chunk orc.stripe.size 268,435,456 number of bytes in each stripe orc.row.index.stride 10,000 number of rows between index entries (must be >= 1000) orc.create.index true whether to create row indexes orc.bloom.filter.columns “” comma separated list of column names for which bloom filter should be created orc.bloom.filter.fpp 0.05 false positive probability for bloom filter (must >0.0 and <1.0)

注意：所有关于 ORCFile 的参数都是在 HQL 语句的 TBLPROPERTIES 字段里面出现
1）创建一个 ZLIB 压缩的 ORC 存储方式
（1）建表语句

create table log_orc_zlib(
track_time string,
url string,
session_id string,
referer string,
ip string,
end_user_id string,
city_id string
)
row format delimited fields terminated by '\t'
stored as orc
tblproperties("orc.compress"="ZLIB");

（2）插入数据

insert into log_orc_zlib select * from log_text;

（3）查看插入后数据

hive (default)> dfs -du -h /user/hive/warehouse/log_orc_zlib/ ;
2.78 M /user/hive/warehouse/log_orc_none/000000_0 

2）创建一个 SNAPPY 压缩的 ORC 存储方式
（1）建表语句

create table log_orc_snappy(
track_time string,
url string,
session_id string,
referer string,
ip string,
end_user_id string,
city_id string
)
row format delimited fields terminated by '\t'
stored as orc
tblproperties("orc.compress"="SNAPPY");

（2）插入数据

insert into log_orc_snappy select * from log_text;

（3）查看插入后数据

hive (default)> dfs -du -h /user/hive/warehouse/log_orc_snappy/;
3.75 M /user/hive/warehouse/log_orc_snappy/000000_0

ZLIB 比 Snappy 压缩的还小。原因是 ZLIB 采用的是 deflate 压缩算法。比 snappy 压缩的压缩率高。

3）创建一个 SNAPPY 压缩的 parquet 存储方式
（1）建表语句

create table log_parquet_snappy(
track_time string,
url string,
session_id string,
referer string,
ip string,
end_user_id string,
city_id string
)
row format delimited fields terminated by '\t'
stored as parquet
tblproperties("parquet.compression"="SNAPPY");

（2）插入数据

insert into log_parquet_snappy select * from log_text;

（3）查看插入后数据

hive (default)> dfs -du -h /user/hive/warehouse/log_parquet_snappy/;
6.39 MB /user/hive/warehouse/ log_parquet_snappy /000000_0

4）存储方式和压缩总结

在实际的项目开发当中，hive 表的数据存储格式一般选择：orc 或 parquet。压缩方式一般选择 snappy，lzo。

到此Hive的基础知识番薯就更新完啦，下面给佬们总结些面试题，不喜勿喷撒。感谢大家支持

Hive常见的一些面试题

Hive 中的压缩格式TextFile、SequenceFile、RCfile 、ORCfile各有什么区别？

1、TextFile
默认格式，存储方式为行存储，数据不做压缩，磁盘开销大，数据解析开销大。可结合Gzip、Bzip2使用(系统自动检查，执行查询时自动解压)，但使用这种方式，压缩后的文件不支持split，Hive不会对数据进行切分，从而无法对数据进行并行操作。并且在反序列化过程中，必须逐个字符判断是不是分隔符和行结束符，因此反序列化开销会比SequenceFile高几十倍。
2、SequenceFile SequenceFile是Hadoop
API提供的一种二进制文件支持，存储方式为行存储，其具有使用方便、可分割、可压缩的特点。
SequenceFile支持三种压缩选择：NONE，RECORD，BLOCK。Record压缩率低，一般建议使用BLOCK压缩。
优势是文件和hadoop api中的MapFile是相互兼容的
3、RCFile
存储方式：数据按行分块，每块按列存储。结合了行存储和列存储的优点： 首先，RCFile
保证同一行的数据位于同一节点，因此元组重构的开销很低； 其次，像列存储一样，RCFile
能够利用列维度的数据压缩，并且能跳过不必要的列读取；
4、ORCFile 存储方式：数据按行分块 每块按照列存储。 压缩快、快速列存取。
效率比rcfile高，是rcfile的改良版本。
小结：
相比TEXTFILE和SEQUENCEFILE，RCFILE由于列式存储方式，数据加载时性能消耗较大，但是具有较好的压缩比和查询响应。
数据仓库的特点是一次写入、多次读取，因此，整体来看，RCFILE相比其余两种格式具有较明显的优势。

hive内部表和外部表的区别

未被external修饰的是内部表，被external修饰的为外部表。 区别: 内部表数据由Hive自身管理，外部表数据由HDFS管理；
内部表数据存储的位置是hive.metastore.warehouse.dir（默认：/user/hive/warehouse）
外部表数据的存储位置由自己制定（如果没有LOCATION，Hive将在HDFS上的/user/hive/warehouse文件夹下以外部表的表名创建一个文件夹，并将属于这个表的数据存放在这里）；
删除内部表会直接删除元数据（metadata）及存储数据；删除外部表仅仅会删除元数据，HDFS上的文件并不会

为什么要对数据仓库分层

用空间换时间，通过大量的预处理来提升应用系统的用户体验（效率），因此数据仓库会 存在大量冗余的数据。
如果不分层的话，如果源业务系统的业务规则发生变化将会影响整个数据清洗过程，工作量巨大。
通过数据分层管理可以简化数据清洗的过程，因为把原来一步的工作分到了多个步骤去完成，相当于把一个复杂的工作拆成了多个简单的工作，把一个大的黑盒变成了一个白盒，每一层的处理逻辑都相对简单和容易理解，这样我们比较容易保证每一个步骤的正确性，当数据发生错误的时候，往往我们只需要局部调整某个步骤即可。

sort by 和 order by 的区别

order by
会对输入做全局排序，因此只有一个reducer（多个reducer无法保证全局有序）只有一个reducer，会导致当输入规模较大时，需要较长的计算时间。
sort by不是全局排序，其在数据进入reducer前完成排序. 因此，如果用sort by进行排序，并且设置mapred.reduce.tasks>1， 则sort by只保证每个reducer的输出有序，不保证全局有序。

Hive 小文件过多怎么解决

使用 hive 自带的 concatenate 命令，自动合并小文件 调整参数减少Map数量 减少Reduce的数量
使用hadoop的archive将小文件归档

Hive优化有哪些

数据存储及压缩 通过调参优化 有效地减小数据集将大表拆分成子表；结合使用外部表和分区表 SQL优化

Hive的数据倾斜都有哪些？如何解决Hive的数据倾斜问题？

数据倾斜怎么解决

空值引发的数据倾斜
解决方案：
第一种：可以直接不让null值参与join操作，即不让null值有shuffle阶段

select * from log a join users b on o.user_id = b.user_id
union all select * from log o where a. user_id is null;

第二种：因为null值参与shuffle时的hash结果是一样的，那么我们可以给null值随机赋值，这样它们的hash结果就不一样，就会进到不同的reduce中：

select * from log o left join users b on 
case
when a.user_id is null then concat('hive_',rand())
else a.user_id 
end = b.user_id;

不同数据类型引发的数据倾斜
解决方案：
如果key字段既有string类型也有int类型，默认的hash就都会按int类型来分配，那我们直接把int类型都转为string就好了，这样key字段都为string，hash时就按照string类型分配了：

select * from users a left join logs b on a.user_id = cast(b.user_id as string);

不可拆分大文件引发的数据倾斜

解决方案： 这种数据倾斜问题没有什么好的解决方案，只能将使用GZIP压缩等不支持文件分割的文件转为bzip和zip等支持文件分割的压缩方式。
所以，我们在对文件进行压缩时，为避免因不可拆分大文件而引发数据读取的倾斜，在数据压缩的时候可以采用bzip2和Zip等支持文件分割的压缩算法。

数据膨胀引发的数据倾斜
解决方案：

在Hive中可以通过参数 hive.new.job.grouping.set.cardinality
配置的方式自动控制作业的拆解，该参数默认值是30。表示针对grouping
sets/rollups/cubes这类多维聚合的操作，如果最后拆解的键组合大于该值，会启用新的任务去处理大于该值之外的组合。如果在处理数据时，某个分组聚合的列有较大的倾斜，可以适当调小该值。

表连接时引发的数据倾斜
解决方案：

通常做法是将倾斜的数据存到分布式缓存中，分发到各个Map任务所在节点。在Map阶段完成join操作，即MapJoin，这避免了
Shuffle，从而避免了数据倾斜。

确实无法减少数据量引发的数据倾斜
解决方案：

这类问题最直接的方式就是调整reduce所执行的内存大小。
调整reduce的内存大小使用mapreduce.reduce.memory.mb这个配置。

Hive表关联查询，如何解决数据倾斜的问题？

1）倾斜原因
map输出数据按key Hash的分配到reduce中，由于key分布不均匀、业务数据本身的特、建表时考虑不周、等原因造成的reduce 上的数据量差异过大

（1）key分布不均匀
（2）业务数据本身的特性
（3）建表时考虑不周
（4）某些SQL语句本身就有数据倾斜
如何避免：对于key为空产生的数据倾斜，可以对其赋予一个随机值

2）解决方案
（1）参数调节：

 hive.map.aggr = true  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中），最后完成最终的聚合操作
（2）SQL 语句调节：

① 选用join key分布最均匀的表作为驱动表。做好列裁剪和filter操作，以达到两表做join 的时候，数据量相对变小的效果
②大小表Join： 使用map join让小的维度表（1000 条以下的记录条数）先进内存。在map端完成reduce
③ 大表join大表：把空值的key变成一个字符串加上随机数，把倾斜的数据分到不同的reduce上，由于null 值关联不上，处理后并不影响最终结果
④count distinct大量相同特殊值: count distinct 时，将值为空的情况单独处理，如果是计算count distinct，可以不用处理，直接过滤，在最后结果中加1。如果还有其他计算，需要进行group by，可以先将值为空的记录单独处理，再和其他计算结果进行union

请说明hive中 Sort By，Order By，Cluster By，Distrbute By各代表什么意思？

order by：会对输入做全局排序，因此只有一个reducer（多个reducer无法保证全局有序）。只有一个reducer，会导致当输入规模较大时，需要较长的计算时间
sort by：不是全局排序，其在数据进入reducer前完成排序
distribute by：按照指定的字段对数据进行划分输出到不同的reduce中
cluster by：除了具有 distribute by 的功能外还兼具 sort by 的功能

写出hive中split、coalesce及collect_list函数的用法（可举例）？

split将字符串转化为数组，即：split(‘a,b,c,d’ , ‘,’) ==> [“a”,“b”,“c”,“d”]
coalesce(T v1, T v2, …) 返回参数中的第一个非空值；如果所有值都为 NULL，那么返回NULL

Hive有哪些方式保存元数据，各有哪些特点？

Hive支持三种不同的元存储服务器，分别为：内嵌式元存储服务器、本地元存储服务器、远程元存储服务器，每种存储方式使用不同的配置参数
内嵌式元存储主要用于单元测试，在该模式下每次只有一个进程可以连接到元存储，Derby是内嵌式元存储的默认数据库
在本地模式下，每个Hive客户端都会打开到数据存储的连接并在该连接上请求SQL查询
在远程模式下，所有的Hive客户端都将打开一个到元数据服务器的连接，该服务器依次查询元数据，元数据服务器和客户端之间使用Thrift协议通信

表的优化

小表、大表join

将key相对分散，并且数据量小的表放在join的左边，这样可以有效减少内存溢出错误发生的几率；再进一步，可以使用Group让小的维度表（1000条以下的记录条数）先进内存。在map端完成reduce

实际测试发现：新版的hive已经对小表JOIN大表和大表JOIN小表进行了优化。小表放在左边和右边已经没有明显区别

大表Join小表

1）空KEY过滤

有时join超时是因为某些key对应的数据太多，而相同key对应的数据都会发送到相同的reducer上，从而导致内存不够。此时我们应该仔细分析这些异常的key，很多情况下，这些key对应的数据是异常数据，我们需要在SQL语句中进行过滤。例如key对应的字段为空

Group By

默认情况下，Map阶段同一Key数据分发给一个reduce，当一个key数据过大时就倾斜了

并不是所有的聚合操作都需要在Reduce端完成，很多聚合操作都可以先在Map端进行部分聚合，最后在Reduce端得出最终结果

1）开启Map端聚合参数设置
（1）是否在Map端进行聚合，默认为True

 hive.map.aggr = true

（2）在Map端进行聚合操作的条目数目

 hive.groupby.mapaggr.checkinterval = 100000 

（3）有数据倾斜的时候进行负载均衡（默认是false）

 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) 去重统计

数据量小的时候无所谓，数据量大的情况下，由于COUNT DISTINCT操作需要用一个Reduce Task来完成，这一个Reduce需要处理的数据量太大，就会导致整个Job很难完成，一般COUNT DISTINCT使用先GROUP BY再COUNT的方式替换

笛卡尔积

尽量避免笛卡尔积，join的时候不加on条件，或者无效的on条件，Hive只能使用1个reducer来完成笛卡尔积

行列过滤

列处理：在SELECT中，只拿需要的列，如果有，尽量使用分区过滤，少用SELECT *。
行处理：在分区剪裁中，当使用外关联时，如果将副表的过滤条件写在Where后面，那么就会先全表关联，之后再过滤

关于Hive的知识点先更新这些拉,等小弟以后面试会积累一下面经分享给大家的,如果是做数仓开发,Hive一定会被问到,毕竟Hive是支撑数仓体系的一个小工具撒…