[hadoop hive] hive总结

1、表操作

建表（建表时需要注意前面不要添加空格回车之类的内容，防止各种异常）
create table if not exists employees(
name string,
salary float,
subordinates array<string>,
deductions map<string,float>,
address struct<street:string,city:string,state:string,zip:int>
)
row format delimited fields terminated by '\t'
collection items terminated by ','
map keys terminated by ':'
lines terminated by '\n'
stored as textfile
location '/data/';


查看建表语句(经测试，hive0.9不支持下面的查看建表语句，hive0.14支持)
show create table employees;


格式化查看表结构
desc formatted employees;
如果需要查看详细信息，也可以使用desc employees;


删除表：drop table employees;
显示表：show tables;
显示数据库：show databases;
使用默认的数据库：use default;


表内容：
wang 123 a1,a2,a3 k1:1,k2:2,k3:3 s1,s2,s3,4
li 235 a4,a5,a6 k4:4,k5:5,k6:6 s4,s5,s6,9
zhao 878 b1,b2,b3 q1:1,q2:2,q3:3 f1,f2,f3,4


加载数据(从本地加载需要使用local，否则需要先将数据加载到hdfs中)
load data local inpath '/usr/local/opt/data/mydata' overwrite into table employees;


数据查询（查询数组、Map、struct中的内容）
select name,subordinates[0],deductions["k1"],address.city from employees;


根据一个表创建另外一张表
create table test1 like employees;
create table test2 as select name,address from employees;


hive不同文件读取对比
stored as textfile
①直接查看hdfs
②hadoop fs -text
stored as sequencefile
①hadoop fs -text
stored as rcfile
①hive -service rcfilecat path
stored as inputformat 'class'
①outformat 'class'

2、hive自定义jar包加载

方法一：将jar包copy到hive的lib目录下，然后重启客户端；
方法二：在hive客户端命令行中使用：add jar PATH;

3、分区表(创建表时所有的注释都要删除，否则创建表时会报错)

create table if not exists employees_c(
name string,
salary float,
subordinates array<string>,
deductions map<string,float>,
address struct<street:string,city:string,state:string,zip:int>
)
partitioned by (country string,date string)//添加分区说明信息
row format delimited fields terminated by '\t'
collection items terminated by ','
map keys terminated by ':'
lines terminated by '\n'
stored as textfile
location '/data/';
对于已经创建完成的表添加分区信息
alter table employees add if not exists partition(country="cn",date="20150502")
对于已经存在表分区信息的表删除分区
alter table employees drop if exists partition(country="cn",date="20150502");
查看分区信息
show partitions employees;

4、桶表

create table bucketed_user(
id int,
name string
)
//按照Id进行聚集，按照name进行排序，放到4个桶里面
clustered by (id) sorted by (name) into 4 buckets
stored as textfile;


如果想要使桶表生效，先要执行如下命令，或者修改配置文件：
set hive.enforce.bucketing=true;


导入数据(直接使用load data不能将数据加载成桶表的格式)
insert overwrite table bucketed_user select sname,saddr from test1;


简单查询
select * from bucketed_user where id = 'a'

5、hive -help下的命令

hive -e "select * from user_table;"
这可以在Shell脚本中使用，不进入hive cli获取hive的查询结果,也可以使用hive -f sqlfilePath打到
同样的效果
hive -v  -f a.txt > ./res.txt
-v保存到文件时同时会将sql语句打印到res.txt中

在hive cli中可以使用如下命令：
list jar; list file;//列出加载到hadoop集群缓存中的jar包和文件
source "/usr/local/opt/sql/hive_sql" //在命令行方式中执行HQL

6、hive变量

set val='';//设置变量
${hiveconf:val} //读取变量
环境变量 ${env:HOME},其中env是查看所有环境变量
在hive cli中使用
set val="test";
select * from employees where name=${hiveconf:val};
select ${env:HOME} from employees;

7、数据加载

内表数据加载
①创建表是加载
 create table newTable as select col1,col2 from oldTable
②创建表时指定数据位置
 create table tableName(...) location ''
③本地数据加载
 load data local inpath 'localPath' [overwrite] into table tableName
 注意：如果添加上overwrite表示覆盖重写，也就是删除原有数据，然后加载新数据
④加载HDFS数据
 load data inpath 'hdfsPath' [overwrite] into table tableName
 注意：加载HDFS数据操作是移动数据，不是复制数据
⑤还可以使用hadoop命令拷贝数据到指定位置（可以在hive的Shell中执行和Linux的Shell中执行）
 在command中执行hadoop fs -copyFromLocal localPath hiveTablePath
 然后再hive中查询就可以看到数据已经被加载了。
     
     实际上Hadoop命令也可以在hive命令行中运行，可以使用dfs -ls /;所以上面的命令也可以使用
     hive > dfs -copyFromLocal localPath hiveTablePath
⑥由查询语句加载数据
 insert [into|overwrite] table tableName
 selelct col1,col2
 from table 
 where ...
 方法二：
 from table
 insert [into|overwrite] table tableName
 select col1,col2
 where ...
 
 注意：字段对应不同于一些关系型数据库，是按照顺序进行对应，而不是名称 

   外表数据加载
    ①创建表时指定数据位置
    create external table tableName(...) location '..'
    ②查询加载和使用Shell操作同内表操作
   
   分区表数据加载：
    内部分区表数据加载方式类似于内表
    外部分区表数据加载方式类似于外表
    注意：数据存放的路径层次要和表的分区一致
    如果分区表没有新增分区，即使目标路径下已经有数据了，但依然查不到数据
    区别：加载数据指定目标表的同时，需要指定分区
    加载数据时添加了partition
    eg:   load data local inpath 'linuxPath' overwrite into table tableName partition (pn='')
    insert into table tableName partition (pn='') select col1,col2 from tableName2
   
   hive数据加载需要注意的问题
   ①分隔符的问题，并且分隔符默认只有单个字符
   ②数据类型对应问题
    load数据，字段类型不能相互转化时，查询返回NULL
    select查询插入，字段类型不能相互转化时，插入数据为NULL
   ③select查询插入数据，字段值顺序要与表中字段顺序一致，名称可以不一致
    hive在数据加载时不做检查，查询时检查
   ④外部分区表需要添加分区才能看到数据  
   

8、可以在hive的Shell中使用hadoop命令/linux shell命令

hive> dfs -copyFromLocal /usr/local/opt/data1 /data;
dfs -ls /;
其他类似
使用Linux Shell命令（前面添加!）
eg: !ls /usr/local/;

9、hive数据导出

①hadoop命令
get eg:hadoop fs  -get hdfsPath linuxPath(hadoop fs -get /data/* /usr/local/opt/my/data/)
text eg: hadoop fs -text hdfsPath > file
②通过insert。。directory方式
insert overwrite [local] directory '/linuxPath' [row format delimited fields terminated by '\t']
select name,salary,addr from employees;
如果不使用local，那么后面row format..这一句也就不支持
③Shell命令加管道： hive -f/e|sed/grep/awk > file
④第三方工具（sqoop）

10、hive动态分区

参数说明：
①set hive.exec.dynamic.partition=true;//使用动态分区
②set hive.exec.dynamic.partition.mode=nonstrict|strict;//nonstrict无限制模式，
 如果模式是strict,则必须有一个静态分区，且放在最前面
③set hive.exec.max.dynamic.partitions.pernode=10000;//每个
 节点生成动态分区的最大个数
④set hive.exec.max.dynamic.partitions=100000;//生成动态分区的最大个数
⑤set hive.exec.max.created.files=1500000;//一个任务最多可以创建的文件数目
⑥set hive.datanode.max.xcievers=8192;//限定一次最多打开的文件数

建议一个表一天产生的分区不要超过1000个，防止MySQL出现问题
hql:insert overwrite table dy_partition_table partition(分区字段（splitName）)
select name,addr as splitName from oldTable;

11、表属性的操作

修改表名称
alter table tableName rename to newTableName;
修改列名
alter table tableName change column c1 c2 int comment '..' after severity;
//默认放在最后，通过after可以把该列放在指定列的后面或者使用'first'放到第一位
eg: alter table employee change column type type string  after address; 
alter table employee change column type type string  first; 
增加列
alter table tableName add columns(c1 string comment '..',c2 long comment 'xx');
修改tblproperties
alter table tableName set tblproperties(property_name=property_value,property_name=property_value,...);
针对无分区表与有分区表不同
无分区表（修改字段内容分隔符）
alter table tableName set serdeproperties('field.delim'='\t');
注意：会导致之前存在的分区无法应用新修改的属性
有分区表（修改字段内容分隔符）
alter table test1 partition(dt='xx') set serdeproperties('field.delim'='\t');
修改location
alter table tableName [partition()] set location 'path'
内部表转外部表
alter table tableName set tblproperties('EXTERNAL'='TRUE');
外部表转内部表
alter table tableName set tblproperties('EXTERNAL'='FALSE');
可以在wiki：LanguageManual DDL中查看hive修改表操作
动态分区：
set hive.exec.dynamic.partition=true;//开启动态分区
如果set hive.exec.dynamic.partition.mode=nonstrict;
那么插入动态分区数据时可以不使用静态分区

eg:insert overwrite table test_part partition(dt,value)
select 'abc' as name,createDate as dt, addr as value from testext;
如果set hive.exec.dynamic.partition.mode=strict;
那么插入动态分区数据时，至少第一个分区是静态分区
eg:insert overwrite table test_part partition(dt='20150505',value)
select 'abc' as name, addr as value from testext;

12、hive高级查询

聚合操作
1)count计数
count(*) count(1) count(col)
count(*)如果一行中的所有值都为NULL，那么count(*)不加一
count(1)对于上面的这种情况，count（1）也会加一
2)sum求和
sum(可以转成数字的值)返回bigint
sum(col)+cast(1 as bigint)//总数加一
3)avg求平均值
avg(可以转成数字的值)返回double
4)distinct去重
count(distinct col)
Order by
select col1,col2, from test where condition order by col1,col2 [asc|desc]
注意：order by 后面可以有多列进行排序，默认按照字典排序
order by 为全局排序
order by 需要reduce操作，并且只有一个reduce，与配置无关
group by 
按照某些字段的值进行分组，将相同的值放在一起
select col1[,col2],count(1),sel_expr(聚合操作) from table where condition
group by col1[,col2] [having]
注意：select后面非聚合列必须出现在group by中
除去普通列就是一些聚合操作
group by 后面也可以跟表达式,比如substr(col)
特性：使用了reduce操作，受限于reduce数量，设置reduce参数：set mapred.reduce.tasks=5;
输出文件个数与reduce数相同，文件大小与reduce处理的数据量有关
问题：网络负载过重
数据倾斜，优化参数：set hive.groupby.skewindata=true;
join
两个表m,n之间按照on条件进行连接，m中的一条记录和n中的一条记录组成一条新的记录
join：等值连接，需要某个值在m和n中同时存在
left outer join:左外连接，左边表中的无论是否在右边表中存在时，都输出，右边表的值只有在左边表
中存在时才输出
right outer join:右外连接，和left outer join 相反
left semi join ：类似于exists
mapjoin:在Map端完成join操作，不需要使用reduce，基于内存做join，属于优化操作
说明：在Map端把小表加载到内存中，然后读取大表，和内存中的小表完成连接操作
其中使用了分布式缓存技术
优缺点：不消耗集群的reduce资源（reduce资源相对紧缺）
  减少了reduce操作，加快程序执行
  降低网络负载
  
  占用部分内存，所以加载到内存中的表不能过大，因为每个计算节点都会加载一次
  生成较多的小文件
配置以下参数，由hive根据SQL字段选择common join还是mapJoin
set hive.auto.convert.join=true;
hive.mapjoin.smalltable.filesize默认值是25M
第二种方式，手动指定：
select /*+mapjoin(n)*/ m.col,m.col2,n.col3 from m join n on m.col = n.col;
其中不管/*,还是+都不能省略
mapjoin的使用场景
1）关联操作中有一张表非常小
2）不等值的链接操作
如果join发生数据倾斜，可以使用优化参数：set hive.optimize.skewjoin=true;
分桶
一般使用分区就足够了
对于每一个表（table）或者分区，hive可以进一步分桶，也就是说桶是更为细粒度的数据范围划分
hive是针对某一列进行分桶
hive采用队列值哈希，然后除以桶的个数求余的方式决定该条记录存放在哪个桶中
好处:
获得更高的查询处理效率
使取样更高效
分桶的使用
select * from bucketed_user tablesample(bucket 1 out of 2 on id)
bucket join
需要先设置以下值才可以使用bucket join
set hive.optimize.bucketmapjoin=true;
set hive.optimize.bucketmapjoin.sortedmerge=true;
set hive.input.format=org.apache.hadoop.hive.ql.io.BucketizedHiveInputFormat;
连接两个在（包含连接列）相同列上划分了桶的表，可以使用Map端连接（Map-side join）高效的实现。比如
join操作。对于join操作两个表有一个相同的列，如果这两个表都进行了桶操作。那么将保存相同列值的桶进行
join操作就可以了，可以大大减少join的数据量。
对于Map端连接的情况，两个表以相同的方式划分桶。处理左边表内某个桶的mapper知道右边表内相匹配的行在
对应的桶内。因此，mapper只需要获取那个桶(这只是右边表内存储数据的一小部分)即可进行连接。这一优化方法
并不一定要求两个表桶的个数相同，两个表的桶个数是倍数关系也可以。
distribute分散数据
distribute by col//按照col列把数据分散到不同的reduce
sort排序
sort by col //按照col列把数据排序
select col1,col2 from m_table distribute by col1 sort by col1 asc,col2 desc;

一般distribute和sort结合出现，确保每个reduce的输出都是有序的
应用场景：
map输出的文件大小不均
reduce输出的文件大小不均
小文件过多
文件超大
对比：
distribute by 与group by
都是按照key值划分数据
都使用reduce操作
唯一不同，distribute by只是单纯的分散数据，而group by把相同的key的数据聚集到一起，
后续必须是聚合操作
order by 与 sort by
order by是全局排序
sort by 只是确保每个reduce上面输出的数据有序，如果只有一个reduce时，和order by作用一样
cluster by
把有相同值的数据聚集到一起，并排序
cluster by col效果等同于distribute by col order by col
union all
多个表的数据合并成一个表，hive不支持union
select col from ((select a as col from t1) union all (select b as col from t2))tmp
要求：
字段名字一样
字段类型一样
字段个数一样
字表不能有别名
如果需要从合并之后的表中查询数据，那么合并的表需要要有别名

13、函数

1)显示当前会话有多少函数可用
show functions;
2)显示函数的描述信息
desc function concat;
3)显示函数的扩展描述信息
desc function extended concat;
demo:
 select cast(1.5 as int) from employee;//cast类型转换
 其他内置函数参见hive函数手册
 
 下面两个函数每个分区的第一个数总是从0开始的
 cume_dist() over(partition b id order by money)
  //((想通知最大行号)/(行数))
 percent_rank() over(partition by id order by money)
   //((相同值最小行号-1)/(行数-1))
混合函数
可以调用Java类和方法
java_method(class,method[,arg1[,arg2..]])
reflect(class,method[,arg1[,arg2..]])//java_method 和reflect是相同的

eg:select java_method("java.lang.Math","sqrt",cast(id as double)) from employee;
UDTF
表函数
lateralView:lateral view udtf(expression) tableAlias as columnAlias(',' columnAlias)*fromClause:
from baseTable (lateralView)*
例：explode函数：把一行内容拆分成多行
eg: select id ,adid from winfunc lateral view explode(split(type,'B')) tt as adid
正则表达式
下面两个例子是正则贪婪匹配和非贪婪匹配的对比,索引是按照小括号走的，0表示匹配全部
eg:select regexp_extract('979|7.10.80|8684','.*\\|(.*)',1) from employee limit 1;
结果为：8684
  select regexp_extract('979|7.10.80|8684','(.*?)\\|(.*)',1) from employee limit 1;
结果为：979

14、用户自定义函数

UDF：用户自定义函数（user defined function）
针对单条记录
创建函数步骤
1)自定义一个Java类
2)继承UDF类
3)重写evaluate方法
4)打jar包
5)hive执行add jar    add jar /usr/local/opt/jar.jar
6)hive执行创建模板函数 create temporary function bigthan as 'com.johnson.hive.udf.UdfTest';
7)hql中使用  select name1, bigthan(name1,500) from employee; 
测试代码如下：
package com.johnson.hive.udf;
import org.apache.hadoop.hive.ql.exec.UDF;
import org.apache.hadoop.io.Text;


public class UdfTest extends UDF {
/**
* 自定义evaluate方法，方法名固定，参数和返回值按照项目要求改变
        * 如果t1>t2,return true
        * else return false
        * @return
        */
public boolean evaluate(Text t1,Text t2){
boolean flag = false;
if(t1!=null&&t2!=null){
double d1 = 0;
double d2 = 0;
try{
d1 = Double.parseDouble(t1.toString());
d2 = Double.parseDouble(t2.toString());
}catch(Exception e){}
if(d1>d2){
flag = true;
}
}
return flag;
}
}


UDAF：用户自定义聚合函数（user defined aggregation function）
 针对记录集合
 开发通用步骤：
  1)第一个是编写resolver类，resolver负责类型检查，操作符重载
  2)第二个是编写evaluator类，evaluator真正实现UDAF的逻辑
 通常来说，顶层UDAF类继承org.apache.hadoop.hive.ql.udf.GenericUDAFResolver2,
 类名编写嵌套类evaluator实现UDAF的逻辑
 一、实现resolver
   resolver通常继承org.apache.hadoop.hive.ql.udf.GenericUDAFResolver2,但是
   建议继承AbstractGenericUDAFResolver，隔离将来hive接口的变化。GenericUDAFResolver
   和GenericUDAFResolver2的接口区别是，后面的运行evaluator实现可以访问更多的信息，例如
   distinct限定符，通配符function（*）
 二、实现evaluator
   所有的evaluator必须继承抽象类org.apache.hadoop.hive.ql.udf.generic.GenericUDAFEvaluator.
   子类必须实现它的一些抽象方法，实现UDAF逻辑。
 Mode：这个类比较重要，他表示了UDAF在MapReduce的各个阶段，理解Mode的含义，就可以理解UDAF的
     运行流程。
     下面是源代码：
     public static enum Mode{
      PARTIAL1,
      PARTIAL2,
      FINAL,
      COMPLETE
     }
     PARTIAL1:这个是Mapreduce的Map阶段。从原始数据到部分数据集合，将会调用iterate()和
              terminatedPartial()
     PARTIAL2:这个是Mapreduce的Map阶段的？Combiner阶段，负责在Map端合并Map的数据，从
      部分数据聚合到部分数据聚合，将会调用merge()和terminatedPartial()
     FINAL:mapreduce的reduce阶段。从部分数据的聚合到完全聚合，将会调用merge和terminate
     COMPLETE：如果出现了这个阶段，表示Mapreduce只有Map，没有reduce，所有Map端就直接出
       结果了。从原始数据直接到完全聚合，将会调用iterate()和terminate()
可以看下源码中的sum/count聚合函数的实现
永久函数：
对于在hive Shell下是用add jar,只在当前Shell下有效，当Shell关闭在打开后，添加的临时UDF就会失效，
可以使用下面的方法将函数进行永久使用
1）如果希望在hive中自定义一个函数，并且能永久使用，可以修改源码添加相应的函数类，然后修改
  ql/src/java/org/apache/hadoop/hive/ql/exec/Function/Registry.java类，添加相应的注册
  函数代码
  registerUDF("parse_url",UDFParseUrl.class,false);
  这种方法一般用在集群刚刚搭建的时候，需要修改hive源代码，并从新编译打包
2）新建hiverc文件 ----这种方法比较常用
jar包放到安装目录下或者指定目录下
$HOME/.hiverc   //在当前用户的$HOME目录下新建.hiverc文件(vim .hiverc或者touch .hiverc)
把初始化语句加载到文件中
在文件中加载初始化语句的demo：
-- add self functions //注释
add jar /usr/local/opt/extenal_jar/jar.jar; //添加jar文件
create temporary function bigthan as 'com.johnson.hive.udf.UdfTest'; //注册别名

15、hive SQL优化

    join优化
    set hive.optimize.skewjoin=true;如果是join过程出现倾斜，应该设置为true
    set hive.skewjoin.key=100000; 这个是join的键赌赢的记录条数，超过这个值则进行优化
    mapjoin
    set hive.auto.convert.join=true;
    hive.mapjoin.smalltable.filesize默认值是25M
    select /*+mapjoin(A)*/ f.a,f.b from A t join B f on (f.a = t.a)
    简单总结，mapjoin的适用场景
    1)关联操作中有一张表非常小
    2)不等值的链接操作
    bucket join
    使用条件：
    两个表以相同方式划分桶
    两个表的桶个数是倍数关系
    create table order(cid int,price float) clustered by (cid) into 32 buckets;
    create table customer(id int, first string) clustered by (id) into 32 buckets;
    select price from order t join customer s on t.cid = s.id
   
    join优化案例
    优化前：select m.cid,u.id from order m join customer u on m.cid = u.id where m.dt='2013-01-01';
    优化后：select m.cid,u.id from (select cid from order where dt='2013-01-01')m join customer u on m.cid = u.id;
    原因：因为hive先执行join，然后执行where，这和关系型数据库里面sql执行的顺序是不一样的，所以
    必须这样写,尤其是在表进行分区的情况下更明显
    group by优化：
    set hive.groupby.skewindata=true;如果group by过程中出现倾斜，应该设置为true
    set hive.groupby.mapaggr.checkinterval=100000;这个是group的键对应的记录条数超过这个值后
就会进行优化
count distinct
优化前：select count(distinct id ) from tableName;
优化后：select count(1) from (select distinct id from tableName) tmp;
  select count(1) from (select id from tableName group by id) tmp;
hive SQL优化
优化前：
select a,sum(b),count(distinct c),count(distinct d) from test group by a;
优化后：
select a,sumb(b) as b,count(c) as c,count(d) as d
from (
select a,0 as b,c, null as d from test group by a,c
union all select a,0 as b,null as c,d from test group by a,d
union all select a,b null as c,null as d from test) tmp1
group by a;

16、hive优化

目标：
在有限的资源下，提高运行效率
常见问题：
数据倾斜
Map数设置
reduce数设置
其他
hive执行顺序 ：HQL-》Job-》Mapreduce
执行计划：
查看执行计划：explain[extended] hql
demo:
select col,count(1) from test2 group by col;
explain select col,count(1) from test2 group by col;

17、hive表优化

分区
静态分区
动态分区
set hive.exec.dynamic.partition=true;
set hive.exec.dynamic.partition.mode=nonstrict;
分桶
set hive.enforce.bucketing=true;
set hive.enforce.sorting=true;
数据
相同数据尽量聚集在一起（可以降低网络数据负载）

18、hive MapReduce优化

job优化
并行化执行
每个查询被hive转化为多个阶段，有些阶段关联性不大，则可以并行化执行，减少执行时间
set hive.exec.parallel=true;
set hive.exec.parallel.thread.number=8;
本地化执行
set hive.exec.mode.local.auto=true;
当一个job满足如下条件才能真正使用本地模式：
1）job的输入数据大小必须小于参数
hive.exec.mode.local.auto.inputbytes.max(默认是128M)
                2）job的Map数必须小于参数：
                hive.exec.mode.local.auto.tasks.max(默认4) 
                3）job的Reduce数必须为0或者1
        job合并输入小文件
        set hive.input.format=org.apache.hadoop.hive.ql.io.CombineHiveInputFormat
        合并文件数由mapred.max.split.size限制的大小决定
        job合并输出小文件
        set hive.merge.smallfiles.avgsize=256000000;当输出文件平均大小小于该值，启动新job合并文件
        set hive.merge.size.per.task=64000000;合并后的文件大小
        JVM  重利用
        set mapred.job.reuse.jvm.num.tasks=20;
        jvm重利用可以使job长时间保留slot，知道作业结束，这在对于有较多任务和较多小文件的任务是非常
        有意义的，减少执行时间。当然这个值不能设置过大，因为有些作业会有reduce任务，如果reduce任务
        没有完成，则Map任务占用的solt不能施法，其他的作业可能就需要等待。
        压缩数据
        中间压缩：
        中间压缩就是处理hive查询的多个job之间的数据，对于中间压缩，最好选择一个节省CPU耗时的
        压缩方式。
        set hive.exec.compress.intermediate=true;
        set hive.intermediate.compression.codec=org.apache.hadoop.io.compress.SnappyCodec;
        set hive.intermediate.compression.type=BLOCK;
        hive查询最终的输出也可以压缩
        set hive.exec.compress.output=true;
        set mapred.output.compression.codec=org.apache.hadoop.io.compress.GzipCodec;
        set mapred.output.compression.type=BLOCK;
       
        Map优化
        set mapred.map.tasks=10;有时候会无效,原因是Map个数的计算公式如下:
        1)默认Map格式
        default_num = total_size/block_size;
        2)期望大小
        goal_num = mapred.map.tasks;
        3)设置处理的文件大小
        split_size = max(mapred.min.split.size,block_size);
        split_num = total_size/split_size;
        4)计算的Map的个数
        compute_map_num = min(split_num,max(default_num,goal_num))  
        经过上面分析可知,在设置Map个数的适合,可以简单的总结为以下几点:
        1)如果想增加Map个数,则设置mapred.map.tasks为一个较大的值 .
        2)如果想减小Map个数,则设置mapred.min.split.size为一个较大的值.
        情况1:输入文件size巨大,但不是小文件
        增大mapred.min.split.size的值
        情况2:输入文件数量巨大,并且都是小文件,就是单个文件的size小于blockSize.这种情况通过增
        大mapred.min.split.size不可行,需要使用CombineFileInputFormat将多个input path
        合并成一个inputSplit送给mapper进行处理,从而减少mapper的数量.
           map端聚合
            set hive.map.aggr=true;//相当于combiner
           推测执行
            mapred.map.tasks.speculative.execution

19. hive shuffle优化

Map端
io.sort.mb
io.sort.spill.percent
min.num.spill.for.combine
io.sort.factor
io.sort.record.percent
reduce端
mapred.reduce.parallel.copies
mapred.reduce.copy.backoff
io.sort.factor
mapred.job.shuffle.input.buffer.percent
mapred.job.reduce.input.buffer.percent

20. hive reduce优化

需要reduce操作的查询
聚合函数
sum/count/distinct/...
高级查询
group by, join, distribute by ,cluster by ..
order by 比较特殊,只需要一个reduce
推测执行
1)mapred.reduce.tasks.speculative.execution
2)hive.mapred.reduce.tasks.speculative.execution
这两种方式那种都可以
reduce优化
set mapred.reduce.tasks=10;//直接设置
hive.exec.reducers.max默认:999
hive.exec.reducers.bytes.per.reducer 每个reduce计算的文件大小,默认:1G
计算公式
numRTasks = min[maxReducers,input.size/perReducer] //使用的reduce的计算公式
maxReducers = hive.exec.reducers.max
perReducer = hive.exec.reducers.bytes.per.reducer   

21.针对不同来源汇总的数据仓库

对于内容:
1)不同数据源进行处理
2)不同数据格式进行统一格式
3)不同来源数据统一字段
4)非统一字段使用集合
5)来自不同来源使用分区