Hive常用操作大全_show tables like 'table_name'语句能否添加筛选条件

Hive架构原理——转载

一、常用操作

1、查看数据库：show databases;

2、根据字段筛选和查找表：show tables like '*?*'

3、查看表结构：desc TABLE_NAME;

4、查看当前所在的数据库：select current_database();

5、查看表的创建信息：show create table 表名

6、删除表：drop table 表名 [purge]：purge直接删掉，不保留在回收站；

7、清空表数据：truncate table 表名：清空表数据(仅限内部表，外部表不需要)。

8、针对元数据修改表：alter table 表名 ... 。后面可跟多种修改类型，具体操作如下图所示：

9、union all 和union的区别：union all是合并后保留重复项，union是合并后删除重复项(1.2版本之后不可用)

10、sort by：每个reducer中的数据进行排序，不是全局有序的，排序列必须出现在select column列表中，reducer为1时，即等于order by；

11、show views;查看视图列表，在hive2.2以后才有

12、MapJoin：Hive默认是reduce端join，但在大表+小表进行不等值连接时，用mapjoin更节省资源。因此可以设置set hive.aotu.convert.join=true，运行程序时就自动转换为mapjoin。（mapjoin不支持union all,lateral view,group by/join/sort by/cluster by/distribute by等操作后面，不支持union,join以及其他mapjoin操作前面）

13、Hive存储的数据结构

二、建表操作

1、创建[外部]表：create [external] table TABLE_NAME( 字段 字段类型) row format delimited fields terminated by '分隔符' [map、struct等其他限制条件，如果有]

2、CTAS建表：就是从一个SQL查询结果来创建一个表进行存储：create table 新建表名称 row format ... as + 查询语句，一般用在清洗脏表时新建表

3、CTE查询和建表：with 表名 as (sql语句)+查询语句。在with前使用create table 表名 as，则将查询结果作为新表内容存储到数据库中(永久，非临时)，即为CTE建表

4、视图：新建视图：create view VIEW_NAME as +查询语句。视图是已经编译好的sql语句，依赖于表，随着表的变化而变化，类似于Excel里数据透视图或生成的柱状图等。可以通过alter view 视图名字 as +查询语句来重构视图结构

5、临时表：在上面任何一种建表方式中，在create和表名之间加上temporary，即为临时表。临时表只对当前session(会话窗口)有效，退出当前session时自动删除，表的路径在tmp目录下。建表语句为：create temporary table 表名 ...。

6、分区表：新建时，在row format前面加上partitioned by (字段 字段类型)；导入数据时在最后面加partition(字段=分区名)；查看分区show partitions 表名;alter table 表名 drop partition (字段=分区名);分区表就是一个文件目录

6.2、外部分区表，一般分区表都是清洗后insert插进去，但有时我们需要根据已有数据建一个外部分区表，此时装载数据需要使用alter table default.ods_logs add partition (log_data='20210311') location '/upload/20210311';，删除的话，把add替换为drop即可

7、分桶表：hive自动根据bucket数量分桶：set hive.enforce.bucketing = true;手动指定reduce数量：set mapreduce.job.reduces = num;set mapreduce.reduce.tasks = num;(不推荐手动)，并在 create 后row format前增加：clustered by (TANLE_NAME) into N buckets

8、分桶表抽样：select * from 表名 tablesample(bucket X out of Y on id) s;其中x为第几个部分，Y为分桶数量的整数倍或因子。如果Y为分桶数，则数据为第X个桶；如果Y为小于分桶数的因子，则数据为X+[n]Y的数据；如果Y为大于分桶数的倍数，则可以理解为重新分桶为Y，数据为Y中的第X个桶。

9、CTL建表，like：create table 表名 like 表名;创建一个表结构，意思是抄袭后一个表的表结构，建出来的是一个空表

• 或者create table ... as select * from ... where 1=2

10、侧视图lateral view：侧视图一般和表生成函数(explode等)使用，对行里的数组、map、结构体进行拆分，用来规范行，或者解析json格式的数据。案例：

select 字段,新别名1,新别名2,新别名3,新别名4,新别名5,新别名6
from 表名
lateral view explode(数组字段1) 别名1 as 新别名1
lateral view explode(map字段2) 别名2 as 新别名2,新别名3
lateral view inline(array(结构体)) 别名3as 新别名4,新别名5,新别名6;
1
2
3
4
5

三、建表注意点

1、有表头的文件，忽视掉表头：tblproperties("skip.header.line.count"="1")

2、csv文件默认分隔符是逗号，但有的字段里也包含逗号，所以row format后要正则替换为row format serde 'org.apache.hadoop.hive.serde2.OpenCSVSerde' with serdeproperties("separatorchar"=",","escapeChar"="\\")

3、对于字段里的重复数据，如果需要在原有基础上更新为非重复的数据，可将原字段分区，这样重复的字段就会被分到一个区，然后对第二个以后的数据分别做处理，即可。

4、不指定分隔符的话，hive表的默认分隔符是，字段:^A ,集合： ^B,映射： ^C

四、加载数据

1、导入数据：load data [local] inpath 'PATH' into table NAME;本地是复制，HDFS里如果没有指定location时会移动hdfs数据到warehouse目录下，指定的话就不移动

2、更新源数据：load data [local] inpath 'PATH' overwrite into table NAME;不写overwrite是追加

3、新建数据库并把表加载进去的方法，把多个建表、导数据的sql语句写在代码内，然后在虚拟机下执行：hive -f 代码文件名，即可一次性建立好数据库并导入数据。

五、装载数据

1、INSERT表插入数据，支持overwrite(覆盖)和into(追加)，数据插入的列数必须与指定列数相同

• 基本语法：insert overwrite/into table 表名1 [partition(partcol1=val1, partcol2=val2 ...)] select fileds,... from 表名2;
• 支持插入值列表：insert into 表名 values_list
• insert into支持指定插入到哪些字段中：insert into table(x,y,z) ...
• 多插入：

from 表名 
insert overwrite 表名2 select * 
insert overwrite 表名3 select *;
1
2
3

• 插入到分区：

from 表名
insert overwrite table 表名 partition(Field1,Field2)
select *,'part1','part2';
1
2
3

• 通过指定列插入(insert into可以省略table关键字)

insert into 表名(字段1) select 'John' from 表名2 limit 1;
1

• 通过指定值插入

insert into 表名(字段1) value('Judy'),('John');
1

使用insert语句将数据插入/导出到文件

2、把表导出到文件：from 表名 insert overwrite [local] directory '...' select *;加上local为导出到虚拟机下的目录，去掉local为HDFS里；也可以在路径和select之间添加row format delimited来指定分隔符。

3、把表导出到另一张表里：from 表名 insert overwrite table 表名2 select *

4、导入导出：
把表导入到HDFS文件：export table 表名 [partition(分区1,分区2)] to '...';
把文件导入到表里：import table 表名 [partition(分区1,分区2)] from '...';

5、把文件直接加载到表里：hdfs dfs -put '...file' '...file'

六、查询

1、order by：可以使用if和case when等系统函数，除聚合函数外，所选的其他列也必须包含在group by中，having是对group by聚合的结果进行条件筛选

select if(salary>5000,'good','bad'),sum(salary)
from employee_contract
group by if(salary>5000,'good','bad')
1
2
3

结果：
±------±-------±-+
| _c0 | _c1 |
±------±-------±-+
| bad | 18000 |
| good | 44800 |
±------±-------±-+
2、distribute by+sort by = cluster by：分组排序，分组聚合，类似mysql里的group by。cluster by不支持desc|asc，一般为了充分利用所有的reducer，先使用cluster by 再使用order by。但只能指定一个字段，即既按照该字段分区，又按照该字段排序，不常用。

七、部分错误解决方案：

1.Unsupported SubQuery Expression ‘1’: SubQuery expression refers to Outer query expressions only.
子查询和外部查询具有相同的字段别名或者外部查询没有取别名，导致把内表的字段名识别为外部查询的别名（hql里对字段名的清晰度要求比mysql更高）
2.SemanticException [Error 10002]: Line 76:19 Invalid column reference ‘sid’
使用join表关联后，如果使用group by分组一个字段，则这个表的其他字段也需要聚合后才能使用，如果不聚合，则会报上面错误。这一点和mysql不一样，hivesql更严格
。。。待更新

八、函数

点击：Hive常见函数说明以及使用案例

九、项目实战流程总结

1、把数据上传到hdfs/也可以放在虚拟机本地
2、新建一个数据库/使用已有的数据库
3、根据数据文件里的每张表结构，创建对应的外部表。
4、csv文件默认是逗号分隔符，可能会与字段内容里的逗号冲突造成数据错乱，因此在创建表结构时读取文件的分隔符不能默认使用逗号，需要把分隔符进行正则替换然后再处理。
5、很多表都是有表头的，建表时要设置tblproperties忽略第一行的字段。
6、导入数据。表里的数据有可能是未经过处理的，比如说要加密的字段，重复的id、等等，因此需要对有问题或者需要优化的地方进行数据清洗，清洗完的数据放在一个新表里，然后根据新表进行查询操作。
7、一定要熟悉阅读表字段的内容，以及各张表之间的联系
8、LLAP：内存中读取缓存，辅助引擎提高性能，对串行化的升级，不代替引擎，目前只支持Tez
9、zeppelin，alt点住多行可以同时写多行数据
10、serde，针对不同格式的文件使用不同的序列方式
11、所有字段可以都设置成string，然后用函数转

十、常见set参数

Hive常见set的配置设置
引用：Hive常见set的配置设置
设置reduce数量（默认值-1）

set mapred.reduce.tasks=100;

set mapreduce.job.reduces=3;
1
2
3

修改表为内部表

set tblproperties('EXTERNAL'='FALSE');
1

开启分桶表（默认false）

set hive.enforce.bucketing=true;
1

开启Hive中间传输数据压缩功能

set hive.exec.cmpress.intermediate=true;
1

开启mapreduce 中map 输出压缩功能

set mapreduce.map.output.compress=true;
1

设置mapreduce 中map 输出数据的压缩方式

set mapreduce.map.output.compress.codec= org.apache.hadoop.io.compress.SnappyCodec;
1

开启hive 最终输出数据压缩功能

set hive.exec.compress.output=true;
1

开启mapreduce 最终输出数据压缩

set mapreduce.output.fileoutputformat.compress=true;
1

设置mapreduce 最终数据输出压缩方式

set mapreduce.output.fileoutputformat.compress.codec = org.apache.hadoop.io.compress.SnappyCodec;
1

设置mapreduce 最终数据输出压缩为块压缩

set mapreduce.output.fileoutputformat.compress.type=BLOCK;
1

设置Fetch抓取为more（默认为more）

set hive.fetch.task.conversion=more;
1

开启本地模式（默认关闭），在数据量比较小的时候，可以提高速度

set hive.exec.mode.local.auto=true;
1

设置local mr 的最大输入数据量，当输入数据量小于这个值时采用local mr 的
方式，默认为134217728，即128M

set hive.exec.mode.local.auto.inputbytes.max=50000000;
1

设置local mr 的最大输入文件个数，当输入文件个数小于这个值时采用local mr
的方式，默认为4

set hive.exec.mode.local.auto.input.files.max=10;
1

打开mapjoin 功能（默认是打开的）

set hive.auto.convert.join = true;
1

开启Map 端聚合参数设置

set hive.map.aggr = true;
1

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

set hive.groupby.mapaggr.checkinterval = 100000;
1

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

set hive.groupby.skewindata = true;
1

开启动态分区功能（默认开启）

set hive.exec.dynamic.partition=true;
1

设置为非严格模式（默认严格strict）

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

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

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

在每个执行MR 的节点上，最大可以创建多少个动态分区（100）

set hive.exec.max.dynamic.partitions.pernode=100;
1

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

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

开启小文件合并（HiveInputFormat ）——map端合并

set mapred.max.split.size=256*1024*1024;最大切片值
set mapred.min.split.size=128*1024*1024;最小切片值
set mapred.min.split.size.per.node=1;一个节点上split的最少值
set hive.input.format=org.apache.hadoop.hive.ql.io.CombineHiveInputFormat;
1
2
3
4

开启小文件合并（HiveOutputFormat ）——reduce端输出之前合并

set hive.merge.mapfiles=true;在maponly的任务结束时合并小文件
set hive.merge.mapred.files=true;在true时MR的任务结束时合并小文件
set hive.merge.size.per.task=250*1000*1000;合并文件的大小设置
set hive.merge.smallfiles.avgsize=16000000 #当输出文件的平均大小小于该值时，启动一个独立的map-reduce任务进行文件merge
1
2
3
4

每个Reduce 处理的数据量默认是256MB256000000）

set mapreduce.input.fileinputformat.split.maxsize=256000000;
1

每个任务最大的reduce 数，默认为1009

set hive.exec.reducers.max=1009;
1

开启并行执行（默认关闭）

set hive.exec.parallel=true;
1

同一个sql 允许最大并行度，默认为8。

set hive.exec.parallel.thread.number=16;
1

HiveServer2操作日志记录模式，忽略任何日志记录

set hive.server2.logging.operation.level=NONE;
1

设置后可以按照指定的列排序

set hive.groupby.orderby.position.alias=true
1

少量小文件：本地化

set hive.exec.mode.local.auto=true;
set hive.exec.mode.local.auto.inputbytes.max=500000;设计文件最大字节数
set hive.exec.mode.local.auto.input.files.max=5;最大文件数：default 4
set mapred.reduce.tasks=1
1
2
3
4

JVM重用：串行化（Map或Reduce）

set mapred.jb.reuse.jvm.num.tasks=5;默认为1
1

并行执行：非依赖关系的子查询可以并发执行：不需要并发时关闭

set hive.exec.parallel=true;默认false
set hive.exec.parallel.thread.number=16;默认为8
1
2

reducetask的数量
job.setNumReduceTasks(int N);
set mapred.reduce.tasks=15;

默认
set hive.exec.reduces.bytes.per.reducer=1G;默认
set hive.exec.reduces.max=999;默认999
reducetaskCount=Math.min(maxReduceCount,fileSize/bytePerReduce);

• 单节点开启动态分区时，可能会容量不够无法创建，需要以下设置

set hive.exec.dynamic.partition=true;
set hive.exec.dynamic.partition.mode=nonstrict;
set hive.exec.max.dynamic.partitions.pernode=1000;
set hive.optimize.sort.dynamic.partition=true;
1
2
3
4

其他参数调优，来源网络：

Hive参数配置调优
　　hive通过将查询划分成一个或多个MapReduce任务达到并行处理的目的。每个任务都可能具有多个mapper和reducer任务，其中至少有一些是可以并行执行的。

确定最佳的mapper个数和reducer个数取决于多个变量，例如输入的数据量大小以及对这些数据执行的操作类型等。

　　保持平衡性是很有必要的，对于Spark/Hadoop这样的大数据系统来讲，数据量大并不可怕,可怕的是数据倾斜，每个节点处理的运算不均衡。

如果有太多的mapper或reducer任务，就会导致启动阶段、调度和运行job过程中产生过多的开销；而如果设置的数量太少，那就有可能没充分利用好集群内在并行性。

mapred.reduce.tasks
所提交 Job 的 reduer 的个数，使用 Hadoop Client 的配置。
1

hive.mapred.mode
Map/Redure 模式，如果设置为 strict，将禁止3中类型的查询：
1.分区表的where筛选条件必须含有分区字段；
2.对使用了order by语句的查询，必须使用limit语句(order by语句为执行排序会将所有的结果集数据分发到同一个reducer中进行处理，增加limit语句可以防止reducer额外执行很长时间)
3.限制笛卡儿积的查询，就是有where语句，而没有on语句。
'nonstrict'

hive.merge.mapfiles
在Map-only的任务结束时合并小文件
是否开启合并 Map 端小文件，当Hive输入由很多个小文件组成，由于每个小文件都会启动一个map任务，如果文件过小，会使得map任务启动和初始化的时间大于逻辑处理的时间，造成资源浪费，甚至OOM。为此，当我们启动一个任务，发现输入数据量小但任务数量多时，需要注意在Map前端进行输入合并。当然，在我们向一个表写数据时，也需要注意输出文件大小
true

hive.merge.mapredfiles
是否开启合并 Map/Reduce 小文件，即是否在Map-Reduce的任务结束时合并小文件
false

hive.exec.parallel
是否开启 map/reduce job的并发提交。
false

hive.limit.optimize.enable
当使用LIMIT语句时，其可以对数据源进行抽样，避免执行整个查询语句，然后再返回部分结果
但这个功能有个缺点，有可能输入中有用的数据永远不会被处理到。

hive.exec.reducers.bytes.per.reducer
每一个 reducer 的平均负载字节数。
1000000000

hive.exec.reducers.max
设置reducer个数的上限，可以阻止某个查询消耗过多的reducer资源，对这个属性值大小的设定，一个建议的计算公式如下：
(集群总Reduce槽位个数*1.5) / (执行中查询的平均个数)
1.5倍数是一个经验系数，用于防止未充分利用集群的情况。
999

hive.exec.rowoffset
hive提供了2种虚拟列：一种用于将要进行划分的输入文件名，另一种用于文件中的块内偏移量。当hive产生了非预期的或null的返回结果时，可以通过这些虚拟列诊断查询。通过这些“字段”，用户可以查看到哪个文件甚至哪些数据导致出现问题：
SELECT
INPUT_FILE_NAME,
BLOCK_OFFSET_INSIDE_FILE,
ROW_OFFSET_INSIDE_BLOCK,
line
FROM hive_text
WHERE line LIKE '%hive%' LIMIT 2;
true

hive.multigroupby.singlemr
一个特别的优化，是否将查询中的多个group by操作组装到单个MapReduce任务中。
false

hive.exec.dynamic.partition
是否打开动态分区。
false

hive.exec.dynamic.partition.mode
打开动态分区后，动态分区的模式，有 strict 和 nonstrict 两个值可选，strict 要求至少包含一个静态分区列，nonstrict 则无此要求。
strict

hive.exec.max.dynamic.partitions
所允许的最大的动态分区的个数。
1000

hive.exec.max.dynamic.partitions.pernode
单个 reduce 结点所允许的最大的动态分区的个数。
100

hive.exec.default.partition.name
默认的动态分区的名称，当动态分区列为''或者null时，使用此名称。''
'__HIVE_DEFAULT_PARTITION__'

hive.exec.mode.local.auto
决定 Hive 是否应该自动地根据输入文件大小，在本地运行（在GateWay运行）
true

hive.exec.mode.local.auto.inputbytes.max
如果 hive.exec.mode.local.auto 为 true，当输入文件大小小于此阈值时可以自动在本地模式运行，默认是 128兆。
134217728L

hive.exec.mode.local.auto.tasks.max
如果 hive.exec.mode.local.auto 为 true，当 Hive Tasks（Hadoop Jobs）小于此阈值时，可以自动在本地模式运行。
4

hive.auto.convert.join
是否根据输入小表的大小，自动将 Reduce 端的 Common Join 转化为 Map Join，从而加快大表关联小表的 Join 速度。
false

hive.mapred.local.mem
Mapper/Reducer 在本地模式的最大内存量，以字节为单位，0为不限制。
0

hive.exec.scratchdir
HDFS路径，用于存储不同 map/reduce 阶段的执行计划和这些阶段的中间输出结果。
/tmp/<user.name>/hive

hive.metastore.warehouse.dir
Hive 默认的数据文件存储路径，通常为 HDFS 可写的路径。
"

hive.groupby.skewindata
决定 group by 操作是否支持倾斜的数据。
false

hive.default.fileformat
Hive 默认的输出文件格式，与创建表时所指定的相同，可选项为 'TextFile' 、 'SequenceFile' 或者 'RCFile'。
'TextFile'

hive.security.authorization.enabled
Hive 是否开启权限认证。
false

hive.exec.plan
Hive 执行计划的路径，会在程序中自动进行设置
null

hive.exec.submitviachild
决定 map/reduce Job 是否应该使用各自独立的 JVM 进行提交（Child进程），默认情况下，使用与 HQL compiler 相同的 JVM 进行提交。
false

hive.exec.script.maxerrsize
通过 TRANSFROM/MAP/REDUCE 所执行的用户脚本所允许的最大的序列化错误数。
100000

hive.exec.script.allow.partial.consumption
是否允许脚本只处理部分数据，如果设置为 true ，因 broken pipe 等造成的数据未处理完成将视为正常。
false

hive.exec.compress.output
决定查询中最后一个 map/reduce job 的输出是否为压缩格式。
false

hive.exec.compress.intermediate
决定查询的中间 map/reduce job （中间 stage）的输出是否为压缩格式。
false

hive.intermediate.compression.codec
中间 map/reduce job 的压缩编解码器的类名（一个压缩编解码器可能包含多种压缩类型），该值可能在程序中被自动设置。


hive.intermediate.compression.type
中间 map/reduce job 的压缩类型，如 "BLOCK" "RECORD"。

hive.exec.pre.hooks
语句层面，整条 HQL 语句在执行前的 hook 类名。
"

hive.exec.post.hooks
语句层面，整条 HQL 语句在执行完成后的 hook 类名。


hive.exec.parallel.thread.number
并发提交时的并发线程的个数。
8

hive.mapred.reduce.tasks.speculative.execution
是否开启 reducer 的推测执行，与 mapred.reduce.tasks.speculative.execution 作用相同。
false

hive.exec.counters.pull.interval
客户端拉取 progress counters 的时间，以毫秒为单位。
1000L

hadoop.bin.path
Hadoop Client 可执行脚本的路径，该路径用于通过单独的 JVM 提交 job，使用 Hadoop Client 的配置。
$HADOOP_HOME/bin/hadoop

hadoop.config.dir
Hadoop Client 配置文件的路径，使用 Hadoop Client 的配置。
$HADOOP_HOME/conf

fs.default.name
Namenode 的 URL，使用 Hadoop Client 的配置。
file:///

map.input.file
Map 的输入文件，使用 Hadoop Client 的配置。
null

mapred.input.dir
Map 的输入目录，使用 Hadoop Client 的配置。
null

mapred.input.dir.recursive
输入目录是否可递归嵌套，使用 Hadoop Client 的配置。
false

mapred.job.tracker
Job Tracker 的 URL，使用 Hadoop Client 的配置，如果这个配置设置为 'local'，将使用本地模式。
local

mapred.job.name
Map/Reduce 的 job 名称，如果没有设置，则使用生成的 job name，使用 Hadoop Client 的配置。
null

mapred.reduce.tasks.speculative.execution
Map/Reduce 推测执行，使用 Hadoop Client 的配置。
null

hive.metastore.metadb.dir
Hive 元数据库所在路径。
"

hive.metastore.uris
Hive 元数据的 URI，多个 thrift://地址，以英文逗号分隔。
"

hive.metastore.connect.retries
连接到 Thrift 元数据服务的最大重试次数。
3

javax.jdo.option.ConnectionPassword
JDO 的连接密码。
"

hive.metastore.ds.connection.url.hook
JDO 连接 URL Hook 的类名，该 Hook 用于获得 JDO 元数据库的连接字符串，为实现了 JDOConnectionURLHook 接口的类。
"

javax.jdo.option.ConnectionURL
元数据库的连接 URL。
"

hive.metastore.ds.retry.attempts
当没有 JDO 数据连接错误后，尝试连接后台数据存储的最大次数。
1

hive.metastore.ds.retry.interval
每次尝试连接后台数据存储的时间间隔，以毫秒为单位。
1000

hive.metastore.force.reload.conf
是否强制重新加载元数据配置，一但重新加载，该值就会被重置为 false。
false

hive.metastore.server.min.threads
Thrift 服务线程池的最小线程数。
8

hive.metastore.server.max.threads
Thrift 服务线程池的最大线程数。
0x7fffffff

hive.metastore.server.tcp.keepalive
Thrift 服务是否保持 TCP 连接。
true

hive.metastore.archive.intermediate.original
用于归档压缩的原始中间目录的后缀，这些目录是什么并不重要，只要能够避免冲突即可。
'_INTERMEDIATE_ORIGINAL'

hive.metastore.archive.intermediate.archived
用于归档压缩的压缩后的中间目录的后缀，这些目录是什么并不重要，只要能够避免冲突即可。
'_INTERMEDIATE_ARCHIVED'

hive.metastore.archive.intermediate.extracted
用于归档压缩的解压后的中间目录的后缀，这些目录是什么并不重要，只要能够避免冲突即可。
'_INTERMEDIATE_EXTRACTED'

hive.cli.errors.ignore
是否忽略错误，对于包含多的 SQL 文件，可以忽略错误的行，继续执行下一行。
false

hive.session.id
当前会话的标识符，格式为“用户名_时间”用于记录在 job conf 中，一般不予以手动设置。
"

hive.session.silent
当前会话是否在 silent 模式运行。 如果不是 silent 模式，所以 info 级打在日志中的消息，都将以标准错误流的形式输出到控制台。
false

hive.query.string
当前正在被执行的查询字符串。
"

hive.query.id
当前正在被执行的查询的ID。
"

hive.query.planid
当前正在被执行的 map/reduce plan 的 ID。
"

hive.jobname.length
当前 job name 的最大长度，hive 会根据此长度省略 job name 的中间部分。
50

hive.jar.path
通过单独的 JVM 提交 job 时，hive_cli.jar 所在的路径
"

hive.aux.jars.path
各种由用户自定义 UDF 和 SerDe 构成的插件 jar 包所在的路径。
"

hive.added.files.path
ADD FILE 所增加的文件的路径。
"

hive.added.jars.path
ADD JAR 所增加的文件的路径。
"

hive.added.archives.path
ADD ARCHIEVE 所增加的文件的路径。
"

hive.table.name
当前的 Hive 表的名称，该配置将通过 ScirptOperator 传入到用户脚本中。
"

hive.partition.name
当前的 Hive 分区的名称，该配置将通过 ScriptOperator 传入到用户脚本中。
"

hive.script.auto.progress
脚本是否周期性地向 Job Tracker 发送心跳，以避免脚本执行的时间过长，使 Job Tracker 认为脚本已经挂掉了。
false

hive.script.operator.id.env.var
用于识别 ScriptOperator ID 的环境变量的名称。
'HIVE_SCRIPT_OPERATOR_ID'

hive.alias
当前的 Hive 别名，该配置将通过 ScriptOpertaor 传入到用户脚本中。
"

hive.map.aggr
决定是否可以在 Map 端进行聚合操作
true

hive.join.emit.interval
Hive Join 操作的发射时间间隔，以毫秒为单位。
1000

hive.join.cache.size
Hive Join 操作的缓存大小，以字节为单位。
25000

hive.mapjoin.bucket.cache.size
Hive Map Join 桶的缓存大小，以字节为单位。
100

hive.mapjoin.size.key
Hive Map Join 每一行键的大小，以字节为单位。
10000

hive.mapjoin.cache.numrows
Hive Map Join 所缓存的行数。
25000

hive.groupby.mapaggr.checkinterval
对于 Group By 操作的 Map 聚合的检测时间，以毫秒为单位。
100000

hive.map.aggr.hash.percentmemory
Hive Map 端聚合的哈稀存储所占用虚拟机的内存比例。
0.5

hive.map.aggr.hash.min.reduction
Hive Map 端聚合的哈稀存储的最小 reduce 比例。
0.5

hive.udtf.auto.progress
Hive UDTF 是否周期性地报告心跳，当 UDTF 执行时间较长且不输出行时有用。
false

hive.fileformat.check
Hive 是否检查输出的文件格式。
true

hive.querylog.location
Hive 实时查询日志所在的目录，如果该值为空，将不创建实时的查询日志。
'/tmp/$USER'

hive.script.serde
Hive 用户脚本的 SerDe。
'org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe'

hive.script.recordreader
Hive 用户脚本的 RecordRedaer。
'org.apache.hadoop.hive.ql.exec.TextRecordReader'

hive.script.recordwriter
Hive 用户脚本的 RecordWriter。
'org.apache.hadoop.hive.ql.exec.TextRecordWriter'

hive.hwi.listen.host
HWI 所绑定的 HOST 或者 IP。
'0.0.0.0'

hive.hwi.listen.port
HWI 所监听的 HTTP 端口。
9999

hive.hwi.war.file
HWI 的 war 文件所在的路径。
$HWI_WAR_FILE

hive.test.mode
是否以测试模式运行 Hive
false

hive.test.mode.prefix
Hive 测试模式的前缀。
'test_'

hive.test.mode.samplefreq
Hive 测试模式取样的频率，即每秒钟取样的次数。
32

hive.test.mode.nosamplelist
Hive 测试模式取样的排除列表，以逗号分隔。
"

hive.merge.size.per.task
每个任务合并后文件的大小，根据此大小确定 reducer 的个数，默认 256 M。
256000000

hive.merge.smallfiles.avgsize
需要合并的小文件群的平均大小，默认 16 M。
16000000

hive.optimize.skewjoin
是否优化数据倾斜的 Join，对于倾斜的 Join 会开启新的 Map/Reduce Job 处理。
false

hive.skewjoin.key
倾斜键数目阈值，超过此值则判定为一个倾斜的 Join 查询。
1000000

hive.skewjoin.mapjoin.map.tasks
处理数据倾斜的 Map Join 的 Map 数上限。
10000

hive.skewjoin.mapjoin.min.split
处理数据倾斜的 Map Join 的最小数据切分大小，以字节为单位，默认为32M。
33554432

mapred.min.split.size
Map Reduce Job 的最小输入切分大小，与 Hadoop Client 使用相同的配置。
1

hive.mergejob.maponly
是否启用 Map Only 的合并 Job。
true

hive.heartbeat.interval
Hive Job 的心跳间隔，以毫秒为单位。
1000

hive.mapjoin.maxsize
Map Join 所处理的最大的行数。超过此行数，Map Join进程会异常退出。
1000000

hive.hashtable.initialCapacity
Hive 的 Map Join 会将小表 dump 到一个内存的 HashTable 中，该 HashTable 的初始大小由此参数指定。
100000

hive.hashtable.loadfactor
Hive 的 Map Join 会将小表 dump 到一个内存的 HashTable 中，该 HashTable 的负载因子由此参数指定。
0.75

hive.mapjoin.followby.gby.localtask.max.memory.usage
MapJoinOperator后面跟随GroupByOperator时，内存的最大使用比例
0.55

hive.mapjoin.localtask.max.memory.usage
Map Join 的本地任务使用堆内存的最大比例
0.9

hive.mapjoin.localtask.timeout
Map Join 本地任务超时，淘宝版特有特性
600000

hive.mapjoin.check.memory.rows
设置每多少行检测一次内存的大小，如果超过 hive.mapjoin.localtask.max.memory.usage 则会异常退出，Map Join 失败。
100000

hive.debug.localtask
是否调试本地任务，目前该参数没有生效
false

hive.task.progress
是否开启 counters ，以记录 Job 执行的进度，同时客户端也会拉取进度 counters。
false

hive.input.format
Hive 的输入 InputFormat。
默认是org.apache.hadoop.hive.ql.io.HiveInputFormat，其他还有org.apache.hadoop.hive.ql.io.CombineHiveInputFormat

hive.enforce.bucketing
是否启用强制 bucketing。
false

hive.enforce.sorting
是否启用强制排序。
false

hive.mapred.partitioner
Hive 的 Partitioner 类。
'org.apache.hadoop.hive.ql.io.DefaultHivePartitioner'

hive.exec.script.trust
Hive Script Operator For trust
false

hive.hadoop.supports.splittable.combineinputformat
是否支持可切分的 CombieInputFormat
false

hive.optimize.cp
是否优化列剪枝。
true

hive.optimize.ppd
是否优化谓词下推。
true

hive.optimize.groupby
是否优化 group by。
true

hive.optimize.bucketmapjoin
是否优化 bucket map join。
false

hive.optimize.bucketmapjoin.sortedmerge
是否在优化 bucket map join 时尝试使用强制 sorted merge bucket map join。
false

hive.optimize.reducededuplication
是否优化 reduce 冗余。
true

hive.hbase.wal.enabled
是否开启 HBase Storage Handler。
true

hive.archive.enabled
是否启用 har 文件。
false

hive.archive.har.parentdir.settable
是否启用 har 文件的父目录可设置。
false

hive.outerjoin.supports.filters
是否启动外联接支持过滤条件。
true

hive.fetch.output.serde
对于 Fetch Task 的 SerDe 类
'org.apache.hadoop.hive.serde2.DelimitedJSONSerDe'

hive.semantic.analyzer.hook
Hive 语义分析的 Hook，在语义分析阶段的前后被调用，用于分析和修改AST及生成的执行计划，以逗号分隔。
null

hive.cli.print.header
是否显示查询结果的列名，默认为不显示。
false

hive.cli.encoding
Hive 默认的命令行字符编码。
'UTF8'

hive.log.plan.progress
是否记录执行计划的进度。
true

hive.exec.script.wrapper
Script Operator 脚本调用的封装，通常为脚本解释程序。例如，可以把该变量值的名称设置为"python"，那么传递到 Script Operator 的脚本将会以"python <script command>"的命令形式进行调用，如果这个值为null或者没有设置，那么该脚本将会直接以"<script command>"的命令形式调用。
null

hive.check.fatal.errors.interval
客户端通过拉取 counters 检查严重错误的周期，以毫秒为单位，淘宝特有配置项。
5000L
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588

GC问题