Fetch获取

• Fetch抓取：Hibe中某些情况查询可以不必使用MapReuce计算。
• 在 hive-default.xml.template 文件中 hive.fetch.task.conversion 默认是 more,老版本命令是minimal，改属性修改为more以后，在全局查找、字段查找、limit查找等都不走mapreduce。

  <property><name>hive.fetch.task.conversion</name><value>more</value><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 haveany aggregations or distincts (which incurs RS), lateral views and joins.0. none : disable hive.fetch.task.conversion1. minimal : SELECT STAR, FILTER on partition columns, LIMIT only2. more    : SELECT, FILTER, LIMIT only (support TABLESAMPLE and virtual columns)</description></property>

-- 查询代码
select count(*)
from week12_day06_day02.t_movieRate;--hive.fetch.task.conversion 设置为more
--用时：1 row retrieved starting from 1 in 19 s 584 ms (execution: 19 s 542 ms, fetching: 42 ms)
--hive.fetch.task.conversion 设置为minimal
--用时：1 row retrieved starting from 1 in 23 s 335 ms (execution: 23 s 274 ms, fetching: 61 ms)

本地模式

• 大多数的Hadoop Job是需要Hadoop提供完整的可扩展来处理大数据集的。不过时Hive的输入数据量是非常小的。在这种情况下，为查询触发执行任务消耗的时候可以会比实际Job的执行实际要多的多。对于大多数这种情况，Hive可以通过本地模式在单台机器上处理所有的任务。对小数据集，执行时间可以明显被缩短。

-- 查询代码
select count(*)
from week12_day06_day02.t_movieRate;--set hive.exec.mode.local.auto=true; --开启本地 mr
--用时：1 row retrieved starting from 1 in 1 s 406 ms (execution: 1 s 355 ms, fetching: 51 ms)
--set hive.exec.mode.local.auto=false; --关闭本地 mr
--用时： 1 row retrieved starting from 1 in 19 s 479 ms (execution: 19 s 429 ms, fetching: 50 ms

表优化

• 小表Join大表

1. 实际测试发现：新版的Hive以及对小表join大表和大表join小表进行了优化，小表放在左边和右边以及没用明显区别；

大表join小表

1、第一种方法：查询之前，过滤Null

select n.* from (select * from nullidtable where id is not null) n left join bigtable o on n.id = o.id;

2、第二中方法：给Null的赋值

需要避免实际倾斜，所有使用rand（）；

select n.* from nullidtable n full join bigtable o on case when n.id is null then concat('hive', rand()) else n.id end = o.id;

1. MapJoin
   • 如果不指定MapJoin或者不符合MapJoin的条件，那么Hive解析器会将Join操作转换成CommonJoin，即：在Reduce阶段完成join，容易发生数据倾斜。可以用MapJoin把小表全部加载到内存，在map端进行join，避免reduce处理。
   • 开启MapJoin参数设置：

开启自动选择MapJoin：set hive.auto.convert.join=true,默认为true;

set hive.auto.convert.join=true;

设置大表小表的阀值（默认25M一下是小表）：

set hive.mapjoin.smalltable.filesize=25000000;

1. Group By
   1. 默认情况下,Map 阶段同一 Key 数据分发给一个 reduce,当一个 key 数据过大时,就可能发生数据倾斜;
   2. 并不是所有的聚合操作都需要在 Reduce 端完成,很多聚合操作都可以现在 Map 端进行部分聚合,最后在 Reduce 端得出最终结果。
   3. 开启 Map 端聚合参数设置:

1、是否在 Map 端进行聚合,默认为true：

set hive.map.aggr=true;

2、在 Map 端进行聚合操作的条目数目:

set hive.groupby.mapaggr.checkinterval=100000;

3、有数据倾斜的时候，进行负载均衡：

set hive.groupby.skewindata=true;

1. Count（Distinct）去重统计
   1. 数据量大的情况下,由于 COUNT DISTINCT 操作需要用一个Reduce Task 来完成,这一个 Reduce 需要处理的数据量太大,就会导致整个 Job 很难完成,一般 COUNT DISTINCT 使用时,先 GROUP BY 再 COUNT 的方式替换;
2. 动态分布调整
   1. 关系型数据库中,对分区表Insert数据的时候,数据库自动会根据分区字段的值,将数据插入到相应的分区中,Hive 中也提供了类似的机制,即动态分区(Dynamic Partition);
   2. 开启动态分区参数设置:

1、开启动态分区功能,默认为true:

set hive.exec.dynamic.partition=true;

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

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

3、在所有执行 MR 的节点上,最大一共可以创建多少个动态分区:

set hive.exec.max.dynamic.partitions=1000;

4、整个 MR Job中,最大可以创建多少个HDFS文件:

set hive.exec.max.created.files=100000;

5、当有空分区生成时,是否抛出异常:

set hive.error.on.empty.partition=false;

1. 笛卡尔积
   1. 不使用笛卡尔积
2. 行列过滤
   1. 禁止使用 SELECT *

合理设置MapReduce数量

1. 对分区表Insert数据时候，数据库自动会根据分区字段的值，将数据插入到相应的分区中，即动态分区

-- 开启动态分区功能
set hive.exec.dynamic.partition=true;
-- 设置为非严格模式
set hive.exec.dynamic.partition.mode=nonstrict;
-- 在所有执行MR的节点上，最大一共可以创建多少个动态分区，默认1000
set hive.exec.max.dynamic.partitions=1000;
-- 在每个执行MR的节点上，最大可以创建多少个动态分区，该参数需要根据实际的数据来设定
set hive.exec.max.dynamic.partitions.pernode=100;
-- 整个MR Job中，最大可以创建多少个HDFS文件，默认100000
set hive.exec.max.created.files=100000;
-- 当有空分区生成时，是否抛出异常。一般不需要设置
set hive.error.on.empty.partition=false;

并行执行

1. Hive 会将一个查询转化成一个或者多个阶段，这样的阶段可以是 MapReduce 阶段、抽样阶段、合并阶段、limit 阶段，或者 Hive 执行过程中可能需要的其他阶段，默认情况下，Hive 一次只会执行一个阶段，不过，某个特定的 job 可能包含众多的阶段，而这些阶段可能并非完全互相依赖的，也就是说有些阶段是可以并行执行的，这样可能使得整个 job 的执行时间缩短。不过，如果有更多的阶段可以并行执行，那么 job 可能就越快完成。
2. 通过设置参数 hive.exec.parallel 值为 true，就可以开启并发执行。不过，在共享集群中，需要注意下，如果 job 中并行阶段增多，那么集群利用率就会增加。

严格模式

1. Hive 提供了一个严格模式，可以防止用户执行那些可能意想不到的不好的影响的查询
2. 开启严格模式需要修改 hive.mapred.mode 值为 strict，开启严格模式可以禁止 种类型的查询：
   1. 对于分区表，除非where语句中含有分区字段过滤条件来限制范围，否则不允许执行
   2. 对于使用了order by语句的查询，要求必须使用limit语句
   3. 限制笛卡尔积的查询

JVM重用

1. JVM 重用是 Hadoop 调优参数的内容，其对 Hive 的性能具有非常大的影响，特别是对于很难避免小文件的场景或 task 特别多的场景，这类场景大多数执行时间都很短。
2. Hadoop 的默认配置通常是使用派生来执行和任务的，这时的启动过程可能会造成相当大的开销，尤其是执行的包含有成百上千任务的情况。
3. 重用可以使得实例在同一个中重新使用多次。
4. 需要在 Hadoop 的 mapred-site.xml 中配置，但是有个缺点是重用次数过大，会产生大量的垃圾

  <property><name>mapreduce.job.jvm.numtasks</name><value>10</value><description>How many tasks to run per jvm. If set to -1, there isno limit. </description></property>

推测执行

1. 如果用户因为输入数据量很大而需要执行长时间的 Map 或者 Reduce Task 的话，那么启动推测执行造成的浪费是非常巨大大

Hive优化总结

1. hadoop处理数据的过程，有几个显著的特征：
   1. 不怕数据多，就怕数据倾斜
   2. 对jobs数比较多的作业运行效率相对比较低，比如即使有几百行的表，如果多次关联多次汇总，产生十几个jobs，没半个雄安是是跑不完的。map reudce作业的初始化是比较长的。
   3. 对sum，count来说，不存在数据倾斜问题。
   4. 对count（distinct），效率较低，数据量一多，准出问题，如果是多count（distinct）效率更低。
2. 优化可以从几个方面着手
   1. 好的模型设计事半功倍
   2. 解决数据倾斜问题
   3. 较少job数
   4. 设置合理的map reduce的task数，能有效提升性能。（比如，10W+级别的计算，用160个reduce，那么相当的浪费，1个足够）
   5. 自己动手写sql解决数据倾斜问题是不错的选择。set hive.troupby.skewindata=true；这是通用的算法优化，当算法优化中是漠视业务，习惯性提供通用的解决哈哈，。Eti开发人员更了解业委，更了解数据，所以通过业委逻辑解决倾斜的方法往往更精确，更有效。
   6. 对count（distinct）采取漠视的方法，尤其数据大的算法分容易产生倾斜问题，不抱侥幸心理。自己动手，丰衣足食。
   7. 对小文件进行合并，是行至有效的提高调度效率的方法。加入我们的作业设置合理的文件数，对云梯的整体调度效率也会产生积极的影响。