在hive调优（一） 中说了一些常见的调优，但是觉得参数涉及不多，补充如下

1.设置合理solt数

mapred.tasktracker.map.tasks.maximum

每个tasktracker可同时运行的最大map task数，默认值2。

mapred.tasktracker.reduce.tasks.maximum

每个tasktracker可同时运行的最大reduce task数，默认值1。

2.配置磁盘块

mapred.local.dir

map task中间结果写本地磁盘路径，默认值${hadoop.tmp.dir}/mapred/local。

可配置多块磁盘缓解写压力。当存在多个可以磁盘时，Hadoop将采用轮询方式将不同的map task中间结果写到磁盘上。

3.配置RPC Handler数

mapred.job.tracker.handler.count

jobtracker可并发处理来自tasktracker的RPC请求数，默认值10。

4.配置HTTP线程数

tasktracker.http.threads

HTTP服务器的工作线程数，用于获取map task的输出结果，默认值40。

5.启用批调度

6.选择合适的压缩算法

Job输出结果是否压缩

mapred.output.compress

是否压缩，默认值false。

mapred.output.compression.type

压缩类型，有NONE, RECORD和BLOCK，默认值RECORD。

mapred.output.compression.codec

压缩算法，默认值org.apache.hadoop.io.compress.DefaultCodec。

map task输出是否压缩

mapred.compress.map.output

是否压缩，默认值false

mapred.map.output.compression.codec

压缩算法，默认值org.apache.hadoop.io.compress.DefaultCodec。

7.设置失败容忍度

mapred.max.map.failures.percent

例如：set mapred.max.map.failures.percent=30;

作业最多允许失败的map task比例，默认值0。

mapred.max.reduce.failures.percent

作业最多允许失败的reduce task比例，默认值0。

mapred.map.max.attempts

一个map task的最多重试次数，默认值4。

mapred.reduce.max.attempts

一个reduce task的最多重试次数，默认值4。

8.设置跳过坏记录

mapred.skip.attempts.to.start.skipping

当任务失败次数达到该值时，启用跳过坏记录功能，默认值2。

mapred.skip.out.dir

检测出的坏记录存放目录，默认值为输出目录的_logs/skip，设置为none表示不输出。

mapred.skip.map.max.skip.records

map task最多允许的跳过记录数，默认值0。

mapred.skip.reduce.max.skip.groups

reduce task最多允许的跳过记录数，默认值0。

9.配置jvm重用

mapred.job.reuse.jvm.num.tasks

一个jvm可连续启动多个同类型任务，默认值1，若为-1表示不受限制。

10.配置jvm参数

mapred.child.java.opts

任务启动的jvm参数，默认值-Xmx200m，建议值-XX:-UseGCOverheadLimit -Xms512m -Xmx2048m -verbose:gc -Xloggc:/tmp/@taskid@.gc

11. map task调优

io.sort.mb

默认值100M

io.sort.record.percent

默认值0.05

io.sort.spill.percent

默认值0.80

12.reduce task调优

io.sort.factor

默认值10

mapred.reduce.parallel.copies

默认值5

=================================================================================

1.设置任务名称，方便查找监控

SETmapred.job.name=P_DWA_D_IA_S_USER_PROD;

2.决定是否可以在Map端进行聚合操作

sethive.map.aggr=true;

3.有数据倾斜的时候进行负载均衡

sethive.groupby.skewindata=true;

HiveQL去重操作

和SQL一样，HiveQL中同样支持DISTINCT操作，如下示例：

(1)SELECTcount(DISTINCTuid)FROMlog

(2)SELECTip,count(DISTINCTuid)FROMlogGROUPBYip

(3)SELECTip,count(DISTINCTuid,uname)FROMlogGROUPBYip

(4)SELECTip,count(DISTINCTuid),count(DISTINCTuname)FROMlogGROUPBYip

当我们使用HiveQL中的去重关键字DISTINCT时，需要注意的一点是：

在多个列上进行的去重操作与hive环境变量hive.groupby.skewindata存在关系。

当hive.groupby.skewindata=true时，hive不支持多列上的去重操作，并报错：

Errorinsemanticanalysis:DISTINCTondifferentcolumnsnotsupportedwithskewindata.

注意：上面示例中的(3)不属于多列上的DISTINCT操作。

GroupBy语句

Map端部分聚合：

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

基于Hash

参数包括：

hive.map.aggr=true是否在Map端进行聚合，默认为True

hive.groupby.mapaggr.checkinterval=100000在Map端进行聚合操作的条目数目

有数据倾斜的时候进行负载均衡

hive.groupby.skewindata=false

当选项设定为true，生成的查询计划会有两个MRJob。第一个MRJob中，Map的输出结果集合会随机分布到Reduce中，每个Reduce做部分聚合操作，并输出结果，这样处理的结果是相同的GroupByKey有可能被分发到不同的Reduce中，从而达到负载均衡的目的;第二个MRJob再根据预处理的数据结果按照GroupByKey分布到Reduce中(这个过程可以保证相同的GroupByKey被分布到同一个Reduce中)，最后完成最终的聚合操作。

4.每个MapReduce作业的任务可以申请的内存资源数量

SETmapreduce.map.memory.mb=2048;

每个MapReduce作业的map任务可以申请的内存资源数量

SETmapreduce.reduce.memory.mb=8192;

每个MapReduce作业的reduce任务可以申请的内存资源数量

5.对于简单的不需要聚合的类似SELECT

from LIMITn语句，不需要起MapReducejob，直接通过Fetchtask获取数据

sethive.fetch.task.conversion=more;

合并小文件

6.hive.merge.mapredfiles(默认为false)

正常的map-reducejob后，是否启动mergejob来合并reduce端输出的结果，建议开启

setmapred.max.split.size=524288000;

setmapred.min.split.size.per.node=471859200;

setmapred.min.split.size.per.rack=471859200;

sethive.hadoop.supports.splittable.combineinputformat=true;

sethive.input.format=org.apache.hadoop.hive.ql.io.CombineHiveInputFormat;

注：第四个参数存在其他参数才能生效

7.设置参数不走map-reduce

sethive.fetch.task.conversion=more;

8.hive动态分区参数设置

ive.exec.dynamic.partition=true

默认值：false

描述：是否允许动态分区

hive.exec.dynamic.partition.mode=nonstrict

默认值：strict

描述：strict是避免全分区字段是动态的，必须有至少一个分区字段是指定有值的

设置如下参数配置动态分区的使用环境：

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

默认值：100

描述：eachmapperorreducer可以创建的最大动态分区数

hive.exec.max.dynamic.partitions=1000

默认值：1000

描述：一个DML操作可以创建的最大动态分区数

hive.exec.max.created.files=100000

默认值：100000

描述：一个DML操作可以创建的文件数

=============================================================================================================

hive.exec.reducers.bytes.per.reducer

默认值：1000000000(1G)

说明：每个reduce的接受的数据量

如果送到reduce的数据为10G,那么将生成10个reduce任务

hive.exec.reducers.max

默认值：999

说明：reduce的最大个数

hive.cli.print.header

目前值：fasle

说明：可以控制在处理中是否显示表列名(就是查询结果)

mapred.reduce.tasks

默认值：-1

说明：每个任务reduce的默认值

-1代表自动根据作业的情况来设置reduce的值

hive.cli.print.current.db

默认值：false

说明：开启这个属性可以再CLI提示符前打印出当前所在的数据库名

hive.cli.prompt

默认值：hive

说明：应该就是设置“hive”为启动cli的命令

hive.cli.pretty.output.num.cols

默认值：-1

说明：根据百度翻译，意思应该是根据表的列数，和你终端的宽度，自动设置你数据展现的格式。

hive.exec.scratchdir

集群值：/tmp/hive-${user.name}

说明：HDFS路径，用于存储不同map/reduce阶段的执行计划和这些阶段的中间输出结果。

hive.exec.local.scratchdir

集群值：/tmp/${user.name}

说明：Hive默认的数据文件存储路径，通常为HDFS可写的路径。

hive.test.mode

默认值：false

说明：是否以测试模式运行Hive

hive.test.mode.prefix

默认值：test_

说明：Hive测试模式的前缀。

hive.test.mode.samplefreq

默认值：32

说明：Hive测试模式取样的频率，即每秒钟取样的次数。

hive.test.mode.nosamplelist

说明：Hive测试模式取样的排除列表，以逗号分隔。

hive.metastore.uris

说明：Hive元数据的URI，多个thrift://地址，以英文逗号分隔。

javax.jdo.option.ConnectionURL

集群值：jdbc:derby:;databaseName=metastore_db;create=true

说明：元数据库的连接URL。

javax.jdo.option.DetachAllOnCommit

说明：事务提交后detach所有提交的对象，默认是true;

javax.jdo.option.NonTransactionalRead

说明：是否允许非事务的读，默认是true;

javax.jdo.option.ConnectionUserName：username，默认APP;

javax.jdo.option.ConnectionPassword：password，默认mine;

javax.jdo.option.Multithreaded：是否支持并发访问metastore，默认是true;

datanucleus.connectionPoolingType：使用连接池来访问JDBCmetastore，默认是DBCP;

datanucleus.validateTables：检查是否存在表的schema，默认是false;

datanucleus.validateColumns：检查是否存在列的schema，默认false;

datanucleus.validateConstraints：检查是否存在constraint的schema，默认false;

datanucleus.stroeManagerType：元数据存储类型，默认rdbms;

datanucleus.autoCreateSchema：在不存在时是否自动创建必要的schema，默认是true;

datanucleus.aotuStartMechanismMode：如果元数据表不正确，抛出异常，默认是checked;

datanucleus.transactionIsolation：默认的事务隔离级别，默认是read-committed;

datanucleus.cache.level2：使用二级缓存，默认是false;

datanucleus.cache.level2.type：二级缓存的类型，有两种，SOFT:软引用，WEAK:弱引用，默认是SOFT;

datanucleus.identifierFactory：id工厂生产表和列名的名字，默认是datanucleus;

datanucleus.plugin.pluginRegistryBundleCheck：当plugin被发现并且重复时的行为，默认是LOG;

hive.metastroe.warehouse.dir

说明：数据仓库的位置，默认是/user/hive/warehouse;

hive.metastore.execute.setugi：非安全模式，设置为true会令metastore以客户端的用户和组权限执行DFS操作，默认是false，这个属性需要服务端和客户端同时设置;

hive.metastore.event.listeners：metastore的事件监听器列表，逗号隔开，默认是空;

hive.metastore.partition.inherit.table.properties：当新建分区时自动继承的key列表，默认是空;

hive.metastore.end.function.listeners：metastore函数执行结束时的监听器列表，默认是空;

hive.metadata.move.exported.metadata.to.trash

说明：猜测，默认值是空。应该是垃圾站，如果垃圾站被清，元数据都会被清掉。

hive.metastore.partition.name.whitelist.pattern

说明：猜测，默认值是空。应该是如果设置了规则，分区名称将会按照你的正则规则去匹配。不匹配会被拒绝创建。

hive.metastore.disallow.incompatible.col.type.change

说明:额，集群值是空。描述中大概意思是，如果开启(默认false)则更改表字段的类型到一个不兼容的新类型是不允许的。RCFile默认SerDe(columnarserde)序列化的值在这样一种方式下数据类型可以转换成字符串的任何类型。地图也是序列化为一个字符串，它可以作为一个字符串读取。然而，任何二进制序列化，都是不行的。当ALTERTABLE尝试访问旧分区是会被阻止的。更多细节见hive-4409。

原始的类型，如int，string，bigint，等相互兼容，不阻止。

好吧。。。只能翻译成这样了。。。

hive.metastore.end.function.listeners：metastore函数执行结束时的监听器列表，默认是空;

hive.metastore.event.expiry.duration：事件表中事件的过期时间，默认是0;

hive.metastore.event.clean.freq：metastore中清理过期事件的定时器的运行周期，默认是0;

hive.metastore.connect.retries：创建metastore连接时的重试次数，默认是5;

hive.metastore.failure.retries：创建metastore连接时的失败重试次数，默认是3;

hive.metastore.client.connect.retry.delay：客户端在连续的重试连接等待的时间，默认1;

hive.metastore.client.socket.timeout：客户端socket超时时间，默认20秒;

hive.metastore.rawstore.impl：原始metastore的存储实现类，默认是org.apache.hadoop.hive.metastore.ObjectStore;

hive.metastore.batch.retrieve.max：在一个batch获取中，能从metastore里取出的最大记录数，默认是300，集群设置值是1000;

hive.default.fileformat

说明：Hive默认的输出文件格式，与创建表时所指定的相同，可选项为'TextFile'(默认)、'SequenceFile'或者'RCFile'。

hive.default.rcfile.serde：hive默认的RCFILESerDe格式默认：org.apache.hadoop.hive.serde2.columnar.ColumnarSerDe;

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

hive.map.aggr说明：决定是否可以在Map端进行聚合操作，默认true;

hive.groupby.skewindata说明：决定groupby操作是否支持倾斜的数据。默认是false;

hive.optimize.multigroupby.common.distincts

说明：这个应该是如果一张表的查询用到相同的distinct字段，可以写成如下格式：

fromsrc

insertoverwritetabledest1selectcol1,count(distinctcolx)groupbycol1

insertoverwritetabledest2selectcol2,count(distinctcolx)groupbycol2;

也就是相当于一表查询，多表插入那种吧。默认是true

hive.groupby.mapaggr.checkinterval说明：对于GroupBy操作的Map聚合的检测时间，以毫秒为单位。默认100000

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

hive.mapjoin.followby.map.aggr.hash.percentmemory：map端聚合时hash表的内存占比，该设置约束groupby在mapjoin后进行，否则使用hive.map.aggr.hash.percentmemory来确认内存占比，默认值0.3;

hive.map.aggr.hash.force.flush.memeory.threshold：map端聚合时hash表的最大可用内存，如果超过该值则进行flush数据，默认是0.9;

hive.map.aggr.hash.percentmemory：map端聚合时hash表所占用的内存比例，默认0.5，这个在map端聚合开启后使用。

hive.session.history.enabled设置为true，则会初始化日志文件,默认为false;

hive.map.aggr.hash.min.reductionHiveMap端聚合的哈稀存储的最小reduce比例。默认0.5;

hive.optimize.index.filter：自动使用索引，默认不开启false;

hive.optimize.index.groupby：是否使用聚集索引优化group-by查询，默认关闭false;

hive.optimize.ppd：是否支持谓词下推，默认开启;所谓谓词下推，将外层查询块的WHERE子句中的谓词移入所包含的较低层查询块(例如视图)，从而能够提早进行数据过滤以及有可能更好地利用索引。

hive.optimize.ppd.storage：谓词下推开启时，谓词是否下推到存储handler，默认开启，在谓词下推关闭时不起作用;

hive.ppd.recognizetransivity：在等值join条件下是否产地重复的谓词过滤器，默认开启;

hive.optimize.groupby：在做分区和表查询时是否做分桶groupby，默认开启true;

hive.optimize.skewjoin.compiletime：默认false，这个，真没看懂百度翻译。。。。

hive.optimize.union.remove：默认false，这个，没看懂百度翻译。。。。

hive.mapred.supports.subdirectories：默认false，哎。。同上

hive.multigroupby.singlemr：将多个groupby产出为一个单一map/reduce任务计划，当然约束前提是groupby有相同的key，默认是false;

hive.map.groupby.sorted：默认false，看不懂。。

hive.map.groupby.sorted.testmode：默认false，看不懂。。

hive.new.job.grouping.set.cardinality：默认30，看不懂。。

hive.join.emit.interval：在发出join结果之前对join最右操作缓存多少行的设定，默认1000;hivejira里有个对该值设置太小的bugfix;

hive.join.cache.size：在做表join时缓存在内存中的行数，默认25000;

hive.smbjoin.cache.rows：在做表smb(smb不知道是啥，Sort-Merge-Bucket)join时缓存在内存中的行数，默认10000;

hive.optimize.skewjoin：

说明：是否开启数据倾斜的join优化，默认不开启false;

hive.skewjoin.key：

说明：判断数据倾斜的阈值，如果在join中发现同样的key超过该值则认为是该key是倾斜的joinkey，默认是100000;

hive.skewjoin.mapjoin.map.tasks：

说明：在数据倾斜join时mapjoin的map数控制，默认是10000;

hive.skewjoin.mapjoin.min.split：

说明：数据倾斜join时mapjoin的map任务的最小split大小，默认是33554432，该参数要结合上面的参数共同使用来进行细粒度的控制;

hive.mapred.mode：

说明：hive操作执行时的模式，默认是nonstrict非严格模式，如果是strict模式，很多有风险的查询会被禁止运行，比如笛卡尔积的join和动态分区;

hive.enforce.bucketmapjoin：默认false，应该是跟桶有关的join设置;

hive.exec.script.maxerrsize：当用户调用transform或者map或者reduce执行脚本时，最大的序列化错误数，默认100000，一般也不用修改;

hive.exec.script.allow.partial.consumption：hive是否允许脚本不从标准输入中读取任何内容就成功退出，默认关闭false;

hive.script.operator.id.env.var：在用户使用transform函数做自定义map/reduce时，存储唯一的脚本标识的环境变量的名字，默认HIVE_SCRIPT_OPERATOR_ID;

hive.script.operator.truncate.env：默认false，知道干啥的。

hive.exec.compress.output：

说明：一个查询的最后一个map/reduce任务输出是否被压缩的标志，默认为false，但是一般会开启为true，好处的话，节省空间不说，在不考虑cpu压力的时候会提高io;

hive.exec.compress.intermediate：

说明：类似上个，在一个查询的中间的map/reduce任务输出是否要被压缩，默认false;

hive.exec.parallel：

说明：hive的执行job是否并行执行，默认不开启false，在很多操作如join时，子查询之间并无关联可独立运行，这种情况下开启并行运算可以大大加速;

hive.exec.parallel.thread.number：

说明：在并行执行时的最大job数，默认是8;

hive.exec.rowoffset：是否提供行偏移量的虚拟列，默认是false不提供，Hive有两个虚拟列:一个是INPUT__FILE__NAME,表示输入文件的路径，另外一个是BLOCK__OFFSET__INSIDE__FILE，表示记录在文件中的块偏移量，这对排查出现不符合预期或者null结果的查询是很有帮助的;

hive.task.progress：控制hive是否在执行过程中周期性的更新任务进度计数器，开启这个配置可以帮助jobtracker更好的监控任务的执行情况，但是会带来一定的性能损耗，当动态分区标志hive.exec.dynamic.partition开启时，本配置自动开启;

hive.hwi.war.file：hive在web接口是的war文件的路径，默认是lib/hive-hwi-xxxx(version).war;

hive.hwi.listen.host：hwi监听的host地址，默认是0.0.0.0;

hive.hwi.listen.port：hwi监听的端口，默认是9999;

hive.exec.pre.hooks：执行前置条件，一个用逗号分隔开的实现了org.apache.hadoop.hive.ql.hooks.ExecuteWithHookContext接口的javaclass列表，配置了该配置后，每个hive任务执行前都要执行这个执行前钩子，默认是空;

hive.metastore.init.hooks：一个逗号分隔的列表钩子被调用，在hmshandler初始化开始。aninit钩指定名称为java类来扩展org.apache.hadoop.hive.metastore.metastoreinitlistener。

hive.client.stats.publishers：做count的job的统计发布类列表，由逗号隔开，默认是空;必须实现org.apache.hadoop.hive.ql.stats.ClientStatsPublisher接口;

hive.merge.mapfiles：

说明：在只有map的作业结束时合并小文件，默认开启true;

hive.merge.mapredfiles：

说明：在一个map/reduce作业结束后合并小文件，默认不开启false;

hive.heartbeat.interval：发送心跳的时间间隔，在mapjoin和filter操作中使用，默认1000;

hive.merge.size.per.task：疑问一体化集群没有生效。

说明：作业结束时合并文件的大小，默认256MB;

hive.merge.smallfiles.avgsize：

说明：在作业输出文件小于该值时，起一个额外的map/reduce作业将小文件合并为大文件，小文件的基本阈值，设置大点可以减少小文件个数，需要mapfiles和mapredfiles为true，默认值是16MB;

****************************************mapjoin 的参数**********************************************************

hive.mapjoin.smalltable.filesize：输入表文件的mapjoin阈值，如果输入文件的大小小于该值，则试图将普通join转化为mapjoin，默认25MB;

hive.ignore.mapjoin.hint：忽略mapjoin暗示

hive.mapjoin.localtask.max.memory.usage：mapjoin本地任务执行时hash表容纳key/value的最大量，超过这个值的话本地任务会自动退出，默认是0.9;

hive.mapjoin.followby.gby.localtask.max.memory.usage：类似上面，只不过是如果mapjoin后有一个groupby的话，该配置控制类似这样的query的本地内存容量上限，默认是0.55;

hive.mapjoin.check.memory.rows：在运算了多少行后执行内存使用量检查，默认100000;

hive.auto.convert.join：根据输入文件的大小决定是否将普通join转换为mapjoin的一种优化，默认不开启false;

hive.auto.convert.join.noconditionaltask：

9. 0.11中新增了一个优化参数“hive.auto.convert.join.noconditionaltask”，默认开启，它对N-Way Join会做优化，枚举所有N-1表size总和，判断是否小于参数hive.auto.convert.join.noconditionaltask.size(默认10MB)，如果小于该值，则会自动转化成Map-Side Join，将N-1张表HashTable打包DistributedCache上传至HDFS分发至各Task节点和Factor Table做Join，从而避免了通常Reduce-side Join会起N-1个MR Job的开销，但是这个参数还是显得过于乐观了，不同于之前的Map Join优化策略(hive.auto.convert.join)，它在替换了conditional task后，没有相应的common-join backup task，从而一旦由于某种原因MapRedLocalTask fail，就会导致整个Job fail, 而0.9中会起backup task来做alternative，所以从Job Level看还是正确执行的，只是执行时间变长了。为保证语句执行的正确性，我们默认关闭此优化参数。

hive.auto.convert.join.noconditionaltask.size：多个mapjoin转换为1个时，所有小表的文件大小总和的最大值。

例如，一个大表顺序关联3个小表a(10M), b(8M),c(12M)，如果hive.auto.convert.join.noconditionaltask.size的值：

1. 小于18M，则无法合并mapjoin，必须执行3个mapjoin;2. 大于18M小于30M，则可以合并a和b表的mapjoin，所以只需要执行2个mapjoin;3. 大于30M，则可以将3个mapjoin都合并为1个。

合并mapjoin有啥好处呢因为每个mapjoin都要执行一次map，需要读写一次数据，所以多个mapjoin就要做多次的数据读写，合并mapjoin后只用读写一次，自然能大大加快速度。但是执行map是内存大小是有限制的，在一次map里对多个小表做mapjoin就必须把多个小表都加入内存，为了防止内存溢出，所以加了hive.auto.convert.join.noconditionaltask.size参数来做限制。不过，这个值只是限制输入的表文件的大小，并不代表实际mapjoin时hashtable的大小。

我们可以通过explain查看执行计划，来看看mapjoin是否生效。

*****************************************************************************************************************

hive.script.auto.progress：默认false。hive的transform/map/reduce脚本执行时是否自动的将进度信息发送给TaskTracker来避免任务没有响应被误杀，本来是当脚本输出到标准错误时，发送进度信息，但是开启该项后，输出到标准错误也不会导致信息发送，因此有可能会造成脚本有死循环产生，但是TaskTracker却没有检查到从而一直循环下去;

hive.script.serde：

用户脚本转换输入到输出时的SerDe约束，默认是org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe;

hive.binary.record.max.length：默认1000,。从一个二进制流读取和对待每一hive.binary.record.max.length字节作为记录。在流的结尾可以有小于hive.binary.record.max.length字节最后一个记录

hive.server2.max.start.attempts： 默认30，感觉没啥用，应该是HiveServer2退出前，每60秒尝试重启一次，持续30分钟。

hive.server2.transport.mode：默认值为binary(TCP)，可选值HTTP。

hive.server2.thrift.http.port：HTTP的监听端口，默认值为10001。

hive.server2.thrift.http.path：服务的端点名称，默认为cliservice。

hive.server2.thrift.http.min.worker.threads：服务池中的最小工作线程，默认为5。

hive.server2.thrift.http.max.worker.threads：服务池中的最小工作线程，默认为500。

hive.script.recordreader：

从脚本读数据的时候的默认reader，默认是org.apache.hadoop.hive.ql.exec.TextRecordReader;

stream.stderr.reporter.prefix：默认‘reporter: '。感觉没啥用， 加此前缀可在标准的Streaming jobs的日志中记录计数器和标准信息

stream.stderr.reporter.enabled：默认true。 应该是streaming job时展现streaing的工作状态和技术信息。

hive.script.recordwriter：写数据到脚本时的默认writer，默认org.apache.hadoop.hive.ql.exec.TextRecordWriter;

hive.input.format：输入格式，默认是org.apache.hadoop.hive.ql.io.CombineHiveInputFormat，如果出现问题，可以改用org.apache.hadoop.hive.ql.io.HiveInputFormat; 这个你们应该熟悉哦

hive.udtf.auto.progress：UDTF执行时hive是否发送进度信息到TaskTracker，默认是false;

hive.mapred.reduce.tasks.speculative.execution：reduce任务推测执行是否开启，默认是true;

hive.exec.counters.pull.interval：运行中job轮询JobTracker的时间间隔，设置小会影响JobTracker的load，设置大可能看不出运行任务的信息，要去平衡，默认是1000;

hive.querylog.location:集群值是：/tmp/${user.name} 。 hive运行时日志文件的位置。

hive.querylog.enable.plan.progress：默认true。每次检查作业的进度时是否记录计划的进度到日志中。这些日志保存在hive.querylog.location指定的位置(Hive-0.10版本开始)。

hive.querylog.plan.progress.interval：默认：60000。记录计划执行进度的时间间隔，单位是毫秒。如果map或者reduce的进度有整数百分比的变化，则不考虑该值而该进度被记入日志。

hive.enforce.bucketing：数据分桶是否被强制执行，默认false，如果开启，则写入table数据时会启动分桶。

hive.enforce.sorting：开启强制排序时，插数据到表中会进行强制排序，默认false;

hive.optimize.bucketingsorting：默认true。 百度翻译没看懂。。。。

If hive.enforce.bucketing or hive.enforce.sorting is true, dont create a reducer for enforcing

bucketing/sorting for queries of the form:

insert overwrite table T2 select * from T1;

where T1 and T2 are bucketed/sorted by the same keys into the same number of buckets.

你们可以看看。。。。

hive.enforce.sortmergebucketmapjoin： 默认false 。不懂。。。。

hive.auto.convert.sortmerge.join：默认false。应该是如果联接表通过sort-merge join的标准，将自动转换为一个sort-merge join。

hive.auto.convert.sortmerge.join.bigtable.selection.policy：

默认：org.apache.hadoop.hive.ql.optimizer.AvgPartitionSizeBasedBigTableSelectorForAutoSMJ

这个字太多。看图吧。。。。。。

hive.auto.convert.sortmerge.join.to.mapjoin：默认false，英文描述很无助。。。。。。。。。。。。。

hive.metastore.ds.connection.url.hook：查找JDO连接url时hook的名字，默认是javax.jdo.option.ConnectionURL;

hive.metastore.ds.retry.attempts：当出现连接错误时重试连接的次数，默认是1次;

hive.metastore.ds.retry.interval：metastore重试连接的间隔时间，默认1000毫秒;

hive.metastore.server.min.threads：在thrift服务池中最小的工作线程数，默认是200;

hive.metastore.server.max.threads：最大线程数，默认是100000;

hive.metastore.server.tcp.keepalive：metastore的server是否开启长连接，长连可以预防半连接的积累，默认是true;

hive.metastore.sasl.enabled：metastore thrift接口的安全策略，开启则用SASL加密接口，客户端必须要用Kerberos机制鉴权，默认是不开启false;

hive.metastore.thrift.framed.transport.enabled：默认false，大概是用标准的TTransport 。如果是true， metastore thrift接口将会使用TFramedTransport。

hive.metastore.kerberos.keytab.file：在开启sasl后kerberos的keytab文件存放路径，默认是空;

hive.metastore.kerberos.principal：

kerberos的principal，_HOST部分会动态替换，默认是hive-metastore/_HOST@EXAMPLE.COM;

hive.cluster.delegation.token.store.class：

代理token的存储实现类，默认是org.apache.hadoop.hive.thrift.MemoryTokenStore，可以设置为org.apache.hadoop.hive.thrift.ZooKeeperTokenStore来做负载均衡集群;

hive.cluster.delegation.token.store.zookeeper.connectString：zk的token存储连接串，默认是localhost:2181;

hive.cluster.delegation.token.store.zookeeper.znode：token存储的节点跟路径，默认是/hive/cluster/delegation;

hive.cluster.delegation.token.store.zookeeper.acl：

token存储的ACL，默认是sasl:hive/host1@example.com:cdrwa,sasl:hive/host2@example.com:cdrwa;

hive.metastore.cache.pinobjtypes：在cache中支持的metastore的对象类型，由逗号分隔，默认是Table,StorageDescriptor,SerDeInfo,Partition,Database,Type,FieldSchema,Order;

hive.optimize.reducededuplication：如果数据已经根据相同的key做好聚合，那么去除掉多余的map/reduce作业，此配置是文档的推荐配置，建议打开，默认是true;

hive.optimize.correlation ： 默认false。利用内部查询的相关性。不明白。。。。exploit intra-query correlations.

hive.optimize.reducededuplication.min.reducer：默认是4. 看不懂。。。。。

******************************动态分区参数******************************************

hive.exec.dynamic.partition：在DML/DDL中是否支持动态分区，默认false;

hive.exec.dynamic.partition.mode：默认strict，在strict模式下，动态分区的使用必须在一个静态分区确认的情况下，其他分区可以是动态;

hive.exec.max.dynamic.partitions：动态分区的上限，默认1000;

hive.exec.max.dynamic.partitions.pernode：每个mapper/reducer节点可以创建的最大动态分区数，默认100;

hive.exec.default.partition.name：当动态分区启用时，如果数据列里包含null或者空字符串的话，数据会被插入到这个分区，默认名字是__HIVE_DEFAULT_PARTITION__;

******************************************************************************************

hive.exec.max.created.files：一个mapreduce作业能创建的HDFS文件最大数，默认是100000;

hive.stats.dbclass：存储hive临时统计信息的数据库，默认是jdbc:derby;

hive.stats.autogather：在insert overwrite命令时自动收集统计信息，默认开启true;

hive.stats.jdbcdriver：数据库临时存储hive统计信息的jdbc驱动;

hive.stats.dbconnectionstring：

临时统计信息数据库连接串，默认jdbc:derby:databaseName=TempStatsStore;create=true;

hive.stats.defaults.publisher：如果dbclass不是jdbc或者hbase，那么使用这个作为默认发布，必须实现StatsPublisher接口，默认是空;

hive.stats.jdbc.timeout：jdbc连接超时配置，默认30秒;

hive.stats.retries.max：当统计发布合聚集在更新数据库时出现异常时最大的重试次数，默认是0，不重试;

hive.stats.retries.wait：重试次数之间的等待窗口，默认是3000毫秒;

hive.stats.reliable：默认是false，翻译是，无论查询是否失败。统计数据不能完全准确的收集;如果设置成true，reading/writing from/into一个分区都可能会失败，因为数据无法准确计算。(这个应该是跟踪问题的时用的参数。。。)

hive.stats.collect.tablekeys：默认false。英文看不到太懂。应该是无论是join或者group by 的keys 都是由执行计划生成和维护的。。。这个有用的访问识别表是否应该被分桶。。。好吧。很乱。

hive.stats.collect.scancols：默认false。应该是执行计划中跟踪列的访问，在表的访问中减少无用的列。

hive.stats.ndv.error：默认20.0。百分比表示的标准误差。提供了一个精度和计算成本之间的权衡，一个较低的值的错误指示更高的精度和更高的计算成本。 (我的理解是默认值低了，错误的指示就高了，但是计算成本也高了)。

hive.stats.key.prefix.max.length：默认200。 翻译看不明白。。。。

hive.support.concurrency：hive是否支持并发，默认是false，支持读写锁的话，必须要起zookeeper;

hive.lock.numretries：获取锁时尝试的重试次数，默认是100;

hive.unlock.numretries：获取解锁时尝试的重试次数，默认是100;

hive.lock.sleep.between.retries：在重试间隔的睡眠时间，默认60秒;

hive.zookeeper.quorum：zk地址列表，默认是空;

hive.zookeeper.client.port：zk服务器的连接端口，默认是2181;

hive.zookeeper.session.timeout：zk客户端的session超时时间，默认是600000;

hive.zookeeper.namespace：在所有zk节点创建后的父节点，默认是hive_zookeeper_namespace;

hive.zookeeper.clean.extra.nodes：在session结束时清除所有额外node;

fs.har.impl：访问Hadoop Archives的实现类，低于hadoop 0.20版本的都不兼容，默认是org.apache.hadoop.hive.shims.HiveHarFileSystem;

hive.archive.enabled：是否允许归档操作，默认是false;

hive.fetch.output.serde：FetchTask序列化fetch输出时需要的SerDe，默认是org.apache.hadoop.hive.serde2.DelimitedJSONSerDe;

hive.exec.mode.local.auto：是否由hive决定自动在local模式下运行，默认是false;

hive.exec.drop.ignorenoneexistent：在drop表或者视图时如果发现表或视图不存在，是否报错，默认是true;

hive.exec.show.job.failure.debug.info：在作业失败时是否提供一个任务debug信息，默认true;

hive.auto.progress.timeout：运行自动progressor的时间间隔，默认是0等价于forever;

HBase存储处理器参数

hive.hbase.wal.enabled：写入hbase时是否强制写wal日志，默认是true;

hive.table.parameters.default：新建表的属性字段默认值，默认是empty空;

hive.entity.separator：用于构造表和分区的名称的分隔符。

hive.ddl.createtablelike.properties.whitelist：当执行创建表时，要复制的表属性。默认是空;

hive.variable.substitute：是否支持变量替换，如果开启的话，支持语法如${var} ${system:var}和${env.var}，默认是true;

hive.variable.substitute.depth：默认40。字面翻译替换引擎的最大替换。

hive.conf.validation：默认ture。应该是是否检查注册的hive配置的类型。

hive.security.authorization.enabled：hive客户端是否认证，默认是false;

hive.security.authorization.manager：

hive客户端认证的管理类，默认是org.apache.hadoop.hive.ql.security.authorization.DefaultHiveAuthorizationProvider;用户定义的要实现org.apache.hadoop.hive.ql.security.authorization.HiveAuthorizationProvider;

hive.security.metastore.authorization.manager：metastore的认证管理类，默认是org.apache.hadoop.hive.ql.security.authorization.DefaultHiveMetastoreAuthorizationProvider;用户定义的必须实现org.apache.hadoop.hive.ql.security.authorization.HiveMetastoreAuthorizationProvider接口;接口参数要包含org.apache.hadoop.hive.ql.security.authorization.StorageBasedAuthorizationProvider接口;使用HDFS的权限控制认证而不是hive的基于grant的方式;

hive.security.authenticator.manager：hive客户端授权的管理类，默认是org.apache.hadoop.hive.ql.security.HadoopDefaultAuthenticator;用户定义的需要实现org.apache.hadoop.hive.ql.security.HiveAuthenticatorProvider;

hive.security.metastore.authenticator.manager：metastore端的授权管理类，默认是org.apache.hadoop.hive.ql.security.HadoopDefaultMetastoreAuthenticator，自定义的必须实现org.apache.hadoop.hive.ql.security.HiveAuthenticatorProvider接口;

hive.security.authorization.createtable.user.grants：当表创建时自动授权给用户，默认是空;

hive.security.authorization.createtable.group.grants：同上，自动授权给组，默认是空;

hive.security.authorization.createtable.role.grants：同上，自动授权给角色，默认是空;

hive.security.authorization.createtable.owner.grants：同上，自动授权给owner，默认是空;

hive.security.command.whitelist：hive授权用户执行的SQL命令列表，用逗号分隔。默认是set,reset,dfs,add,delete;

hive.conf.restricted.list：运行时的不可变配置列表，逗号分隔。默认是空;

hive.metastore.authorization.storage.checks：在做类似drop partition操作时，metastore是否要认证权限，默认是false;

hive.error.on.empty.partition：在遇到结果为空的动态分区时是否报错，默认是false;

hive.index.compact.file.ignore.hdfs：在索引文件中存储的hdfs地址将在运行时被忽略，如果开启的话;如果数据被迁移，那么索引文件依然可用，默认是false;

hive.optimize.index.filter.compact.minsize：压缩索引自动应用的最小输入大小，默认是5368709120;

hive.optimize.index.filter.compact.maxsize：同上，相反含义，如果是负值代表正无穷，默认是-1;

hive.index.compact.query.max.size：一个使用压缩索引做的查询能取到的最大数据量，默认是10737418240 个byte;负值代表无穷大;

hive.index.compact.query.max.entries：使用压缩索引查询时能读到的最大索引项数，默认是10000000;负值代表无穷大;

hive.index.compact.binary.search：在索引表中是否开启二分搜索进行索引项查询，默认是true;

hive.exim.uri.scheme.whitelist：在导入导出数据时提供的一个白名单列表，列表项之间由逗号分隔，默认hdfs,pfile;

hive.lock.mapred.only.operation：控制是否在查询时加锁，默认是false;

**************************************LIMIT参数**************************************

hive.limit.row.max.size：字面意思理解就是在使用limit做数据的子集查询时保证的最小行数据量，默认是100000;

hive.limit.optimize.limit.file：使用简单limit查询数据子集时，可抽样的最大文件数，默认是10;

hive.limit.optimize.enable：使用简单limit抽样数据时是否开启优化选项，默认是false，关于limit的优化问题，在hive programming书中解释的是这个feature有drawback，对于抽样的不确定性给出了风险提示;

hive.limit.optimize.fetch.max：使用简单limit抽样数据允许的最大行数，默认50000，查询query受限，insert不受影响;

hive.limit.pushdown.memory.usage：默认0.3f。 应该是查询分配给hash RS算子最大内存;

hive.rework.mapredwork：是否重做mapreduce，默认是false;

hive.exec.concatenate.check.index：如果设置为true，那么在做ALTER TABLE tbl_name CONCATENATE on a table/partition(有索引) 操作时，抛出错误;可以帮助用户避免index的删除和重建;

hive.sample.seednumber：用来区分抽样的数字，默认是0;

hive.io.exception.handlers：io异常处理handler类列表，默认是空，当record reader发生io异常时，由这些handler来处理异常;

hive.transform.escape.input：默认false。 这个参数避免了特殊字符(换行符、回车符和标签)被传递给用户脚本时带来的影响。这可以然后hive表里包含含特俗字符的数据。

hive.exec.rcfile.use.explicit.header：默认为ture。应该是跟文件的格式有关

hive.exec.orc.dictionary.key.size.threshold：默认0.8。应该是如果在字典中的键数比例大于此部分的非空行总数，则关闭字典编码。1是默认一直使用字典编码。

hive.multi.insert.move.tasks.share.dependencies：默认false。不是太懂。如果这个参数被设置，多插入查询在结束前只会执行一次。优点：一旦启用并发，一旦查询完成

hive.server2.async.exec.wait.queue.size：默认100。在HiveServer2异步线程池等待队列的大小。打这个限制后，异步线程池会拒绝新的请求。

hive.server2.thrift.port：默认10000。HiveServer2 Thrift接口的端口号。可以通过设置$HIVE_SERVER2_THRIFT_PORT重写。

hive.server2.thrift.bind.host：绑定主机上运行HiveServer2 Thrift接口的端口。可以通过设置$hive_server2_thrift_bind_host重写。该值默认为localhost，如果需要在其它机器远程访问Hive，则需要将它改成IP地址。

hive.server2.authentication:授权模式，默认NONE，可选的包括NOSASL、KERBEROS、LDAP、PAM和CUSTOM等授权模式。

客户端身份验证类型：

NONE：没有验证检查

LDAP：LDAP / AD认证

Kerberos：Kerberos/GSSAPI认证

自定义：自定义身份验证提供程序(使用hive.server2.custom.authentication.class的属性)

hive.server2.custom.authentication.class：

用户授权类，实现org.apache.hive.service.auth.PasswdAuthenticationProvider接口

hive.server2.authentication.kerberos.principal：Kerberos主服务器。默认空。

hive.server2.authentication.kerberos.keytab：服务principal的keytab。默认空。

hive.server2.authentication.ldap.url：LDAP的URL。默认空。

hive.server2.authentication.ldap.baseDN：基于DN的LDAP。默认空。

hive.server2.enable.doAs：匿名连接用户，默认true。

hive.server2.table.type.mapping：默认CLASSIC。应该是此设置反映了HiveServer如何向JDBC和其他客户端提供表的类型，实现可用表和表类型的检索。

HIVE：显示hive自带的表类型managed_table，external_table，virtual_view。

CLASSIC：更一般类型，如表和视图。

hive.server2.thrift.sasl.qop：SASL QOP值;设置为下列值使更高水平的客户通信保护Hive Server2。

"auth" - 国际认证和完整性保护(默认)

"auth-int" - 身份验证和完整性保护

"auth-conf" -身份验证和完整性和机密性保护

这个只支持在Kerberos作为HS2客户端的授权

评论内容：