Hive調優技巧彙總

時間  2019-12-02
標籤 hive 技巧 彙總 欄目 Hadoop 简体版
原文   原文鏈接

參考：http://blog.csdn.net/beckham008/article/details/23741151?utm_source=tuicool&utm_medium=referralphp

1.設置合理solt數html

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 .設置任務名稱，方便查找監控 
  SET mapred.job.name=P_DWA_D_IA_S_USER_PROD; 
  
 
  2 .決定是否能夠在 Map 端進行聚合操做 
  set hive.map.aggr=true; 
  
 
  3 .有數據傾斜的時候進行負載均衡 
  set hive.groupby.skewindata=true; 
  
 
  H iveQL 去重操做 
  和 SQL同樣，HiveQL中一樣支持DISTINCT操做，以下示例： 
  ( 1) SELECT count(DISTINCT uid) FROM log 
  ( 2) SELECT ip, count(DISTINCT uid) FROM log GROUP BY ip 
  ( 3) SELECT ip, count(DISTINCT uid, uname) FROMlog GROUP BY ip 
  ( 4) SELECT ip, count(DISTINCTuid), count(DISTINCT uname) FROMlog GROUP BY ip 
  
 
  當 咱們使用Hive QL中的去重關鍵字DISTINCT時，須要注意的一點是： 
  在 多個列上進行的去重操做與hive環境變量hive.groupby.skewindata存在關係。 
  當 hive.groupby.skewindata=true時，hive不支持多列上的去重操做，並報錯： 
  E rror in semantic analysis: DISTINCT on different columns notsupported with skew in data.  
  注 意：上面示例中的(3)不屬於多列上的DISTINCT操做。 
  
 
  G roup By 語句 
  • Map 端部分聚合：
  • 並非全部的聚合操做都須要在 Reduce 端完成，不少聚合操做均可以先在 Map 端進行部分聚合，最後在 Reduce端得出最終結果。
  • 基於 Hash
  • 參數包括：
  • hive.map.aggr = true 是否在 Map 端進行聚合，默認爲True
  • hive.groupby.mapaggr.checkinterval =100000 在 Map 端進行聚合操做的條目數目
  • 有數據傾斜的時候進行負載均衡
  • hive.groupby.skewindata = false
  • 當選項設定爲 true，生成的查詢計劃會有兩個 MR Job。第一個 MR Job 中，Map 的輸出結果集合會隨機分佈到Reduce 中，每一個 Reduce 作部分聚合操做，並輸出結果，這樣處理的結果是相同的 Group By Key有可能被分發到不一樣的 Reduce 中，從而達到負載均衡的目的；第二個 MR Job 再根據預處理的數據結果按照 Group ByKey 分佈到 Reduce 中（這個過程能夠保證相同的 Group By Key 被分佈到同一個 Reduce中），最後完成最終的聚合操做。
  4 .每一個MapReduce做業的任務能夠申請的內存資源數量 
  SET mapreduce.map.memory.mb=2048; 
  每 個MapReduce做業的map任務能夠申請的內存資源數量 
  SET mapreduce.reduce.memory.mb=8192; 
  每 個MapReduce做業的reduce任務能夠申請的內存資源數量 
  
  5.對於簡單的不須要聚合的相似SELECT <col> from <table> LIMIT n語句，不須要起MapReduce job，直接經過Fetch task獲取數據
set hive.fetch.task.conversion=more;
  
合併小文件
6. hive.merge.mapredfiles(默認爲false)
正常的map-reduce job後，是否啓動merge job來合併reduce端輸出的結果，建議開啓

set mapred.max.split.size=524288000;
set mapred.min.split.size.per.node=471859200;
set mapred.min.split.size.per.rack=471859200;
set hive.hadoop.supports.splittable.combineinputformat=true;     
set hive.input.format=org.apache.hadoop.hive.ql.io.CombineHiveInputFormat; 

注：第四個參數存在其餘參數才能生效
  

7.設置參數不走map-reduce
set hive.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
描述：each mapper or reducer能夠建立的最大動態分區數
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： 使用鏈接池來訪問JDBC metastore，默認是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）序列化的值在這樣一種方式下數據類型能夠轉換成字符串的任何類型。地圖也是序列化爲一個字符串，它能夠做爲一個字符串讀取。然而，任何二進制序列化，都是不行的。當ALTER TABLE嘗試訪問舊分區是會被阻止的。更多細節見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默認的RCFILE SerDe格式  默認：org.apache.hadoop.hive.serde2.columnar.ColumnarSerDe；
hive.fileformat.check ： Hive 是否檢查輸出的文件格式。默認true；
hive.map.aggr   • 說明：  決定是否能夠在 Map 端進行聚合操做，默認true；
hive.groupby.skewindata   • 說明：   決定 group by 操做是否支持傾斜的數據。默認是false；
hive.optimize.multigroupby.common.distincts
  •說明：這個應該是若是一張表的查詢用到相同的distinct字段，能夠寫成以下格式：
      from src
        insert overwrite table dest1 select col1, count(distinct colx) group by col1
        insert overwrite table dest2 select col2, count(distinct colx) group by col2;
也就是至關於一表查詢，多表插入那種吧。默認是true
 hive.groupby.mapaggr.checkinterval    • 說明：對 於 Group By 操做的 Map 聚合的檢測時間，以毫秒爲單位。默認100000
hive.mapred.local.mem    • 說明：  Mapper/Reducer 在本地模式的最大內存量，以字節爲單位，0爲不限制。 默認0。
hive.mapjoin.followby.map.aggr.hash.percentmemory： map端聚合時hash表的內存佔比，該設置約束group by在map join後進行，不然使用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.reduction   Hive Map 端聚合的哈稀存儲的最小 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 ：在作分區和表查詢時是否作分桶group by，默認開啓true；
hive.optimize.skewjoin.compiletime：默認false ，這個，真沒看懂百度翻譯。。。。
hive.optimize.union.remove：默認false ，這個，沒看懂百度翻譯。。。。
hive.mapred.supports.subdirectories：默認false ，哎。。同上
hive.multigroupby.singlemr： 將多個group by產出爲一個單一map/reduce任務計劃，固然約束前提是group by有相同的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；hive jira裏有個對該值設置過小的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是傾斜的join key，默認是100000；
hive.skewjoin.mapjoin.map.tasks：
•說明： 在數據傾斜join時map join的map數控制，默認是10000；
hive.skewjoin.mapjoin.min.split：
•說明： 數據傾斜join時map join的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是否在執行過程當中週期性的更新任務進度計數器，開啓這個配置能夠幫助job tracker更好的監控任務的執行狀況，可是會帶來必定的性能損耗，當動態分區標誌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接口的java class列表，配置了該配置後，每一個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後有一個group by的話，該配置控制相似這樣的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。
h ive.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 Storage Handler Parameters --> HBase存儲處理器參數

hive.hbase.wal.enabled： 寫入hbase時是否強制寫wal日誌，默認是true；
hive.table.parameters.default： 新建表的屬性字段默認值，默認是empty空；
hive.entity.separator：用於構造表和分區的名稱的分隔符。例如，@ tablename@partitionname
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客戶端的受權

關於hive server2的配置能夠參考網絡資料：


hive.metastore.schema.verification：默認是true。意思是：(強制metastore的schema一致性，開啓的話會校驗在metastore中存儲的信息的版本和hive的jar包中的版本一致性，而且關閉自動schema遷移，用戶必須手動的升級hive而且遷移schema，關閉的話只會在版本不一致時給出警告。)
這個參數在網上查好像是解決因爲hive版本引起的問題時候回改成false。因爲第一次啓動metastore服務時，mysql做爲數據源的hive數據庫內沒有生成任何表和數據，因此會出現返回的版本號爲空的狀況。咱們能夠暫時在hive.metastore.schema.verification裏設置成false，在第一次啓動自動生成了數據後，那麼就能夠將這個配置值再改回true，日後也相關無事了。
hive.plan.serialization.format：客戶端和任務節點之間的查詢計劃格式。支持兩個參數：kryo和JAVAXML。kryo是默認。
hive.server2.allow.user.substitution：默認爲true。應該是容許altername 用戶被指定爲打開一部分HiveServer2的鏈接請求。


  • 壓縮
a. 
set hive.exec.compress.intermediate=true;
set mapred.map.output.compression.codec=org.apache.hadoop.io.compress.SnappyCodec;
解釋：若是集羣具備很好的CPU性能，可是網絡帶寬有限，這兩個屬性能夠加速中間結果的交換。（若是集羣具備很高的網絡io延遲，那麼這個選項應該被打開）
測試：

Q22
Q23
Q24
未壓縮
2m9.787s
14m19.011s
4m41.635s
壓縮
2m22.371s
13m57.379s
4m43.945s
結論：性能未見明顯提高

b.
set hive.exec.compress.output=false;
set mapred.output.compression.codec=org.apache.hadoop.io.compress.DefaultCodec;
解釋：默認是使得建立的結果表是否進行壓縮，關係到可讀性


Q22
Q23
Q24
未壓縮
2m9.787s
14m19.011s
4m41.635s
壓縮
2m14.084s
13m48.921s
4m40.755s
結論:  性能未見明顯提高

c.
set hive.default.fileformat=TextFile;
解釋：默認文件類型，未測試，應該影響不大。

  • Mapper settings
a.
set mapred.max.split.size=67108864;
set mapred.min.split.size=1;
解釋：一個hive表包含的物理文件的數量與hive預測啓動多少mapper數量無關，由於hive使用HiveCombineInputFormat來合併文件。上面兩個參數是最能影響hive預測生成的mapper數量的，下降這些值會致使過多的map task，過高會致使過少的map task，系統利用率不高。兩個極端都會影響性能。對於小數據集（1-100G），128M多是個好的值。做爲預測的話，使用中等表的大小除以想要利用的集羣的map task數量。

10G Data：

Q22
Q23
Q24
8388608 (8MB)
1m40.767s
9m54.701s
4m54.342s
16777216 (16MB)
1m44.801s
10m45.015s
4m41.974s 
33554432 (32MB)
2m0.222s
12m43.198s
4m36.464s
67108864 (64MB)
2m9.787s
14m19.011s
4m41.635s
134217728 (128MB)
2m51.450s
16m3.758s
4m43.410s

結論： 10G Data, Q22/Q23 隨着mapred.max.split.size的減少而性能提高，Q24無明顯性能提高

  • Reducer Settings
a.
set hive.exec.reducers.bytes.per.reducer=256000000;
解釋：每一個reducer處理的數據大小，若是input size是10G， 設置爲1G，那麼就會啓動10個reducer

10G Data：

Q22
Q23
Q24
128000000
2m7.526s
13m44.007s
4m42.296s
256000000
2m9.787s
14m19.011s
4m41.635s
512000000
2m7.969s
13m45.184s
4m39.975s
結論： 性能未見明顯提高

b.
set hive.exec.reducers.max=99999;
解釋：可使用的最大的reducer的數量，若是配置的是負值，hive將會使用999做爲可使用的最大的reducer數量。
結論： 從日誌看，reducer數量遠小於999，所以配置這個對性能影響應該不會太大。

  • join
a.
set hive.auto.convert.join=true;
解釋: hive是否會根據輸入文件大小將普通的join轉爲mapjoin，默認是true
測試：

Q22
Q23
Q24
True
2m9.787s
14m19.011s
4m41.635s
False
9m44.347s
45m1.006s
5m23.501s
結論： Enable這個屬性可以顯著提升性能。

b. 
set hive.auto.convert.join.noconditionaltask = true;
set hive.auto.convert.join.noconditionaltask.size = 10000000;
解釋：hive.auto.convert.join.noconditionaltask.size代表能夠轉化爲MapJoin的表的大小總合。例若有A、B兩個表，他們的大小都小於該屬性值，那麼他們都會都會分別被轉化爲MapJoin，若是兩個表大小總和加起來也小於該屬性值，那麼這兩個表會被合併爲一個MapJoin。
測試：
1. 
set hive.auto.convert.join=false;
set hive.auto.convert.join.noconditionaltask = true;
 
 
 
   
   
 
     
     

       Q22 
     
 		 
     
     

       Q23 
     
 		 
     
     

       Q24 
     
 		 
   
 
   
 
     
     
 
      9m22.254s 
     
 		 
     
     
 
      44m56.032s 
     
 		 
     
     
 
      5m26.398s 
     
 		 
   
 
   
 
 2.  
 
 

 
 

 
 set hive.auto.convert.join=True; 

 
 

 
  

 

 
 set hive.auto.convert.join.noconditionaltask=false; 

 

 
  
 
 
  
 
    
    
 
      
      

        Q22 
      
 		 
      
      

        Q23 
      
 		 
      
      

        Q24 
      
 		 
    
 
    
 
      
      
 
       9m5.161s 
      
 		 
      
      
 
       18m6.333s
  
      
 		 
      
      

        4m45.650s 
      
 		 
    
 
    
  
 3. 
 
 
 set hive.auto.convert.join=True; 
 
 
  set hive.auto.convert.join.noconditionaltask=True; 
 
 
 
 
  set hive.auto.convert.join.noconditionaltask.size=10000;
  
  
 
   
 
    
 
   
 
   
 
     
     
 
       
       
 
        
 
       
 		 
       
       

         Q22 
       
 		 
       
       

         Q23 
       
 		 
       
       

         Q24 
       
 		 
     
 
     
 
       
       

         10000 (10K) 
       
 		 
       
       

         9m17.021s 
       
 		 
       
       
 
        16m8.071s 
       
 		 
       
       

         4m46.207s 
       
 		 
     
 
     
 
       
       

         10000000 (10M Default) 
       
 		 
       
       

         2m11.891s 
       
 		 
       
       

         13m38.050s 
       
 		 
       
       

         4m33.742s 
       
 		 
     
 
     
 
       
       
 
        100000000 （100M） 
       
 		 
       
       

         1m34.005s 
       
 		 
       
       

         10m43.252s 
       
 		 
       
       

         4m39.885s 
       
 		 
     
 
     
 
       
       

         1000000000 (1G) 
       
 		 
       
       

         1m30.704s 
       
 		 
       
       

         10m49.992s 
       
 		 
       
       

         Exception in thread "main" java.lang.OutOfMemoryError: Java heap space 
       
 
       

                 at org.apache.log4j.spi.LoggingEvent.<init>(LoggingEvent.java:165) 
       
 
       

                 at org.apache.log4j.Category.forcedLog(Category.java:391) 
       
 
       

                 at org.apache.log4j.Category.log(Category.java:856) 
       
 
       

                 at org.apache.commons.logging.impl.Log4JLogger.error(Log4JLogger.java:229) 
       
 
       

                 at org.apache.hadoop.hive.ql.exec.mr.MapredLocalTask.executeInProcess(MapredLocalTask.java:349) 
       
 
       

                 at org.apache.hadoop.hive.ql.exec.mr.ExecDriver.main(ExecDriver.java:744) 
       
 
       

                 at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) 
       
 
       

                 at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57) 
       
 
       

                 at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) 
       
 
       

                 at java.lang.reflect.Method.invoke(Method.java:606) 
       
 
       

                 at org.apache.hadoop.util.RunJar.main(RunJar.java:212) 
       
 
       

         Execution failed with exit status: 1 
       
 
       

         Obtaining error information 
       
 
       
 
       

         Task failed! 
       
 		 
     
 
     
 
       
       
 
        1000000000 (1G) 
        
 
       
 
       
 
        export HADOOP_CLIENT_OPTS="-Xmx2g"
  
       
 		 
       
       

         1m35.893s 
       
 		 
       
       

         10m45.741s 
       
 		 
       
       
 
        10m26.837s 
       
 		 
     
 
     
   
 結論： 
  
 
  

    1）  
   hive.auto.convert.join會覆蓋hive.auto.convert.join.noconditionaltask 
   
 2） 
   第二個測試說明須要將兩個都設爲True 
  
 
  

    3）  
   hive.auto.convert.join.noconditionaltask.size應該設置的較大一點 
   
 4 )   
   Job 數目變少了 
   
 
   
 
  
 
  
 
   

     set hive.mapjoin.localtask.max.memory.usage=0.90; 
   
 
   

     解釋：該屬性值表示本地任務將key/value保存在內存中的hash table中須要佔用多少內存，若是Local任務的內存使用比這個數值大，任務則會終止，這意味着小的hive表中的數據因爲太多了而不能保存在內存中。默認值是0.9. 
   
 
   

     結論： 
    該屬性對性能沒有多少影響 
   
 
   
 
  
 
  

    set hive.optimize.mapjoin.mapreduce=true; 
  
 
  

    解釋：該屬性決定一個Map-only任務是否會被合併到後續的Map-reduce任務中。可是，HIVE-4827對此作了改進，它無論該屬性是True仍是False，都會將Map-only任務合併到後續的map-reduce任務中，所以這個屬性對性能影響不大。 
  
 
  

    測試： 
  
 
  
 
   
 
   
 
     
     
 
       
       
 
        
 
       
 		 
       
       

         Q22 
       
 		 
       
       

         Q23 
       
 		 
       
       

         Q24 
       
 		 
     
 
     
 
       
       

         Undefined 
       
 		 
       
       
 
        2m9.787s 
       
 		 
       
       
 
        14m19.011s
  
       
 		 
       
       
 
        4m41.635s 
        
 
       
 		 
     
 
     
 
       
       

         True 
       
 		 
       
       

         Query returned non-zero code: 1, cause: hive configuration hive.optimize.mapjoin.mapreduce does not exists. 
       
 		 
       
       
 
        
 
       
 		 
       
       
 
        
 
       
 		 
     
 
     
   
 結論：  
   出錯 
   
 
   
 
  
 
  
 
   
 
  
 
  

    set hive.mapred.local.mem=1024; 
  
 
  

    解釋：本地模式下，mapper和reducer的內存，默認爲0 
  
 
  

    測試： 
   
 
   
 
     
     
 
       
       
 
        
 
       
 		 
       
       

         Q22 
       
 		 
       
       

         Q23 
       
 		 
       
       

         Q24 
       
 		 
     
 
     
 
       
       

         0 
       
 		 
       
       
 
        2m9.787s 
       
 		 
       
       
 
        14m19.011s
  
       
 		 
       
       
 
        4m41.635s 
        
 
       
 		 
     
 
     
 
       
       

         1024 
       
 		 
       
       

         2m11.625s 
       
 		 
       
       

         13m41.085s 
       
 		 
       
       

         4m39.853s 
       
 		 
     
 
     
   
 結論： 
   性能未見明顯提高 
  
 
  
 
   
 
  
 
  
 
   
 
  
 
  
 
   
  
  
 
  
     
   
  •  SMB Map Join
    •  
  
 
  

    set hive.auto.convert.sortmerge.join=true; 
  
 set hive.auto.convert.sortmerge.join.noconditionaltask=true; //此屬性不存在 
  

    set hive.optimize.bucketmapjoin = true;  
  
 
  

    set hive.optimize.bucketmapjoin.sortedmerge = true; 
  
 
  

    解釋： 
   Sort-Merge-Bucket (SMB) joins能夠被轉化爲SMB Map Join。這種join歸結於將已排好序的表進行合併，使得該操做比傳統的map join更加快速。可是若是表是劃分表，速度會慢上一些，由於每個mapper都須要獲取一個劃分的一小塊，這些小塊具備一個單一的key。 
  
 
  
 
   測試： 
  
 
  
 
    
   
 
     
     
 
       
       
 
        
 
       
 		 
       
       

         Q22 
       
 		 
       
       

         Q23 
       
 		 
       
       

         Q24 
       
 		 
     
 
     
 
       
       

         Origin 
       
 		 
       
       
 
        2m9.787s 
       
 		 
       
       
 
        14m19.011s
  
       
 		 
       
       
 
        4m41.635s 
        
 
       
 		 
     
 
     
 
       
       

         After 
       
 		 
       
       

         2m12.891s 
       
 		 
       
       

         13m50.629s 
       
 		 
       
       

         4m39.853s 
       
 		 
     
 
     
   
 結論： 
   性能未見明顯提高 
  
 
  
 
   
  
  
 
  
 
   
     
    
  •  Skewjoin
    •  
   
 
   hive.optimize.skewjoin=false 
  
 
  
 
   hive.optimize.skewjoin.compiletime=false 
  
 
  
 
   測試：
  
   
  
   
 
     
     
 
       
       
 
        
 
       
 		 
       
       

         Q22 
       
 		 
       
       

         Q23 
       
 		 
       
       

         Q24 
       
 		 
     
 
     
 
       
       

         Origin 
       
 		 
       
       
 
        2m9.787s 
       
 		 
       
       
 
        14m19.011s
  
       
 		 
       
       
 
        4m41.635s 
        
 
       
 		 
     
 
     
 
       
       

         After 
       
 		 
       
       
 
        FAILED: ParseException line 2:4 missing KW_ROLE at 'hive' near 'hive' 
       
 
       
 
        line 2:8 missing EOF at '.' near 'hive' 
       
 		 
       
       
 
        
 
       
 		 
       
       
 
        
 
       
 		 
     
 
     
   
 
   
 hive.groupby.skewindata=false 
  
 
  
 
   解釋：優化group by子句是否在數據中有誤差 
  
 
  
 
   測試： 
  
 
  
 
   
 
     
     
 
       
       
 
        
 
       
 		 
       
       

         Q22 
       
 		 
       
       

         Q23 
       
 		 
       
       

         Q24 
       
 		 
     
 
     
 
       
       

         False 
       
 		 
       
       
 
        2m9.787s 
       
 		 
       
       
 
        14m19.011s
  
       
 		 
       
       
 
        4m41.635s 
        
 
       
 		 
     
 
     
 
       
       

         True 
       
 		 
       
       
 
        2m48.965s 
       
 		 
       
       
 
        17m2.289s 
       
 		 
       
       
 
        5m59.542s 
       
 		 
     
 
     
   
 結論： 
   性能顯著降低 
  
 
  
 
   
  
   
     
    
  •  並行
    •  
   
 hive.exec.parallel=false 
  
 
  

    hive.exec.parallel.thread.number=8 
  
 
  
 
   
 
    
 解釋：是否並行的執行job以及並行執行job的最大數量 
    
 
    
 
     
 測試： 
    
 
    
 
     
 
       
       
 
         
         
 
          
 
         
 		 
         
         

           Q22 
         
 		 
         
         

           Q23 
         
 		 
         
         

           Q24 
         
 		 
       
 
       
 
         
         

           False 
         
 		 
         
         
 
          2m9.787s 
         
 		 
         
         
 
          14m19.011s
  
         
 		 
         
         
 
          4m41.635s 
          
 
         
 		 
       
 
       
 
         
         

           True 
         
 		 
         
         

           2m16.959s 
         
 		 
         
         
 
          9m32.682s 
         
 		 
         
         
 
          3m12.682s 
         
 		 
       
 
       
     
 結論： 
     Q23/Q24性能顯著提高，Q22未見明顯提高 
    
 
    
 
     
 
     
     
      
  •  其餘
    •  
     
 
    
 
   
 
  
 
 
 

 

 
 
 
  
 
   
 
    

      hive.optimize.ppd=true 
    
 
   
 
  
 
 
 

 
hive.optimize.ppd.storage=true 

 
 
 
  
 
   
 
    

      解釋：是否enable預測pushdown，以及是否將預測pushdown到存儲器。 
    
 
   
 
  
 
 
 

 

 
 
 
 

   測試： 
 
 
 
 
  
 
    
    
 
      
      
 
       
 
      
 		 
      
      

        Q22 
      
 		 
      
      

        Q23 
      
 		 
      
      

        Q24 
      
 		 
    
 
    
 
      
      

        False 
      
 		 
      
      
 
       2m9.787s 
      
 		 
      
      
 
       14m19.011s
  
      
 		 
      
      
 
       4m41.635s 
       
 
      
 		 
    
 
    
 
      
      

        True 
      
 		 
      
      

        2m13.427s 
      
 		 
      
      

        14m7.106s 
      
 		 
      
      

        4m50.376s 
      
 		 
    
 
    
  
 結論： 
  性能未見明顯提高 
 
 
 
 
  
 
 
 
 

   hive.optimize.index.filter=false 
 
 
 

   解釋：是否自動使用索引 
 
 
 

   測試： 
 
 
 
 
  
 
    
    
 
      
      
 
       
 
      
 		 
      
      

        Q22 
      
 		 
      
      

        Q23 
      
 		 
      
      

        Q24 
      
 		 
    
 
    
 
      
      

        False 
      
 		 
      
      
 
       2m9.787s 
      
 		 
      
      
 
       14m19.011s
  
      
 		 
      
      
 
       4m41.635s 
       
 
      
 		 
    
 
    
 
      
      

        True 
      
 		 
      
      

        2m15.132s 
      
 		 
      
      

        14m10.505s 
      
 		 
      
      

        4m49.860s 
      
 		 
    
 
    
  
 結論： 
  性能未見明顯提高 
  
 
  
 
 
 
 
 
 

   hive.mapjoin.smalltable.filesize=5000000 
 
 
 

   解釋：小表文件大小的閾值，若是表大小小於該閾值，則會將普通join轉化爲map join。 
 
 
 

   測試： 
 
 
 
 
  
 
    
    
 
      
      
 
       
 
      
 		 
      
      

        Q22 
      
 		 
      
      

        Q23 
      
 		 
      
      

        Q24 
      
 		 
    
 
    
 
      
      

        1M 
      
 		 
      
      

        2m17.173s 
      
 		 
      
      

        14m11.657s 
      
 		 
      
      

        4m57.931s 
      
 		 
    
 
    
 
      
      

        5M 
      
 		 
      
      
 
       2m9.787s 
      
 		 
      
      
 
       14m19.011s
  
      
 		 
      
      
 
       4m41.635s 
       
 
      
 		 
    
 
    
 
      
      

        10M 
      
 		 
      
      

        2m15.576s 
      
 		 
      
      

        14m20.439s 
      
 		 
      
      

        5m0.655s 
      
 		 
    
 
    
  
 結論： 
  性能未見明顯提高 
 
 
 
 
  
 
 
 
 
 
  
     
   
  •  綜合性能提高配置：
    •  
  
 
 
 
 
 
   
 
 

 

 
 set mapred.max.split.size=8388608;
  

 

 
 set hive.auto.convert.join=True; 
 
 
  set hive.auto.convert.join.noconditionaltask= 
  True 
  ; 
 
 
 
 
  set hive.auto.convert.join.noconditionaltask.size=100000000 ; 
 
 
 

   set hive.groupby.skewindata= 
  false 
 
 

 

 
 
 
   
  
 
    
   

     set hive.exec.parallel= 
    True 
   
 
   

     set hive.exec.parallel.thread.number=8 
   
 
   
 
    
  
   
 10G Data: 
   
 
   
 
     
     
 
       
       
 
        
 
       
 		 
       
       

         Q22 
       
 		 
       
       

         Q23 
       
 		 
       
       

         Q24 
       
 		 
     
 
     
 
       
       

         Origin 
       
 		 
       
       
 
        2m9.787s 
       
 		 
       
       
 
        14m19.011s
  
       
 		 
       
       
 
        4m41.635s 
        
 
       
 		 
     
 
     
 
       
       

         After 
       
 		 
       1m20.856s (37.7% up) 
       
       
 
        7m22.865s (48.4% up) 
       
 		 
       
       
 
        3m42.101s (21.1 % up) 
       
 		 
     
 
     
   
 
   
 
  
 
  
 
   1T Data: 
  
 
  
 
   
  
   
 
     
     
 
       
       
 
        
 
       
 		 
       
       

         Q22 
       
 		 
       
       

         Q23 
       
 		 
       
       

         Q24 
       
 		 
     
 
     
 
       
       

         Origin 
       
 		 
       
       
 
        20m8.207s 
       
 		 
       
       
 
        24m50.490s
  
       
 		 
       
       
 
        12m47.515s 
       
 		 
     
 
     
   
 
   
 
  
 
  
 
   hive.auto.convert.join.noconditionaltask.size=100000000 ;
  
  
 
  
 
    
   
 
    
 
      
      
 
        
        
 
         
 
        
 		 
        
        

          Q22 
        
 		 
        
        

          Q23 
        
 		 
        
        

          Q24 
        
 		 
      
 
      
 
        
        
 
         8388608 (8MB) 
        
 		 
        
        
 
         10m57.554s 
         
 
        
 		 
        
        
 
         40+m  
        
 		 
        
        
 
         ( 
         skip 
         ) 
         
 
        
 		 
      
 
      
 
        
        
 
         16777216 (16MB) 
         
 
        
 		 
        
        
 
         7m27.275s 
        
 		 
        
        
 
         40+m 
        
 		 
        
        
 
         (skip) 
         
 
        
 		 
      
 
      
 
        
        
 
         
33554432 (32MB)
 
        
 		 
        
        
 
         6m9.236s 
        
 		 
        
        
 
         36m27.416s 
        
 		 
        
        
 
         (skip) 
        
 		 
      
 
      
 
        
        

          67108864 (64MB default) 
        
 		 
        
        
 
         5m36.872s 
        
 		 
        
        
 
         31m55.655s 
        
 		 
        
        
 
         遠大於12min 
        
 		 
      
 
      
 
        
        

          134217728 (128MB) 
        
 		 
        
        
 
         4m49.397s 
        
 		 
        
        
 
         29m44.575s 
        
 		 
        
        
 
         20m17.109s 
        
 		 
      
 
      
 
        
        

          268435456 (256MB) 
        
 		 
        
        
 
         5m43.634 
        
 		 
        
        

          skip 
        
 		 
        skip 
      
 
      
    
 
   
 
    
   
 
    
  
   
 set mapred.max.split.size= 
   134217728  
   ; 
   
 
  
 
  hive.auto.convert.join.noconditionaltask.size= 
  ; (export HADOOP_CLIENT_OPTS="-Xmx2g") 
  
 
 
 
 
 
  
 
  
 
  
 
    
    
 
      
      
 
       
 
      
 		 
      
      

        Q22 
      
 		 
      
      

        Q23 
      
 		 
      
      

        Q24 
      
 		 
    
 
    
 
      
      

        10M（default） 
      
 		 
      
      

        40min+ 
      
 		 
      
      
 
       
 
      
 		 
      
      
 
       
 
      
 		 
    
 
    
 
      
      

        100M 
      
 		 
      
      
 
       4m49.397s
  
      
 		 
      
      
 
       29m44.575s
  
      
 		 
      
      
 
       20m17.109s 
       
 
      
 		 
    
 
    
 
      
      

        500M 
      
 		 
      
      

        4m57.060s 
      
 		 
      
      

        29min左右 
      
 		 
      
      

        同上 
      
 		 
    
 
    
 
      1G (export HADOOP_CLIENT_OPTS="-Xmx2g") 
      
      

        4m56.741s 
      
 		 
      
      

        29min左右 
      
 		 
      
      

        同上 
      
 		 
    
 
    
  
 
  
 
 
 
 

   1T Data配置： 
 
 
 
 
  
 
   set mapred.max.split.size=134217728 ;
  
  
 
  
 
   set hive.auto.convert.join=True; 
   
 
    set hive.auto.convert.join.noconditionaltask= 
    True 
    ; 
   
 
   
 
    set hive.auto.convert.join.noconditionaltask.size=100000000 ; 
   
 
   

     set hive.groupby.skewindata= 
    false 
   
 
  
 
  
 
   
 
     
    
 
      
     

       set hive.exec.parallel= 
      True 
     
 
     

       set hive.exec.parallel.thread.number=8 
     
 
    
 
   
 
  
 
  
 
   
 
  
 
  

    ps: 集羣愈來愈慢，在最初的配置下rerun跟上面的配置進行對比： 
  
 
  
 
   
 
   
 
     
     
 
       
       
 
        
 
       
 		 
       
       

         Q22 
       
 		 
       
       

         Q23 
       
 		 
       
       

         Q24 
       
 		 
     
 
     
 
       
       

         Origin 
       
 		 
       
       
 
        44m56.835s 
       
 		 
       
       
 
        45m18.217s 
       
 		 
       
       
 
        34m43.947s 
       
 		 
     
 
     
 
       
       

         After 
       
 		 
       4m49.397s
 		 
       
       
 
        29m44.575s 
        
 
       
 		 
       
       
 
        20m17.109s 
        
 
       
 		 
     
 
     
   
 
  
 
  
 
   Q22在此配置下有接近10/11性能提高 
  
 
  
 
 
 
 

   重啓集羣以後，rerun： 
 
 
 
 
  
 
   
 
     
     
 
       
       
 
        
 
       
 		 
       
       

         Q22 
       
 		 
       
       

         Q23 
       
 		 
       
       

         Q24 
       
 		 
     
 
     
 
       
       

         Origin 
       
 		 
       
       

         23m7.372s 
       
 		 
       
       

         26m49.460s 
       
 		 
       
       

         15m57.590s 
       
 		 
     
 
     
 
       
       

         After 
       
 		 
       2m31.808 (89% up) 
       
       
 
        18m18.278s (31.8% up) 
       
 		 
       
       
 
        12m55.900s (19.0% up) 
       
 		 
     
 
     
   
 
  
 
  
 
   
 
  
 
 
 

 

 

 

 
 
 

 Map Reduce數量相關java
 

 
 
 
 
    
  
  
  
  
  • 1
    • 
  
  
  
  
  • 2
    • 
  
  
  
  
  • 3
    • 
 
 
 
 
數據分片大小 (分片的數量決定map的數量) 
計算公式: splitSize = Math.max(minSize, Math.min(maxSize, blockSize))
 

 set mapreduce.input.fileinputformat.split.maxsize=750000000;node
 

 
 
 
 
    
  
  
  
  
  • 1
    • 
  
  
  
  
  • 2
    • 
  
  
  
  
  • 3
    • 
 
 
 
 
單個reduce處理的數據量 (影響reduce的數量) 
計算公式: Max(1, Min(hive.exec.reducers.max [1099], ReducerStage estimate/hive.exec.reducers.bytes.per.reducer)) x hive.tez.max.partition.factor
 

 set hive.exec.reducers.bytes.per.reducer=629145600;mysql
 

 
 
 
 
    
  
  
  
  
  • 1
    • 
  
  
  
  
  • 2
    • 
 
 
 
 
tez將會根據vertice的輸出大小動態預估調整reduce的個數
 

 set hive.tez.auto.reducer.parallelism = true; 
 執行計劃相關web
 

 
 
 
 
    
  
  
  
  
  • 1
    • 
  
  
  
  
  • 2
    • 
 
 
 
 
hive執行引擎 mr/tez/spark
 

 set hive.execution.engine=mr;算法
 

 
 
 
 
    
  
  
  
  
  • 1
    • 
  
  
  
  
  • 2
    • 
 
 
 
 
調整Join順序，讓屢次Join產生的中間數據儘量小，選擇不一樣的Join策略
 

 set hive.cbo.enable=true;sql
 

 
 
 
 
    
  
  
  
  
  • 1
    • 
  
  
  
  
  • 2
    • 
 
 
 
 
若是數據已經根據相同的key作好聚合，那麼去除掉多餘的map/reduce做業
 

 set hive.optimize.reducededuplication=true;數據庫
 

 
 
 
 
    
  
  
  
  
  • 1
    • 
  
  
  
  
  • 2
    • 
 
 
 
 
若是一個簡單查詢只包括一個group by和order by，此處能夠設置爲1或2
 

 set hive.optimize.reducededuplication.min.reducer=4;apache
 

 
 
 
 
    
  
  
  
  
  • 1
    • 
  
  
  
  
  • 2
    • 
 
 
 
 
Map Join優化, 不太大的表直接經過map過程作join
 

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

 
 
 
 
    
  
  
  
  
  • 1
    • 
  
  
  
  
  • 2
    • 
 
 
 
 
Map Join任務HashMap中key對應value數量
 

 set hive.smbjoin.cache.rows=10000;
 

 
 
 
 
    
  
  
  
  
  • 1
    • 
  
  
  
  
  • 2
    • 
 
 
 
 
能夠被轉化爲HashMap放入內存的表的大小(官方推薦853M)
 

 set hive.auto.convert.join.noconditionaltask.size=894435328;
 

 
 
 
 
    
  
  
  
  
  • 1
    • 
  
  
  
  
  • 2
    • 
  
  
  
  
  • 3
    • 
  
  
  
  
  • 4
    • 
  
  
  
  
  • 5
    • 
 
 
 
 
map端聚合(跟group by有關), 若是開啓, Hive將會在map端作第一級的聚合, 會用更多的內存 
http://dmtolpeko.com/2014/10/13/map-side-aggregation-in-hive/

開啓這個參數 sum(1)會有類型轉換問題
 

 set hive.map.aggr=false;
 

 
 
 
 
    
  
  
  
  
  • 1
    • 
  
  
  
  
  • 2
    • 
 
 
 
 
全部map任務能夠用做Hashtable的內存百分比, 若是OOM, 調小這個參數(官方默認0.5)
 

 set hive.map.aggr.hash.percentmemory=0.5;
 

 
 
 
 
    
  
  
  
  
  • 1
    • 
  
  
  
  
  • 2
    • 
 
 
 
 
將只有SELECT, FILTER, LIMIT轉化爲FETCH, 減小等待時間
 

 set hive.fetch.task.conversion=more; 
 set hive.fetch.task.conversion.threshold=1073741824;
 

 
 
 
 
    
  
  
  
  
  • 1
    • 
  
  
  
  
  • 2
    • 
 
 
 
 
聚合查詢是否轉化爲FETCH
 

 set hive.fetch.task.aggr=false;
 

 
 
 
 
    
  
  
  
  
  • 1
    • 
  
  
  
  
  • 2
    • 
 
 
 
 
若是數據按照join的key分桶，hive將簡單優化inner join(官方推薦關閉)
 

 set hive.optimize.bucketmapjoin= false; 
 set hive.optimize.bucketmapjoin.sortedmerge=false;
 

 
 
 
 
    
  
  
  
  
  • 1
    • 
  
  
  
  
  • 2
    • 
  
  
  
  
  • 3
    • 
  
  
  
  
  • 4
    • 
 
 
 
 
向量化計算 
https://cwiki.apache.org/confluence/display/Hive/Vectorized+Query+Execution 
若是開啓, sum(if(a=1,1,0))這樣的語句跑不過
 

 set hive.vectorized.execution.enabled=false; 
 set hive.vectorized.execution.reduce.enabled=false; 
 set hive.vectorized.groupby.checkinterval=4096; 
 set hive.vectorized.groupby.flush.percent=0.1; 
 動態分區相關
 

 
 
 
 
    
  
  
  
  
  • 1
    • 
  
  
  
  
  • 2
    • 
 
 
 
 
hive0.13有個bug, 開啓這個配置會對全部字段排序
 

 set hive.optimize.sort.dynamic.partition=false;
 

 
 
 
 
    
  
  
  
  
  • 1
    • 
  
  
  
  
  • 2
    • 
 
 
 
 
如下兩個參數用於開啓動態分區
 

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

 小文件相關
 

 
 
 
 
    
  
  
  
  
  • 1
    • 
  
  
  
  
  • 2
    • 
 
 
 
 
合併小文件
 

 set hive.merge.mapfiles=true; 
 set hive.merge.mapredfiles=true; 
 set hive.merge.tezfiles=true; 
 set hive.merge.sparkfiles=false; 
 set hive.merge.size.per.task=536870912; 
 set hive.merge.smallfiles.avgsize=536870912; 
 set hive.merge.orcfile.stripe.level=true; 
 ORC相關
 

 https://orc.apache.org/docs/hive-config.html
 

 
 
 
 
    
  
  
  
  
  • 1
    • 
  
  
  
  
  • 2
    • 
 
 
 
 
若是開啓將會在ORC文件中記錄metadata
 

 set hive.orc.splits.include.file.footer=false;
 

 
 
 
 
    
  
  
  
  
  • 1
    • 
  
  
  
  
  • 2
    • 
 
 
 
 
ORC寫緩衝大小
 

 set hive.exec.orc.default.stripe.size=67108864; 
 統計相關
 

 
 
 
 
    
  
  
  
  
  • 1
    • 
  
  
  
  
  • 2
    • 
 
 
 
 
新建立的表/分區是否自動計算統計數據
 

 set hive.stats.autogather=true; 
 set hive.compute.query.using.stats=true; 
 set hive.stats.fetch.column.stats=true; 
 set hive.stats.fetch.partition.stats=true;
 

 
 
 
 
    
  
  
  
  
  • 1
    • 
  
  
  
  
  • 2
    • 
 
 
 
 
手動統計已經存在的表
 

 ANALYZE TABLE COMPUTE STATISTICS; 
 ANALYZE TABLE COMPUTE STATISTICS for COLUMNS; 
 ANALYZE TABLE partition (coll=」x」) COMPUTE STATISTICS for COLUMNS; 
 其餘
 

 
 
 
 
    
  
  
  
  
  • 1
    • 
  
  
  
  
  • 2
    • 
 
 
 
 
在order by limit查詢中分配給存儲Top K的內存爲10%
 

 set hive.limit.pushdown.memory.usage=0.1;
 

 
 
 
 
    
  
  
  
  
  • 1
    • 
  
  
  
  
  • 2
    • 
 
 
 
 
是否開啓自動使用索引
 

 set hive.optimize.index.filter=true;
 

 
 
 
 
    
  
  
  
  
  • 1
    • 
  
  
  
  
  • 2
    • 
 
 
 
 
獲取文件塊路徑的工做線程數
 

 set mapreduce.input.fileinputformat.list-status.num-threads=5;


        

            

        	





    

		

            
相關文章

            

                

                

                    

                

            


            
相關標籤/搜索

            
        


    

        

            

        

        

        
        

        

        

    




	

    





    

    	

    

        每日一句
    

    
    
    	每一个你不满意的现在，都有一个你没有努力的曾经。
    







    

    


    



    

        本站公眾號
    

    

           歡迎關注本站公眾號,獲取更多信息

        
    




    

    




	


	







    

        聯繫我們
        最近搜索
        最新文章
        
        沪ICP备13005482号-10

            MyBatis教程
            SQL 教程
            MySQL教程
            Java 教程
            Thymeleaf 教程
            Hibernate教程
            Spring教程 
            Redis教程