PageRenderTime 58ms CodeModel.GetById 21ms RepoModel.GetById 1ms app.codeStats 0ms

/common/src/java/org/apache/hadoop/hive/conf/HiveConf.java

https://github.com/mkgobaco/hive
Java | 1720 lines | 1161 code | 228 blank | 331 comment | 89 complexity | f6c3d3a755169fd464147422d4ca8c23 MD5 | raw file
Possible License(s): Apache-2.0

Large files files are truncated, but you can click here to view the full file

    

  1. /**
    2. 

  2.  * Licensed to the Apache Software Foundation (ASF) under one
    3. 

  3.  * or more contributor license agreements.  See the NOTICE file
    4. 

  4.  * distributed with this work for additional information
    5. 

  5.  * regarding copyright ownership.  The ASF licenses this file
    6. 

  6.  * to you under the Apache License, Version 2.0 (the
    7. 

  7.  * "License"); you may not use this file except in compliance
    8. 

  8.  * with the License.  You may obtain a copy of the License at
    9. 

  9.  *
    10. 

  10.  *     http://www.apache.org/licenses/LICENSE-2.0
    11. 

  11.  *
    12. 

  12.  * Unless required by applicable law or agreed to in writing, software
    13. 

  13.  * distributed under the License is distributed on an "AS IS" BASIS,
    14. 

  14.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    15. 

  15.  * See the License for the specific language governing permissions and
    16. 

  16.  * limitations under the License.
    17. 

  17.  */
    18. 

  18. 

  19. package org.apache.hadoop.hive.conf;
    20. 

  20. 

  21. import java.io.ByteArrayOutputStream;
    22. 

  22. import java.io.File;
    23. 

  23. import java.io.IOException;
    24. 

  24. import java.io.InputStream;
    25. 

  25. import java.io.PrintStream;
    26. 

  26. import java.net.URL;
    27. 

  27. import java.util.ArrayList;
    28. 

  28. import java.util.HashMap;
    29. 

  29. import java.util.Iterator;
    30. 

  30. import java.util.LinkedHashSet;
    31. 

  31. import java.util.List;
    32. 

  32. import java.util.Map;
    33. 

  33. import java.util.Map.Entry;
    34. 

  34. import java.util.Properties;
    35. 

  35. import java.util.Set;
    36. 

  36. import java.util.regex.Matcher;
    37. 

  37. import java.util.regex.Pattern;
    38. 

  38. 

  39. import javax.security.auth.login.LoginException;
    40. 

  40. 

  41. import org.apache.commons.lang.StringUtils;
    42. 

  42. import org.apache.commons.logging.Log;
    43. 

  43. import org.apache.commons.logging.LogFactory;
    44. 

  44. import org.apache.hadoop.conf.Configuration;
    45. 

  45. import org.apache.hadoop.hive.common.classification.InterfaceAudience.LimitedPrivate;
    46. 

  46. import org.apache.hadoop.hive.shims.ShimLoader;
    47. 

  47. import org.apache.hadoop.mapred.JobConf;
    48. 

  48. import org.apache.hadoop.security.UserGroupInformation;
    49. 

  49. import org.apache.hadoop.util.Shell;
    50. 

  50. import org.apache.hive.common.HiveCompat;
    51. 

  51. 

  52. /**
    53. 

  53.  * Hive Configuration.
    54. 

  54.  */
    55. 

  55. public class HiveConf extends Configuration {
    56. 

  56. 

  57.   protected String hiveJar;
    58. 

  58.   protected Properties origProp;
    59. 

  59.   protected String auxJars;
    60. 

  60.   private static final Log l4j = LogFactory.getLog(HiveConf.class);
    61. 

  61.   private static URL hiveDefaultURL = null;
    62. 

  62.   private static URL hiveSiteURL = null;
    63. 

  63.   private static byte[] confVarByteArray = null;
    64. 

  64. 

  65.   private static final Map<String, ConfVars> vars = new HashMap<String, ConfVars>();
    66. 

  66.   private final List<String> restrictList = new ArrayList<String>();
    67. 

  67. 

  68.   private boolean isWhiteListRestrictionEnabled = false;
    69. 

  69.   private final List<String> modWhiteList = new ArrayList<String>();
    70. 

  70. 

  71.   static {
    72. 

  72.     ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
    73. 

  73.     if (classLoader == null) {
    74. 

  74.       classLoader = HiveConf.class.getClassLoader();
    75. 

  75.     }
    76. 

  76. 

  77.     hiveDefaultURL = classLoader.getResource("hive-default.xml");
    78. 

  78. 

  79.     // Look for hive-site.xml on the CLASSPATH and log its location if found.
    80. 

  80.     hiveSiteURL = classLoader.getResource("hive-site.xml");
    81. 

  81.     for (ConfVars confVar : ConfVars.values()) {
    82. 

  82.       vars.put(confVar.varname, confVar);
    83. 

  83.     }
    84. 

  84.   }
    85. 

  85. 

  86.   /**
    87. 

  87.    * Metastore related options that the db is initialized against. When a conf
    88. 

  88.    * var in this is list is changed, the metastore instance for the CLI will
    89. 

  89.    * be recreated so that the change will take effect.
    90. 

  90.    */
    91. 

  91.   public static final HiveConf.ConfVars[] metaVars = {
    92. 

  92.       HiveConf.ConfVars.METASTOREDIRECTORY,
    93. 

  93.       HiveConf.ConfVars.METASTOREWAREHOUSE,
    94. 

  94.       HiveConf.ConfVars.METASTOREURIS,
    95. 

  95.       HiveConf.ConfVars.METASTORETHRIFTCONNECTIONRETRIES,
    96. 

  96.       HiveConf.ConfVars.METASTORETHRIFTFAILURERETRIES,
    97. 

  97.       HiveConf.ConfVars.METASTORE_CLIENT_CONNECT_RETRY_DELAY,
    98. 

  98.       HiveConf.ConfVars.METASTORE_CLIENT_SOCKET_TIMEOUT,
    99. 

  99.       HiveConf.ConfVars.METASTOREPWD,
    100. 

  100.       HiveConf.ConfVars.METASTORECONNECTURLHOOK,
    101. 

  101.       HiveConf.ConfVars.METASTORECONNECTURLKEY,
    102. 

  102.       HiveConf.ConfVars.METASTOREFORCERELOADCONF,
    103. 

  103.       HiveConf.ConfVars.METASTORESERVERMINTHREADS,
    104. 

  104.       HiveConf.ConfVars.METASTORESERVERMAXTHREADS,
    105. 

  105.       HiveConf.ConfVars.METASTORE_TCP_KEEP_ALIVE,
    106. 

  106.       HiveConf.ConfVars.METASTORE_INT_ORIGINAL,
    107. 

  107.       HiveConf.ConfVars.METASTORE_INT_ARCHIVED,
    108. 

  108.       HiveConf.ConfVars.METASTORE_INT_EXTRACTED,
    109. 

  109.       HiveConf.ConfVars.METASTORE_KERBEROS_KEYTAB_FILE,
    110. 

  110.       HiveConf.ConfVars.METASTORE_KERBEROS_PRINCIPAL,
    111. 

  111.       HiveConf.ConfVars.METASTORE_USE_THRIFT_SASL,
    112. 

  112.       HiveConf.ConfVars.METASTORE_CACHE_PINOBJTYPES,
    113. 

  113.       HiveConf.ConfVars.METASTORE_CONNECTION_POOLING_TYPE,
    114. 

  114.       HiveConf.ConfVars.METASTORE_VALIDATE_TABLES,
    115. 

  115.       HiveConf.ConfVars.METASTORE_VALIDATE_COLUMNS,
    116. 

  116.       HiveConf.ConfVars.METASTORE_VALIDATE_CONSTRAINTS,
    117. 

  117.       HiveConf.ConfVars.METASTORE_STORE_MANAGER_TYPE,
    118. 

  118.       HiveConf.ConfVars.METASTORE_AUTO_CREATE_SCHEMA,
    119. 

  119.       HiveConf.ConfVars.METASTORE_AUTO_START_MECHANISM_MODE,
    120. 

  120.       HiveConf.ConfVars.METASTORE_TRANSACTION_ISOLATION,
    121. 

  121.       HiveConf.ConfVars.METASTORE_CACHE_LEVEL2,
    122. 

  122.       HiveConf.ConfVars.METASTORE_CACHE_LEVEL2_TYPE,
    123. 

  123.       HiveConf.ConfVars.METASTORE_IDENTIFIER_FACTORY,
    124. 

  124.       HiveConf.ConfVars.METASTORE_PLUGIN_REGISTRY_BUNDLE_CHECK,
    125. 

  125.       HiveConf.ConfVars.METASTORE_AUTHORIZATION_STORAGE_AUTH_CHECKS,
    126. 

  126.       HiveConf.ConfVars.METASTORE_BATCH_RETRIEVE_MAX,
    127. 

  127.       HiveConf.ConfVars.METASTORE_EVENT_LISTENERS,
    128. 

  128.       HiveConf.ConfVars.METASTORE_EVENT_CLEAN_FREQ,
    129. 

  129.       HiveConf.ConfVars.METASTORE_EVENT_EXPIRY_DURATION,
    130. 

  130.       HiveConf.ConfVars.METASTORE_RAW_STORE_IMPL,
    131. 

  131.       HiveConf.ConfVars.METASTORE_END_FUNCTION_LISTENERS,
    132. 

  132.       HiveConf.ConfVars.METASTORE_PART_INHERIT_TBL_PROPS,
    133. 

  133.       HiveConf.ConfVars.METASTORE_BATCH_RETRIEVE_TABLE_PARTITION_MAX,
    134. 

  134.       HiveConf.ConfVars.METASTORE_INIT_HOOKS,
    135. 

  135.       HiveConf.ConfVars.METASTORE_PRE_EVENT_LISTENERS,
    136. 

  136.       HiveConf.ConfVars.HMSHANDLERATTEMPTS,
    137. 

  137.       HiveConf.ConfVars.HMSHANDLERINTERVAL,
    138. 

  138.       HiveConf.ConfVars.HMSHANDLERFORCERELOADCONF,
    139. 

  139.       HiveConf.ConfVars.METASTORE_PARTITION_NAME_WHITELIST_PATTERN,
    140. 

  140.       HiveConf.ConfVars.METASTORE_DISALLOW_INCOMPATIBLE_COL_TYPE_CHANGES,
    141. 

  141.       HiveConf.ConfVars.USERS_IN_ADMIN_ROLE,
    142. 

  142.       HiveConf.ConfVars.HIVE_AUTHORIZATION_MANAGER,
    143. 

  143.       HiveConf.ConfVars.HIVE_TXN_MANAGER,
    144. 

  144.       HiveConf.ConfVars.HIVE_TXN_TIMEOUT,
    145. 

  145.       HiveConf.ConfVars.HIVE_TXN_MAX_OPEN_BATCH,
    146. 

  146.       };
    147. 

  147. 

  148. 

  149.   /**
    150. 

  150.    * dbVars are the parameters can be set per database. If these
    151. 

  151.    * parameters are set as a database property, when switching to that
    152. 

  152.    * database, the HiveConf variable will be changed. The change of these
    153. 

  153.    * parameters will effectively change the DFS and MapReduce clusters
    154. 

  154.    * for different databases.
    155. 

  155.    */
    156. 

  156.   public static final HiveConf.ConfVars[] dbVars = {
    157. 

  157.     HiveConf.ConfVars.HADOOPBIN,
    158. 

  158.     HiveConf.ConfVars.METASTOREWAREHOUSE,
    159. 

  159.     HiveConf.ConfVars.SCRATCHDIR
    160. 

  160.   };
    161. 

  161. 

  162.   /**
    163. 

  163.    * ConfVars.
    164. 

  164.    *
    165. 

  165.    * These are the default configuration properties for Hive. Each HiveConf
    166. 

  166.    * object is initialized as follows:
    167. 

  167.    *
    168. 

  168.    * 1) Hadoop configuration properties are applied.
    169. 

  169.    * 2) ConfVar properties with non-null values are overlayed.
    170. 

  170.    * 3) hive-site.xml properties are overlayed.
    171. 

  171.    *
    172. 

  172.    * WARNING: think twice before adding any Hadoop configuration properties
    173. 

  173.    * with non-null values to this list as they will override any values defined
    174. 

  174.    * in the underlying Hadoop configuration.
    175. 

  175.    */
    176. 

  176.   public static enum ConfVars {
    177. 

  177.     // QL execution stuff
    178. 

  178.     SCRIPTWRAPPER("hive.exec.script.wrapper", null),
    179. 

  179.     PLAN("hive.exec.plan", ""),
    180. 

  180.     PLAN_SERIALIZATION("hive.plan.serialization.format","kryo"),
    181. 

  181.     SCRATCHDIR("hive.exec.scratchdir", "/tmp/hive-" + System.getProperty("user.name")),
    182. 

  182.     LOCALSCRATCHDIR("hive.exec.local.scratchdir", System.getProperty("java.io.tmpdir") + File.separator + System.getProperty("user.name")),
    183. 

  183.     SCRATCHDIRPERMISSION("hive.scratch.dir.permission", "700"),
    184. 

  184.     SUBMITVIACHILD("hive.exec.submitviachild", false),
    185. 

  185.     SUBMITLOCALTASKVIACHILD("hive.exec.submit.local.task.via.child", true),
    186. 

  186.     SCRIPTERRORLIMIT("hive.exec.script.maxerrsize", 100000),
    187. 

  187.     ALLOWPARTIALCONSUMP("hive.exec.script.allow.partial.consumption", false),
    188. 

  188.     STREAMREPORTERPERFIX("stream.stderr.reporter.prefix", "reporter:"),
    189. 

  189.     STREAMREPORTERENABLED("stream.stderr.reporter.enabled", true),
    190. 

  190.     COMPRESSRESULT("hive.exec.compress.output", false),
    191. 

  191.     COMPRESSINTERMEDIATE("hive.exec.compress.intermediate", false),
    192. 

  192.     COMPRESSINTERMEDIATECODEC("hive.intermediate.compression.codec", ""),
    193. 

  193.     COMPRESSINTERMEDIATETYPE("hive.intermediate.compression.type", ""),
    194. 

  194.     BYTESPERREDUCER("hive.exec.reducers.bytes.per.reducer", (long) (256 * 1000 * 1000)),
    195. 

  195.     MAXREDUCERS("hive.exec.reducers.max", 1009), // pick a prime
    196. 

  196.     PREEXECHOOKS("hive.exec.pre.hooks", ""),
    197. 

  197.     POSTEXECHOOKS("hive.exec.post.hooks", ""),
    198. 

  198.     ONFAILUREHOOKS("hive.exec.failure.hooks", ""),
    199. 

  199.     CLIENTSTATSPUBLISHERS("hive.client.stats.publishers", ""),
    200. 

  200.     EXECPARALLEL("hive.exec.parallel", false), // parallel query launching
    201. 

  201.     EXECPARALLETHREADNUMBER("hive.exec.parallel.thread.number", 8),
    202. 

  202.     HIVESPECULATIVEEXECREDUCERS("hive.mapred.reduce.tasks.speculative.execution", true),
    203. 

  203.     HIVECOUNTERSPULLINTERVAL("hive.exec.counters.pull.interval", 1000L),
    204. 

  204.     DYNAMICPARTITIONING("hive.exec.dynamic.partition", true),
    205. 

  205.     DYNAMICPARTITIONINGMODE("hive.exec.dynamic.partition.mode", "strict"),
    206. 

  206.     DYNAMICPARTITIONMAXPARTS("hive.exec.max.dynamic.partitions", 1000),
    207. 

  207.     DYNAMICPARTITIONMAXPARTSPERNODE("hive.exec.max.dynamic.partitions.pernode", 100),
    208. 

  208.     MAXCREATEDFILES("hive.exec.max.created.files", 100000L),
    209. 

  209.     DOWNLOADED_RESOURCES_DIR("hive.downloaded.resources.dir",
    210. 

  210.         System.getProperty("java.io.tmpdir") + File.separator  + "${hive.session.id}_resources"),
    211. 

  211.     DEFAULTPARTITIONNAME("hive.exec.default.partition.name", "__HIVE_DEFAULT_PARTITION__"),
    212. 

  212.     DEFAULT_ZOOKEEPER_PARTITION_NAME("hive.lockmgr.zookeeper.default.partition.name", "__HIVE_DEFAULT_ZOOKEEPER_PARTITION__"),
    213. 

  213.     // Whether to show a link to the most failed task + debugging tips
    214. 

  214.     SHOW_JOB_FAIL_DEBUG_INFO("hive.exec.show.job.failure.debug.info", true),
    215. 

  215.     JOB_DEBUG_CAPTURE_STACKTRACES("hive.exec.job.debug.capture.stacktraces", true),
    216. 

  216.     JOB_DEBUG_TIMEOUT("hive.exec.job.debug.timeout", 30000),
    217. 

  217.     TASKLOG_DEBUG_TIMEOUT("hive.exec.tasklog.debug.timeout", 20000),
    218. 

  218.     OUTPUT_FILE_EXTENSION("hive.output.file.extension", null),
    219. 

  219. 

  220.     HIVE_IN_TEST("hive.in.test", false), // internal usage only, true in test mode
    221. 

  221. 

  222.     // should hive determine whether to run in local mode automatically ?
    223. 

  223.     LOCALMODEAUTO("hive.exec.mode.local.auto", false),
    224. 

  224.     // if yes:
    225. 

  225.     // run in local mode only if input bytes is less than this. 128MB by default
    226. 

  226.     LOCALMODEMAXBYTES("hive.exec.mode.local.auto.inputbytes.max", 134217728L),
    227. 

  227.     // run in local mode only if number of tasks (for map and reduce each) is
    228. 

  228.     // less than this
    229. 

  229.     LOCALMODEMAXINPUTFILES("hive.exec.mode.local.auto.input.files.max", 4),
    230. 

  230.     // if true, DROP TABLE/VIEW does not fail if table/view doesn't exist and IF EXISTS is
    231. 

  231.     // not specified
    232. 

  232.     DROPIGNORESNONEXISTENT("hive.exec.drop.ignorenonexistent", true),
    233. 

  233. 

  234.     // ignore the mapjoin hint
    235. 

  235.     HIVEIGNOREMAPJOINHINT("hive.ignore.mapjoin.hint", true),
    236. 

  236. 

  237.     // Max number of lines of footer user can set for a table file.
    238. 

  238.     HIVE_FILE_MAX_FOOTER("hive.file.max.footer", 100),
    239. 

  239. 

  240.     // Make column names unique in the result set by using table alias if needed
    241. 

  241.     HIVE_RESULTSET_USE_UNIQUE_COLUMN_NAMES("hive.resultset.use.unique.column.names", true),
    242. 

  242. 

  243.     // Hadoop Configuration Properties
    244. 

  244.     // Properties with null values are ignored and exist only for the purpose of giving us
    245. 

  245.     // a symbolic name to reference in the Hive source code. Properties with non-null
    246. 

  246.     // values will override any values set in the underlying Hadoop configuration.
    247. 

  247.     HADOOPBIN("hadoop.bin.path", findHadoopBinary()),
    248. 

  248.     HIVE_FS_HAR_IMPL("fs.har.impl", "org.apache.hadoop.hive.shims.HiveHarFileSystem"),
    249. 

  249.     HADOOPFS(ShimLoader.getHadoopShims().getHadoopConfNames().get("HADOOPFS"), null),
    250. 

  250.     HADOOPMAPFILENAME(ShimLoader.getHadoopShims().getHadoopConfNames().get("HADOOPMAPFILENAME"), null),
    251. 

  251.     HADOOPMAPREDINPUTDIR(ShimLoader.getHadoopShims().getHadoopConfNames().get("HADOOPMAPREDINPUTDIR"), null),
    252. 

  252.     HADOOPMAPREDINPUTDIRRECURSIVE(ShimLoader.getHadoopShims().getHadoopConfNames().get("HADOOPMAPREDINPUTDIRRECURSIVE"), false),
    253. 

  253.     MAPREDMAXSPLITSIZE(ShimLoader.getHadoopShims().getHadoopConfNames().get("MAPREDMAXSPLITSIZE"), 256000000L),
    254. 

  254.     MAPREDMINSPLITSIZE(ShimLoader.getHadoopShims().getHadoopConfNames().get("MAPREDMINSPLITSIZE"), 1L),
    255. 

  255.     MAPREDMINSPLITSIZEPERNODE(ShimLoader.getHadoopShims().getHadoopConfNames().get("MAPREDMINSPLITSIZEPERNODE"), 1L),
    256. 

  256.     MAPREDMINSPLITSIZEPERRACK(ShimLoader.getHadoopShims().getHadoopConfNames().get("MAPREDMINSPLITSIZEPERRACK"), 1L),
    257. 

  257.     // The number of reduce tasks per job. Hadoop sets this value to 1 by default
    258. 

  258.     // By setting this property to -1, Hive will automatically determine the correct
    259. 

  259.     // number of reducers.
    260. 

  260.     HADOOPNUMREDUCERS(ShimLoader.getHadoopShims().getHadoopConfNames().get("HADOOPNUMREDUCERS"), -1),
    261. 

  261.     HADOOPJOBNAME(ShimLoader.getHadoopShims().getHadoopConfNames().get("HADOOPJOBNAME"), null),
    262. 

  262.     HADOOPSPECULATIVEEXECREDUCERS(ShimLoader.getHadoopShims().getHadoopConfNames().get("HADOOPSPECULATIVEEXECREDUCERS"), true),
    263. 

  263.     MAPREDSETUPCLEANUPNEEDED(ShimLoader.getHadoopShims().getHadoopConfNames().get("MAPREDSETUPCLEANUPNEEDED"), false),
    264. 

  264.     MAPREDTASKCLEANUPNEEDED(ShimLoader.getHadoopShims().getHadoopConfNames().get("MAPREDTASKCLEANUPNEEDED"), false),
    265. 

  265. 

  266.     // Metastore stuff. Be sure to update HiveConf.metaVars when you add
    267. 

  267.     // something here!
    268. 

  268.     METASTOREDIRECTORY("hive.metastore.metadb.dir", ""),
    269. 

  269.     METASTOREWAREHOUSE("hive.metastore.warehouse.dir", "/user/hive/warehouse"),
    270. 

  270.     METASTOREURIS("hive.metastore.uris", ""),
    271. 

  271.     // Number of times to retry a connection to a Thrift metastore server
    272. 

  272.     METASTORETHRIFTCONNECTIONRETRIES("hive.metastore.connect.retries", 3),
    273. 

  273.     // Number of times to retry a Thrift metastore call upon failure
    274. 

  274.     METASTORETHRIFTFAILURERETRIES("hive.metastore.failure.retries", 1),
    275. 

  275. 

  276.     // Number of seconds the client should wait between connection attempts
    277. 

  277.     METASTORE_CLIENT_CONNECT_RETRY_DELAY("hive.metastore.client.connect.retry.delay", 1),
    278. 

  278.     // Socket timeout for the client connection (in seconds)
    279. 

  279.     METASTORE_CLIENT_SOCKET_TIMEOUT("hive.metastore.client.socket.timeout", 600),
    280. 

  280.     METASTOREPWD("javax.jdo.option.ConnectionPassword", "mine"),
    281. 

  281.     // Class name of JDO connection url hook
    282. 

  282.     METASTORECONNECTURLHOOK("hive.metastore.ds.connection.url.hook", ""),
    283. 

  283.     METASTOREMULTITHREADED("javax.jdo.option.Multithreaded", true),
    284. 

  284.     // Name of the connection url in the configuration
    285. 

  285.     METASTORECONNECTURLKEY("javax.jdo.option.ConnectionURL",
    286. 

  286.         "jdbc:derby:;databaseName=metastore_db;create=true"),
    287. 

  287.     // Whether to force reloading of the metastore configuration (including
    288. 

  288.     // the connection URL, before the next metastore query that accesses the
    289. 

  289.     // datastore. Once reloaded, this value is reset to false. Used for
    290. 

  290.     // testing only.
    291. 

  291.     METASTOREFORCERELOADCONF("hive.metastore.force.reload.conf", false),
    292. 

  292.     // Number of attempts to retry connecting after there is a JDO datastore err
    293. 

  293.     HMSHANDLERATTEMPTS("hive.hmshandler.retry.attempts", 1),
    294. 

  294.     // Number of miliseconds to wait between attepting
    295. 

  295.     HMSHANDLERINTERVAL("hive.hmshandler.retry.interval", 1000),
    296. 

  296.     // Whether to force reloading of the HMSHandler configuration (including
    297. 

  297.     // the connection URL, before the next metastore query that accesses the
    298. 

  298.     // datastore. Once reloaded, this value is reset to false. Used for
    299. 

  299.     // testing only.
    300. 

  300.     HMSHANDLERFORCERELOADCONF("hive.hmshandler.force.reload.conf", false),
    301. 

  301.     METASTORESERVERMINTHREADS("hive.metastore.server.min.threads", 200),
    302. 

  302.     METASTORESERVERMAXTHREADS("hive.metastore.server.max.threads", 100000),
    303. 

  303.     METASTORE_TCP_KEEP_ALIVE("hive.metastore.server.tcp.keepalive", true),
    304. 

  304.     // Intermediate dir suffixes used for archiving. Not important what they
    305. 

  305.     // are, as long as collisions are avoided
    306. 

  306.     METASTORE_INT_ORIGINAL("hive.metastore.archive.intermediate.original",
    307. 

  307.         "_INTERMEDIATE_ORIGINAL"),
    308. 

  308.     METASTORE_INT_ARCHIVED("hive.metastore.archive.intermediate.archived",
    309. 

  309.         "_INTERMEDIATE_ARCHIVED"),
    310. 

  310.     METASTORE_INT_EXTRACTED("hive.metastore.archive.intermediate.extracted",
    311. 

  311.         "_INTERMEDIATE_EXTRACTED"),
    312. 

  312.     METASTORE_KERBEROS_KEYTAB_FILE("hive.metastore.kerberos.keytab.file", ""),
    313. 

  313.     METASTORE_KERBEROS_PRINCIPAL("hive.metastore.kerberos.principal",
    314. 

  314.         "hive-metastore/_HOST@EXAMPLE.COM"),
    315. 

  315.     METASTORE_USE_THRIFT_SASL("hive.metastore.sasl.enabled", false),
    316. 

  316.     METASTORE_USE_THRIFT_FRAMED_TRANSPORT("hive.metastore.thrift.framed.transport.enabled", false),
    317. 

  317.     METASTORE_CLUSTER_DELEGATION_TOKEN_STORE_CLS(
    318. 

  318.         "hive.cluster.delegation.token.store.class",
    319. 

  319.         "org.apache.hadoop.hive.thrift.MemoryTokenStore"),
    320. 

  320.     METASTORE_CLUSTER_DELEGATION_TOKEN_STORE_ZK_CONNECTSTR(
    321. 

  321.         "hive.cluster.delegation.token.store.zookeeper.connectString", ""),
    322. 

  322.     METASTORE_CLUSTER_DELEGATION_TOKEN_STORE_ZK_ZNODE(
    323. 

  323.         "hive.cluster.delegation.token.store.zookeeper.znode", "/hive/cluster/delegation"),
    324. 

  324.     METASTORE_CLUSTER_DELEGATION_TOKEN_STORE_ZK_ACL(
    325. 

  325.         "hive.cluster.delegation.token.store.zookeeper.acl", ""),
    326. 

  326.     METASTORE_CACHE_PINOBJTYPES("hive.metastore.cache.pinobjtypes", "Table,StorageDescriptor,SerDeInfo,Partition,Database,Type,FieldSchema,Order"),
    327. 

  327.     METASTORE_CONNECTION_POOLING_TYPE("datanucleus.connectionPoolingType", "BONECP"),
    328. 

  328.     METASTORE_VALIDATE_TABLES("datanucleus.validateTables", false),
    329. 

  329.     METASTORE_VALIDATE_COLUMNS("datanucleus.validateColumns", false),
    330. 

  330.     METASTORE_VALIDATE_CONSTRAINTS("datanucleus.validateConstraints", false),
    331. 

  331.     METASTORE_STORE_MANAGER_TYPE("datanucleus.storeManagerType", "rdbms"),
    332. 

  332.     METASTORE_AUTO_CREATE_SCHEMA("datanucleus.autoCreateSchema", true),
    333. 

  333.     METASTORE_FIXED_DATASTORE("datanucleus.fixedDatastore", false),
    334. 

  334.     METASTORE_SCHEMA_VERIFICATION("hive.metastore.schema.verification", false),
    335. 

  335.     METASTORE_AUTO_START_MECHANISM_MODE("datanucleus.autoStartMechanismMode", "checked"),
    336. 

  336.     METASTORE_TRANSACTION_ISOLATION("datanucleus.transactionIsolation", "read-committed"),
    337. 

  337.     METASTORE_CACHE_LEVEL2("datanucleus.cache.level2", false),
    338. 

  338.     METASTORE_CACHE_LEVEL2_TYPE("datanucleus.cache.level2.type", "none"),
    339. 

  339.     METASTORE_IDENTIFIER_FACTORY("datanucleus.identifierFactory", "datanucleus1"),
    340. 

  340.     METASTORE_USE_LEGACY_VALUE_STRATEGY("datanucleus.rdbms.useLegacyNativeValueStrategy", true),
    341. 

  341.     METASTORE_PLUGIN_REGISTRY_BUNDLE_CHECK("datanucleus.plugin.pluginRegistryBundleCheck", "LOG"),
    342. 

  342.     METASTORE_BATCH_RETRIEVE_MAX("hive.metastore.batch.retrieve.max", 300),
    343. 

  343.     METASTORE_BATCH_RETRIEVE_TABLE_PARTITION_MAX(
    344. 

  344.       "hive.metastore.batch.retrieve.table.partition.max", 1000),
    345. 

  345.     // A comma separated list of hooks which implement MetaStoreInitListener and will be run at
    346. 

  346.     // the beginning of HMSHandler initialization
    347. 

  347.     METASTORE_INIT_HOOKS("hive.metastore.init.hooks", ""),
    348. 

  348.     METASTORE_PRE_EVENT_LISTENERS("hive.metastore.pre.event.listeners", ""),
    349. 

  349.     METASTORE_EVENT_LISTENERS("hive.metastore.event.listeners", ""),
    350. 

  350.     // should we do checks against the storage (usually hdfs) for operations like drop_partition
    351. 

  351.     METASTORE_AUTHORIZATION_STORAGE_AUTH_CHECKS("hive.metastore.authorization.storage.checks", false),
    352. 

  352.     METASTORE_EVENT_CLEAN_FREQ("hive.metastore.event.clean.freq",0L),
    353. 

  353.     METASTORE_EVENT_EXPIRY_DURATION("hive.metastore.event.expiry.duration",0L),
    354. 

  354.     METASTORE_EXECUTE_SET_UGI("hive.metastore.execute.setugi", true),
    355. 

  355.     METASTORE_PARTITION_NAME_WHITELIST_PATTERN(
    356. 

  356.         "hive.metastore.partition.name.whitelist.pattern", ""),
    357. 

  357.     // Whether to enable integral JDO pushdown. For partition columns storing integers
    358. 

  358.     // in non-canonical form, (e.g. '012'), it may not work, so it's off by default.
    359. 

  359.     METASTORE_INTEGER_JDO_PUSHDOWN("hive.metastore.integral.jdo.pushdown", false),
    360. 

  360.     METASTORE_TRY_DIRECT_SQL("hive.metastore.try.direct.sql", true),
    361. 

  361.     METASTORE_TRY_DIRECT_SQL_DDL("hive.metastore.try.direct.sql.ddl", true),
    362. 

  362.     METASTORE_DISALLOW_INCOMPATIBLE_COL_TYPE_CHANGES(
    363. 

  363.         "hive.metastore.disallow.incompatible.col.type.changes", false),
    364. 

  364. 

  365.     // Default parameters for creating tables
    366. 

  366.     NEWTABLEDEFAULTPARA("hive.table.parameters.default", ""),
    367. 

  367.     // Parameters to copy over when creating a table with Create Table Like.
    368. 

  368.     DDL_CTL_PARAMETERS_WHITELIST("hive.ddl.createtablelike.properties.whitelist", ""),
    369. 

  369.     METASTORE_RAW_STORE_IMPL("hive.metastore.rawstore.impl",
    370. 

  370.         "org.apache.hadoop.hive.metastore.ObjectStore"),
    371. 

  371.     METASTORE_CONNECTION_DRIVER("javax.jdo.option.ConnectionDriverName",
    372. 

  372.         "org.apache.derby.jdbc.EmbeddedDriver"),
    373. 

  373.     METASTORE_MANAGER_FACTORY_CLASS("javax.jdo.PersistenceManagerFactoryClass",
    374. 

  374.         "org.datanucleus.api.jdo.JDOPersistenceManagerFactory"),
    375. 

  375.     METASTORE_EXPRESSION_PROXY_CLASS("hive.metastore.expression.proxy",
    376. 

  376.         "org.apache.hadoop.hive.ql.optimizer.ppr.PartitionExpressionForMetastore"),
    377. 

  377.     METASTORE_DETACH_ALL_ON_COMMIT("javax.jdo.option.DetachAllOnCommit", true),
    378. 

  378.     METASTORE_NON_TRANSACTIONAL_READ("javax.jdo.option.NonTransactionalRead", true),
    379. 

  379.     METASTORE_CONNECTION_USER_NAME("javax.jdo.option.ConnectionUserName", "APP"),
    380. 

  380.     METASTORE_END_FUNCTION_LISTENERS("hive.metastore.end.function.listeners", ""),
    381. 

  381.     METASTORE_PART_INHERIT_TBL_PROPS("hive.metastore.partition.inherit.table.properties",""),
    382. 

  382. 

  383.     // Parameters for exporting metadata on table drop (requires the use of the)
    384. 

  384.     // org.apache.hadoop.hive.ql.parse.MetaDataExportListener preevent listener
    385. 

  385.     METADATA_EXPORT_LOCATION("hive.metadata.export.location", ""),
    386. 

  386.     MOVE_EXPORTED_METADATA_TO_TRASH("hive.metadata.move.exported.metadata.to.trash", true),
    387. 

  387. 

  388.     // CLI
    389. 

  389.     CLIIGNOREERRORS("hive.cli.errors.ignore", false),
    390. 

  390.     CLIPRINTCURRENTDB("hive.cli.print.current.db", false),
    391. 

  391.     CLIPROMPT("hive.cli.prompt", "hive"),
    392. 

  392.     CLIPRETTYOUTPUTNUMCOLS("hive.cli.pretty.output.num.cols", -1),
    393. 

  393. 

  394.     HIVE_METASTORE_FS_HANDLER_CLS("hive.metastore.fs.handler.class", "org.apache.hadoop.hive.metastore.HiveMetaStoreFsImpl"),
    395. 

  395. 

  396.     // Things we log in the jobconf
    397. 

  397. 

  398.     // session identifier
    399. 

  399.     HIVESESSIONID("hive.session.id", ""),
    400. 

  400.     // whether session is running in silent mode or not
    401. 

  401.     HIVESESSIONSILENT("hive.session.silent", false),
    402. 

  402. 

  403.     // Whether to enable history for this session
    404. 

  404.     HIVE_SESSION_HISTORY_ENABLED("hive.session.history.enabled", false),
    405. 

  405. 

  406.     // query being executed (multiple per session)
    407. 

  407.     HIVEQUERYSTRING("hive.query.string", ""),
    408. 

  408. 

  409.     // id of query being executed (multiple per session)
    410. 

  410.     HIVEQUERYID("hive.query.id", ""),
    411. 

  411. 

  412.     // id of the mapred plan being executed (multiple per query)
    413. 

  413.     HIVEPLANID("hive.query.planid", ""),
    414. 

  414.         // max jobname length
    415. 

  415.     HIVEJOBNAMELENGTH("hive.jobname.length", 50),
    416. 

  416. 

  417.     // hive jar
    418. 

  418.     HIVEJAR("hive.jar.path", ""),
    419. 

  419.     HIVEAUXJARS("hive.aux.jars.path", ""),
    420. 

  420. 

  421.     // hive added files and jars
    422. 

  422.     HIVEADDEDFILES("hive.added.files.path", ""),
    423. 

  423.     HIVEADDEDJARS("hive.added.jars.path", ""),
    424. 

  424.     HIVEADDEDARCHIVES("hive.added.archives.path", ""),
    425. 

  425. 

  426.     HIVE_CURRENT_DATABASE("hive.current.database", ""), // internal usage only
    427. 

  427. 

  428.     // for hive script operator
    429. 

  429.     HIVES_AUTO_PROGRESS_TIMEOUT("hive.auto.progress.timeout", 0),
    430. 

  430.     HIVETABLENAME("hive.table.name", ""),
    431. 

  431.     HIVEPARTITIONNAME("hive.partition.name", ""),
    432. 

  432.     HIVESCRIPTAUTOPROGRESS("hive.script.auto.progress", false),
    433. 

  433.     HIVESCRIPTIDENVVAR("hive.script.operator.id.env.var", "HIVE_SCRIPT_OPERATOR_ID"),
    434. 

  434.     HIVESCRIPTTRUNCATEENV("hive.script.operator.truncate.env", false),
    435. 

  435.     HIVEMAPREDMODE("hive.mapred.mode", "nonstrict"),
    436. 

  436.     HIVEALIAS("hive.alias", ""),
    437. 

  437.     HIVEMAPSIDEAGGREGATE("hive.map.aggr", true),
    438. 

  438.     HIVEGROUPBYSKEW("hive.groupby.skewindata", false),
    439. 

  439.     HIVE_OPTIMIZE_MULTI_GROUPBY_COMMON_DISTINCTS("hive.optimize.multigroupby.common.distincts",
    440. 

  440.         true),
    441. 

  441.     HIVEJOINEMITINTERVAL("hive.join.emit.interval", 1000),
    442. 

  442.     HIVEJOINCACHESIZE("hive.join.cache.size", 25000),
    443. 

  443. 

  444.     // hive.mapjoin.bucket.cache.size has been replaced by hive.smbjoin.cache.row,
    445. 

  445.     // need to remove by hive .13. Also, do not change default (see SMB operator)
    446. 

  446.     HIVEMAPJOINBUCKETCACHESIZE("hive.mapjoin.bucket.cache.size", 100),
    447. 

  447.     HIVEMAPJOINUSEOPTIMIZEDTABLE("hive.mapjoin.optimized.hashtable", true),
    448. 

  448.     HIVEMAPJOINUSEOPTIMIZEDKEYS("hive.mapjoin.optimized.keys", true),
    449. 

  449.     HIVEMAPJOINLAZYHASHTABLE("hive.mapjoin.lazy.hashtable", true),
    450. 

  450.     HIVEHASHTABLEWBSIZE("hive.mapjoin.optimized.hashtable.wbsize", 10 * 1024 * 1024),
    451. 

  451. 

  452.     HIVESMBJOINCACHEROWS("hive.smbjoin.cache.rows", 10000),
    453. 

  453.     HIVEGROUPBYMAPINTERVAL("hive.groupby.mapaggr.checkinterval", 100000),
    454. 

  454.     HIVEMAPAGGRHASHMEMORY("hive.map.aggr.hash.percentmemory", (float) 0.5),
    455. 

  455.     HIVEMAPJOINFOLLOWEDBYMAPAGGRHASHMEMORY("hive.mapjoin.followby.map.aggr.hash.percentmemory", (float) 0.3),
    456. 

  456.     HIVEMAPAGGRMEMORYTHRESHOLD("hive.map.aggr.hash.force.flush.memory.threshold", (float) 0.9),
    457. 

  457.     HIVEMAPAGGRHASHMINREDUCTION("hive.map.aggr.hash.min.reduction", (float) 0.5),
    458. 

  458.     HIVEMULTIGROUPBYSINGLEREDUCER("hive.multigroupby.singlereducer", true),
    459. 

  459.     HIVE_MAP_GROUPBY_SORT("hive.map.groupby.sorted", false),
    460. 

  460.     HIVE_MAP_GROUPBY_SORT_TESTMODE("hive.map.groupby.sorted.testmode", false),
    461. 

  461.     HIVE_GROUPBY_ORDERBY_POSITION_ALIAS("hive.groupby.orderby.position.alias", false),
    462. 

  462.     HIVE_NEW_JOB_GROUPING_SET_CARDINALITY("hive.new.job.grouping.set.cardinality", 30),
    463. 

  463. 

  464. 

  465.     // for hive udtf operator
    466. 

  466.     HIVEUDTFAUTOPROGRESS("hive.udtf.auto.progress", false),
    467. 

  467. 

  468.     // Default file format for CREATE TABLE statement
    469. 

  469.     // Options: TextFile, SequenceFile
    470. 

  470.     HIVEDEFAULTFILEFORMAT("hive.default.fileformat", "TextFile",
    471. 

  471.         new StringsValidator("TextFile", "SequenceFile", "RCfile", "ORC")),
    472. 

  472.     HIVEQUERYRESULTFILEFORMAT("hive.query.result.fileformat", "TextFile",
    473. 

  473.         new StringsValidator("TextFile", "SequenceFile", "RCfile")),
    474. 

  474.     HIVECHECKFILEFORMAT("hive.fileformat.check", true),
    475. 

  475. 

  476.     // default serde for rcfile
    477. 

  477.     HIVEDEFAULTRCFILESERDE("hive.default.rcfile.serde",
    478. 

  478.                            "org.apache.hadoop.hive.serde2.columnar.LazyBinaryColumnarSerDe"),
    479. 

  479. 

  480.     SERDESUSINGMETASTOREFORSCHEMA("hive.serdes.using.metastore.for.schema","org.apache.hadoop.hive.ql.io.orc.OrcSerde,"
    481. 

  481.       + "org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe,org.apache.hadoop.hive.serde2.columnar.ColumnarSerDe,"
    482. 

  482.       + "org.apache.hadoop.hive.serde2.dynamic_type.DynamicSerDe,org.apache.hadoop.hive.serde2.MetadataTypedColumnsetSerDe,"
    483. 

  483.       + "org.apache.hadoop.hive.serde2.columnar.LazyBinaryColumnarSerDe,org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe,"
    484. 

  484.       + "org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe"),
    485. 

  485.     //Location of Hive run time structured log file
    486. 

  486.     HIVEHISTORYFILELOC("hive.querylog.location", System.getProperty("java.io.tmpdir") + File.separator + System.getProperty("user.name")),
    487. 

  487. 

  488.     // Whether to log the plan's progress every time a job's progress is checked
    489. 

  489.     HIVE_LOG_INCREMENTAL_PLAN_PROGRESS("hive.querylog.enable.plan.progress", true),
    490. 

  490. 

  491.     // The interval between logging the plan's progress in milliseconds
    492. 

  492.     HIVE_LOG_INCREMENTAL_PLAN_PROGRESS_INTERVAL("hive.querylog.plan.progress.interval", 60000L),
    493. 

  493. 

  494.     // Default serde and record reader for user scripts
    495. 

  495.     HIVESCRIPTSERDE("hive.script.serde", "org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe"),
    496. 

  496.     HIVESCRIPTRECORDREADER("hive.script.recordreader",
    497. 

  497.         "org.apache.hadoop.hive.ql.exec.TextRecordReader"),
    498. 

  498.     HIVESCRIPTRECORDWRITER("hive.script.recordwriter",
    499. 

  499.         "org.apache.hadoop.hive.ql.exec.TextRecordWriter"),
    500. 

  500.     HIVESCRIPTESCAPE("hive.transform.escape.input", false),
    501. 

  501.     HIVEBINARYRECORDMAX("hive.binary.record.max.length", 1000 ),
    502. 

  502. 

  503.     // HWI
    504. 

  504.     HIVEHWILISTENHOST("hive.hwi.listen.host", "0.0.0.0"),
    505. 

  505.     HIVEHWILISTENPORT("hive.hwi.listen.port", "9999"),
    506. 

  506.     HIVEHWIWARFILE("hive.hwi.war.file", System.getenv("HWI_WAR_FILE")),
    507. 

  507. 

  508.     // mapper/reducer memory in local mode
    509. 

  509.     HIVEHADOOPMAXMEM("hive.mapred.local.mem", 0),
    510. 

  510. 

  511.     //small table file size
    512. 

  512.     HIVESMALLTABLESFILESIZE("hive.mapjoin.smalltable.filesize",25000000L), //25M
    513. 

  513. 

  514.     // random number for split sampling
    515. 

  515.     HIVESAMPLERANDOMNUM("hive.sample.seednumber", 0),
    516. 

  516. 

  517.     // test mode in hive mode
    518. 

  518.     HIVETESTMODE("hive.test.mode", false),
    519. 

  519.     HIVETESTMODEPREFIX("hive.test.mode.prefix", "test_"),
    520. 

  520.     HIVETESTMODESAMPLEFREQ("hive.test.mode.samplefreq", 32),
    521. 

  521.     HIVETESTMODENOSAMPLE("hive.test.mode.nosamplelist", ""),
    522. 

  522.     HIVETESTMODEDUMMYSTATAGGR("hive.test.dummystats.aggregator", ""), // internal variable
    523. 

  523.     HIVETESTMODEDUMMYSTATPUB("hive.test.dummystats.publisher", ""),   // internal variable
    524. 

  524. 

  525.     HIVEMERGEMAPFILES("hive.merge.mapfiles", true),
    526. 

  526.     HIVEMERGEMAPREDFILES("hive.merge.mapredfiles", false),
    527. 

  527.     HIVEMERGETEZFILES("hive.merge.tezfiles", false),
    528. 

  528.     HIVEMERGEMAPFILESSIZE("hive.merge.size.per.task", (long) (256 * 1000 * 1000)),
    529. 

  529.     HIVEMERGEMAPFILESAVGSIZE("hive.merge.smallfiles.avgsize", (long) (16 * 1000 * 1000)),
    530. 

  530.     HIVEMERGERCFILEBLOCKLEVEL("hive.merge.rcfile.block.level", true),
    531. 

  531.     HIVEMERGEINPUTFORMATBLOCKLEVEL("hive.merge.input.format.block.level",
    532. 

  532.         "org.apache.hadoop.hive.ql.io.rcfile.merge.RCFileBlockMergeInputFormat"),
    533. 

  533.     HIVEMERGECURRENTJOBHASDYNAMICPARTITIONS(
    534. 

  534.         "hive.merge.current.job.has.dynamic.partitions", false),
    535. 

  535. 

  536.     HIVEUSEEXPLICITRCFILEHEADER("hive.exec.rcfile.use.explicit.header", true),
    537. 

  537.     HIVEUSERCFILESYNCCACHE("hive.exec.rcfile.use.sync.cache", true),
    538. 

  538. 

  539.     HIVE_RCFILE_RECORD_INTERVAL("hive.io.rcfile.record.interval", Integer.MAX_VALUE),
    540. 

  540.     HIVE_RCFILE_COLUMN_NUMBER_CONF("hive.io.rcfile.column.number.conf", 0),
    541. 

  541.     HIVE_RCFILE_TOLERATE_CORRUPTIONS("hive.io.rcfile.tolerate.corruptions", false),
    542. 

  542.     HIVE_RCFILE_RECORD_BUFFER_SIZE("hive.io.rcfile.record.buffer.size", 4194304),   // 4M
    543. 

  543. 

  544.     // Maximum fraction of heap that can be used by ORC file writers
    545. 

  545.     HIVE_ORC_FILE_MEMORY_POOL("hive.exec.orc.memory.pool", 0.5f), // 50%
    546. 

  546.     // Define the version of the file to write
    547. 

  547.     HIVE_ORC_WRITE_FORMAT("hive.exec.orc.write.format", null),
    548. 

  548.     // Define the default ORC stripe size
    549. 

  549.     HIVE_ORC_DEFAULT_STRIPE_SIZE("hive.exec.orc.default.stripe.size",
    550. 

  550.         256L * 1024 * 1024),
    551. 

  551.     HIVE_ORC_DICTIONARY_KEY_SIZE_THRESHOLD(
    552. 

  552.         "hive.exec.orc.dictionary.key.size.threshold", 0.8f),
    553. 

  553.     // Define the default ORC index stride
    554. 

  554.     HIVE_ORC_DEFAULT_ROW_INDEX_STRIDE("hive.exec.orc.default.row.index.stride"
    555. 

  555.         , 10000),
    556. 

  556.     // Define the default ORC buffer size
    557. 

  557.     HIVE_ORC_DEFAULT_BUFFER_SIZE("hive.exec.orc.default.buffer.size", 256 * 1024),
    558. 

  558.     // Define the default block padding
    559. 

  559.     HIVE_ORC_DEFAULT_BLOCK_PADDING("hive.exec.orc.default.block.padding",
    560. 

  560.         true),
    561. 

  561.     // Define the default compression codec for ORC file
    562. 

  562.     HIVE_ORC_DEFAULT_COMPRESS("hive.exec.orc.default.compress", "ZLIB"),
    563. 

  563.     // Define the default encoding strategy to use
    564. 

  564.     HIVE_ORC_ENCODING_STRATEGY("hive.exec.orc.encoding.strategy", "SPEED",
    565. 

  565.         new StringsValidator("SPEED", "COMPRESSION")),
    566. 

  566.     HIVE_ORC_INCLUDE_FILE_FOOTER_IN_SPLITS("hive.orc.splits.include.file.footer", false),
    567. 

  567.     HIVE_ORC_CACHE_STRIPE_DETAILS_SIZE("hive.orc.cache.stripe.details.size", 10000),
    568. 

  568.     HIVE_ORC_COMPUTE_SPLITS_NUM_THREADS("hive.orc.compute.splits.num.threads", 10),
    569. 

  569.     HIVE_ORC_SKIP_CORRUPT_DATA("hive.exec.orc.skip.corrupt.data", false),
    570. 

  570. 

  571.     HIVE_ORC_ZEROCOPY("hive.exec.orc.zerocopy", false),
    572. 

  572. 

  573.     // Whether extended literal set is allowed for LazySimpleSerde.
    574. 

  574.     HIVE_LAZYSIMPLE_EXTENDED_BOOLEAN_LITERAL("hive.lazysimple.extended_boolean_literal", false),
    575. 

  575. 

  576.     HIVESKEWJOIN("hive.optimize.skewjoin", false),
    577. 

  577.     HIVECONVERTJOIN("hive.auto.convert.join", true),
    578. 

  578.     HIVECONVERTJOINNOCONDITIONALTASK("hive.auto.convert.join.noconditionaltask", true),
    579. 

  579.     HIVECONVERTJOINNOCONDITIONALTASKTHRESHOLD("hive.auto.convert.join.noconditionaltask.size",
    580. 

  580.         10000000L),
    581. 

  581.     HIVECONVERTJOINUSENONSTAGED("hive.auto.convert.join.use.nonstaged", false),
    582. 

  582.     HIVESKEWJOINKEY("hive.skewjoin.key", 100000),
    583. 

  583.     HIVESKEWJOINMAPJOINNUMMAPTASK("hive.skewjoin.mapjoin.map.tasks", 10000),
    584. 

  584.     HIVESKEWJOINMAPJOINMINSPLIT("hive.skewjoin.mapjoin.min.split", 33554432L), //32M
    585. 

  585. 

  586.     HIVESENDHEARTBEAT("hive.heartbeat.interval", 1000),
    587. 

  587.     HIVELIMITMAXROWSIZE("hive.limit.row.max.size", 100000L),
    588. 

  588.     HIVELIMITOPTLIMITFILE("hive.limit.optimize.limit.file", 10),
    589. 

  589.     HIVELIMITOPTENABLE("hive.limit.optimize.enable", false),
    590. 

  590.     HIVELIMITOPTMAXFETCH("hive.limit.optimize.fetch.max", 50000),
    591. 

  591.     HIVELIMITPUSHDOWNMEMORYUSAGE("hive.limit.pushdown.memory.usage", -1f),
    592. 

  592.     HIVELIMITTABLESCANPARTITION("hive.limit.query.max.table.partition", -1),
    593. 

  593. 

  594.     HIVEHASHTABLETHRESHOLD("hive.hashtable.initialCapacity", 100000),
    595. 

  595.     HIVEHASHTABLELOADFACTOR("hive.hashtable.loadfactor", (float) 0.75),
    596. 

  596.     HIVEHASHTABLEFOLLOWBYGBYMAXMEMORYUSAGE("hive.mapjoin.followby.gby.localtask.max.memory.usage", (float) 0.55),
    597. 

  597.     HIVEHASHTABLEMAXMEMORYUSAGE("hive.mapjoin.localtask.max.memory.usage", (float) 0.90),
    598. 

  598.     HIVEHASHTABLESCALE("hive.mapjoin.check.memory.rows", (long)100000),
    599. 

  599. 

  600.     HIVEDEBUGLOCALTASK("hive.debug.localtask",false),
    601. 

  601. 

  602.     HIVEINPUTFORMAT("hive.input.format", "org.apache.hadoop.hive.ql.io.CombineHiveInputFormat"),
    603. 

  603.     HIVETEZINPUTFORMAT("hive.tez.input.format", "org.apache.hadoop.hive.ql.io.HiveInputFormat"),
    604. 

  604. 

  605.     HIVETEZCONTAINERSIZE("hive.tez.container.size", -1),
    606. 

  606.     HIVETEZJAVAOPTS("hive.tez.java.opts", null),
    607. 

  607.     HIVETEZLOGLEVEL("hive.tez.log.level", "INFO"),
    608. 

  608. 

  609.     HIVEENFORCEBUCKETING("hive.enforce.bucketing", false),
    610. 

  610.     HIVEENFORCESORTING("hive.enforce.sorting", false),
    611. 

  611.     HIVEOPTIMIZEBUCKETINGSORTING("hive.optimize.bucketingsorting", true),
    612. 

  612.     HIVEPARTITIONER("hive.mapred.partitioner", "org.apache.hadoop.hive.ql.io.DefaultHivePartitioner"),
    613. 

  613.     HIVEENFORCESORTMERGEBUCKETMAPJOIN("hive.enforce.sortmergebucketmapjoin", false),
    614. 

  614.     HIVEENFORCEBUCKETMAPJOIN("hive.enforce.bucketmapjoin", false),
    615. 

  615. 

  616.     HIVE_AUTO_SORTMERGE_JOIN("hive.auto.convert.sortmerge.join", false),
    617. 

  617.     HIVE_AUTO_SORTMERGE_JOIN_BIGTABLE_SELECTOR(
    618. 

  618.         "hive.auto.convert.sortmerge.join.bigtable.selection.policy",
    619. 

  619.         "org.apache.hadoop.hive.ql.optimizer.AvgPartitionSizeBasedBigTableSelectorForAutoSMJ"),
    620. 

  620.     HIVE_AUTO_SORTMERGE_JOIN_TOMAPJOIN(
    621. 

  621.         "hive.auto.convert.sortmerge.join.to.mapjoin", false),
    622. 

  622. 

  623.     HIVESCRIPTOPERATORTRUST("hive.exec.script.trust", false),
    624. 

  624.     HIVEROWOFFSET("hive.exec.rowoffset", false),
    625. 

  625. 

  626.     HIVE_COMBINE_INPUT_FORMAT_SUPPORTS_SPLITTABLE("hive.hadoop.supports.splittable.combineinputformat", false),
    627. 

  627. 

  628.     // Optimizer
    629. 

  629.     HIVEOPTINDEXFILTER("hive.optimize.index.filter", false), // automatically use indexes
    630. 

  630.     HIVEINDEXAUTOUPDATE("hive.optimize.index.autoupdate", false), //automatically update stale indexes
    631. 

  631.     HIVEOPTPPD("hive.optimize.ppd", true), // predicate pushdown
    632. 

  632.     HIVEPPDRECOGNIZETRANSITIVITY("hive.ppd.recognizetransivity", true), // predicate pushdown
    633. 

  633.     HIVEPPDREMOVEDUPLICATEFILTERS("hive.ppd.remove.duplicatefilters", true),
    634. 

  634.     HIVEMETADATAONLYQUERIES("hive.optimize.metadataonly", true),
    635. 

  635.     // push predicates down to storage handlers
    636. 

  636.     HIVEOPTPPD_STORAGE("hive.optimize.ppd.storage", true),
    637. 

  637.     HIVEOPTGROUPBY("hive.optimize.groupby", true), // optimize group by
    638. 

  638.     HIVEOPTBUCKETMAPJOIN("hive.optimize.bucketmapjoin", false), // optimize bucket map join
    639. 

  639.     HIVEOPTSORTMERGEBUCKETMAPJOIN("hive.optimize.bucketmapjoin.sortedmerge", false), // try to use sorted merge bucket map join
    640. 

  640.     HIVEOPTREDUCEDEDUPLICATION("hive.optimize.reducededuplication", true),
    641. 

  641.     HIVEOPTREDUCEDEDUPLICATIONMINREDUCER("hive.optimize.reducededuplication.min.reducer", 4),
    642. 

  642.     // when enabled dynamic partitioning column will be globally sorted.
    643. 

  643.     // this way we can keep only one record writer open for each partition value
    644. 

  644.     // in the reducer thereby reducing the memory pressure on reducers
    645. 

  645.     HIVEOPTSORTDYNAMICPARTITION("hive.optimize.sort.dynamic.partition", true),
    646. 

  646. 

  647.     HIVESAMPLINGFORORDERBY("hive.optimize.sampling.orderby", false),
    648. 

  648.     HIVESAMPLINGNUMBERFORORDERBY("hive.optimize.sampling.orderby.number", 1000),
    649. 

  649.     HIVESAMPLINGPERCENTFORORDERBY("hive.optimize.sampling.orderby.percent", 0.1f),
    650. 

  650. 

  651.     // whether to optimize union followed by select followed by filesink
    652. 

  652.     // It creates sub-directories in the final output, so should not be turned on in systems
    653. 

  653.     // where MAPREDUCE-1501 is not present
    654. 

  654.     HIVE_OPTIMIZE_UNION_REMOVE("hive.optimize.union.remove", false),
    655. 

  655.     HIVEOPTCORRELATION("hive.optimize.correlation", false), // exploit intra-query correlations
    656. 

  656. 

  657.     // whether hadoop map-reduce supports sub-directories. It was added by MAPREDUCE-1501.
    658. 

  658.     // Some optimizations can only be performed if the version of hadoop being used supports
    659. 

  659.     // sub-directories
    660. 

  660.     HIVE_HADOOP_SUPPORTS_SUBDIRECTORIES("hive.mapred.supports.subdirectories", false),
    661. 

  661. 

  662.     // optimize skewed join by changing the query plan at compile time
    663. 

  663.     HIVE_OPTIMIZE_SKEWJOIN_COMPILETIME("hive.optimize.skewjoin.compiletime", false),
    664. 

  664. 

  665.     // Indexes
    666. 

  666.     HIVEOPTINDEXFILTER_COMPACT_MINSIZE("hive.optimize.index.filter.compact.minsize", (long) 5 * 1024 * 1024 * 1024), // 5G
    667. 

  667.     HIVEOPTINDEXFILTER_COMPACT_MAXSIZE("hive.optimize.index.filter.compact.maxsize", (long) -1), // infinity
    668. 

  668.     HIVE_INDEX_COMPACT_QUERY_MAX_ENTRIES("hive.index.compact.query.max.entries", (long) 10000000), // 10M
    669. 

  669.     HIVE_INDEX_COMPACT_QUERY_MAX_SIZE("hive.index.compact.query.max.size", (long) 10 * 1024 * 1024 * 1024), // 10G
    670. 

  670.     HIVE_INDEX_COMPACT_BINARY_SEARCH("hive.index.compact.binary.search", true),
    671. 

  671. 

  672.     // Statistics
    673. 

  673.     HIVESTATSAUTOGATHER("hive.stats.autogather", true),
    674. 

  674.     HIVESTATSDBCLASS("hive.stats.dbclass", "fs",
    675. 

  675.         new PatternValidator("jdbc(:.*)", "hbase", "counter", "custom", "fs")), // StatsSetupConst.StatDB
    676. 

  676.     HIVESTATSJDBCDRIVER("hive.stats.jdbcdriver",
    677. 

  677.         "org.apache.derby.jdbc.EmbeddedDriver"), // JDBC driver specific to the dbclass
    678. 

  678.     HIVESTATSDBCONNECTIONSTRING("hive.stats.dbconnectionstring",
    679. 

  679.         "jdbc:derby:;databaseName=TempStatsStore;create=true"), // automatically create database
    680. 

  680.     HIVE_STATS_DEFAULT_PUBLISHER("hive.stats.default.publisher",
    681. 

  681.         ""), // default stats publisher if none of JDBC/HBase is specified
    682. 

  682.     HIVE_STATS_DEFAULT_AGGREGATOR("hive.stats.default.aggregator",
    683. 

  683.         ""), // default stats aggregator if none of JDBC/HBase is specified
    684. 

  684.     HIVE_STATS_JDBC_TIMEOUT("hive.stats.jdbc.timeout",
    685. 

  685.         30), // default timeout in sec for JDBC connection & SQL statements
    686. 

  686.     HIVE_STATS_ATOMIC("hive.stats.atomic",
    687. 

  687.         false), // whether to update metastore stats only if all stats are available
    688. 

  688.     HIVE_STATS_RETRIES_MAX("hive.stats.retries.max",
    689. 

  689.         0),     // maximum # of retries to insert/select/delete the stats DB
    690. 

  690.     HIVE_STATS_RETRIES_WAIT("hive.stats.retries.wait",
    691. 

  691.         3000),  // # milliseconds to wait before the next retry
    692. 

  692.     HIVE_STATS_COLLECT_RAWDATASIZE("hive.stats.collect.rawdatasize", true),
    693. 

  693.     // should the raw data size be collected when analyzing tables
    694. 

  694.     CLIENT_STATS_COUNTERS("hive.client.stats.counters", ""),
    695. 

  695.     //Subset of counters that should be of interest for hive.client.stats.publishers (when one wants to limit their publishing). Non-display names should be used".
    696. 

  696.     HIVE_STATS_RELIABLE("hive.stats.reliable", false),
    697. 

  697.     // number of threads used by partialscan/noscan stats gathering for partitioned tables.
    698. 

  698.     // This is applicable only for file formats that implement StatsProvidingRecordReader
    699. 

  699.     // interface (like ORC)
    700. 

  700.     HIVE_STATS_GATHER_NUM_THREADS("hive.stats.gather.num.threads", 10),
    701. 

  701.     // Collect table access keys information for operators that can benefit from bucketing
    702. 

  702.     HIVE_STATS_COLLECT_TABLEKEYS("hive.stats.collect.tablekeys", false),
    703. 

  703.     // Collect column access information
    704. 

  704.     HIVE_STATS_COLLECT_SCANCOLS("hive.stats.collect.scancols", false),
    705. 

  705.     // standard error allowed for ndv estimates. A lower value indicates higher accuracy and a
    706. 

  706.     // higher compute cost.
    707. 

  707.     HIVE_STATS_NDV_ERROR("hive.stats.ndv.error", (float)20.0),
    708. 

  708.     HIVE_STATS_KEY_PREFIX_MAX_LENGTH("hive.stats.key.prefix.max.length", 150),
    709. 

  709.     HIVE_STATS_KEY_PREFIX_RESERVE_LENGTH("hive.stats.key.prefix.reserve.length", 24),
    710. 

  710.     HIVE_STATS_KEY_PREFIX("hive.stats.key.prefix", ""), // internal usage only
    711. 

  711.     // if length of variable length data type cannot be determined this length will be used.
    712. 

  712.     HIVE_STATS_MAX_VARIABLE_LENGTH("hive.stats.max.variable.length", 100),
    713. 

  713.     // if number of elements in list cannot be determined, this value will be used
    714. 

  714.     HIVE_STATS_LIST_NUM_ENTRIES("hive.stats.list.num.entries", 10),
    715. 

  715.     // if number of elements in map cannot be determined, this value will be used
    716. 

  716.     HIVE_STATS_MAP_NUM_ENTRIES("hive.stats.map.num.entries", 10),
    717. 

  717.     // to accurately compute statistics for GROUPBY map side parallelism needs to be known
    718. 

  718.     HIVE_STATS_MAP_SIDE_PARALLELISM("hive.stats.map.parallelism", 1),
    719. 

  719.     // statistics annotation fetches stats for each partition, which can be expensive. turning
    720. 

  720.     // this off will result in basic sizes being fetched from namenode instead
    721. 

  721.     HIVE_STATS_FETCH_PARTITION_STATS("hive.stats.fetch.partition.stats", true),
    722. 

  722.     // statistics annotation fetches column statistics for all required columns which can
    723. 

  723.     // be very expensive sometimes
    724. 

  724.     HIVE_STATS_FETCH_COLUMN_STATS("hive.stats.fetch.column.stats", false),
    725. 

  725.     // in the absence of column statistics, the estimated number of rows/data size that will
    726. 

  726.     // be emitted from join operator will depend on this factor
    727. 

  727.     HIVE_STATS_JOIN_FACTOR("hive.stats.join.factor", (float) 1.1),
    728. 

  728.     // in the absence of uncompressed/raw data size, total file size will be used for statistics
    729. 

  729.     // annotation. But the file may be compressed, encoded and serialized which may be lesser in size
    730. 

  730.     // than the actual uncompressed/raw data size. This factor will be multiplied to file size to estimate
    731. 

  731.     // the raw data size.
    732. 

  732.     HIVE_STATS_DESERIALIZATION_FACTOR("hive.stats.deserialization.factor", (float) 1.0),
    733. 

  733. 

  734.     // Concurrency
    735. 

  735.     HIVE_SUPPORT_CONCURRENCY("hive.support.concurrency", false),
    736. 

  736.     HIVE_LOCK_MANAGER("hive.lock.manager", "org.apache.hadoop.hive.ql.lockmgr.zookeeper.ZooKeeperHiveLockManager"),
    737. 

  737.     HIVE_LOCK_NUMRETRIES("hive.lock.numretries", 100),
    738. 

  738.     HIVE_UNLOCK_NUMRETRIES("hive.unlock.numretries", 10),
    739. 

  739.     HIVE_LOCK_SLEEP_BETWEEN_RETRIES("hive.lock.sleep.between.retries", 60),
    740. 

  740.     HIVE_LOCK_MAPRED_ONLY("hive.lock.mapred.only.operation", false),
    741. 

  741. 

  742.     HIVE_ZOOKEEPER_QUORUM("hive.zookeeper.quorum", ""),
    743. 

  743.     HIVE_ZOOKEEPER_CLIENT_PORT("hive.zookeeper.client.port", "2181"),
    744. 

  744.     HIVE_ZOOKEEPER_SESSION_TIMEOUT("hive.zookeeper.session.timeout", 600*1000),
    745. 

  745.     HIVE_ZOOKEEPER_NAMESPACE("hive.zookeeper.namespace", "hive_zookeeper_namespace"),
    746. 

  746.     HIVE_ZOOKEEPER_CLEAN_EXTRA_NODES("hive.zookeeper.clean.extra.nodes", false),
    747. 

  747. 

  748.     // Transactions
    749. 

  749.     HIVE_TXN_MANAGER("hive.txn.manager",
    750. 

  750.         "org.apache.hadoop.hive.ql.lockmgr.DummyTxnManager"),
    751. 

  751.     // time after which transactions are declared aborted if the client has
    752. 

  752.     // not sent a heartbeat, in seconds.
    753. 

  753.     HIVE_TXN_TIMEOUT("hive.txn.timeout", 300),
    754. 

  754. 

  755.     // Maximum number of transactions that can be fetched in one call to
    756. 

  756.     // open_txns().
    757. 

  757.     // Increasing this will decrease the number of delta files created when
    758. 

  758.     // streaming data into Hive.  But it will also increase the number of
    759. 

  759.     // open transactions at any given time, possibly impacting read
    760. 

  760.     // performance.
    761. 

  761.     HIVE_TXN_MAX_OPEN_BATCH("hive.txn.max.open.batch", 1000),
    762. 

  762. 

  763.     // Whether to run the compactor's initiator thread in this metastore instance or not.
    764. 

  764.     HIVE_COMPACTOR_INITIATOR_ON("hive.compactor.initiator.on", false),
    765. 

  765. 

  766.     // Number of compactor worker threads to run on this metastore instance.
    767. 

  767.     HIVE_COMPACTOR_WORKER_THREADS("hive.compactor.worker.threads", 0),
    768. 

  768. 

  769.     // Time, in seconds, before a given compaction in working state is declared a failure and
    770. 

  770.     // returned to the initiated state.
    771. 

  771.     HIVE_COMPACTOR_WORKER_TIMEOUT("hive.compactor.worker.timeout", 86400L),
    772. 

  772. 

  773.     // Time in seconds between checks to see if any partitions need compacted.  This should be
    774. 

  774.     // kept high because each check for compaction requires many calls against the NameNode.
    775. 

  775.     HIVE_COMPACTOR_CHECK_INTERVAL("hive.compactor.check.interval", 300L),
    776. 

  776. 

  777.     // Number of delta files that must exist in a directory before the compactor will attempt a
    778. 

  778.     // minor compaction.
    779. 

  779.     HIVE_COMPACTOR_DELTA_NUM_THRESHOLD("hive.compactor.delta.num.threshold", 10),
    780. 

  780. 

  781.     // Percentage (by size) of base that deltas can be before major compaction is initiated.
    782. 

  782.     HIVE_COMPACTOR_DELTA_PCT_THRESHOLD("hive.compactor.delta.pct.threshold", 0.1f),
    783. 

  783. 

  784.     // Number of aborted transactions involving a particular table or partition before major
    785. 

  785.     // compaction is initiated.
    786. 

  786.     HIVE_COMPACTOR_ABORTEDTXN_THRESHOLD("hive.compactor.abortedtxn.threshold", 1000),
    787. 

  787. 

  788.     // For HBase storage handler
    789. 

  789.     HIVE_HBASE_WAL_ENABLED("hive.hbase.wal.enabled", true),
    790. 

  790.     HIVE_HBASE_GENERATE_HFILES("hive.hbase.generatehfiles", false),
    791. 

  791. 

  792.     // For har files
    793. 

  793.     HIVEARCHIVEENABLED("hive.archive.enabled", false),
    794. 

  794. 

  795.     //Enable/Disable gbToIdx rewrite rule
    796. 

  796.     HIVEOPTGBYUSINGINDEX("hive.optimize.index.groupby", false),
    797. 

  797. 

  798.     HIVEOUTERJOINSUPPORTSFILTERS("hive.outerjoin.supports.filters", true),
    799. 

  799. 

  800.     // 'minimal', 'more' (and 'all' later)
    801. 

  801.     HIVEFETCHTASKCONVERSION("hive.fetch.task.conversion", "minimal",
    802. 

  802.         new StringsValidator("minimal", "more")),
    803. 

  803.     HIVEFETCHTASKCONVERSIONTHRESHOLD("hive.fetch.task.conversion.threshold", -1l),
    804. 

  804. 

  805.     HIVEFETCHTASKAGGR("hive.fetch.task.aggr", false),
    806. 

  806. 

  807.     HIVEOPTIMIZEMETADATAQUERIES("hive.compute.query.using.stats", false),
    808. 

  808. 

  809.     // Serde for FetchTask
    810. 

  810.     HIVEFETCHOUTPUTSERDE("hive.fetch.output.serde", "org.apache.hadoop.hive.serde2.DelimitedJSONSerDe"),
    811. 

  811. 

  812.     HIVEEXPREVALUATIONCACHE("hive.cache.expr.evaluation", true),
    813. 

  813. 

  814.     // Hive Variables
    815. 

  815.     HIVEVARIABLESUBSTITUTE("hive.variable.substitute", true),
    816. 

  816.     HIVEVARIABLESUBSTITUTEDEPTH("hive.variable.substitute.depth", 40),
    817. 

  817. 

  818.     HIVECONFVALIDATION("hive.conf.validation", true),
    819. 

  819. 

  820.     SEMANTIC_ANALYZER_HOOK("hive.semantic.analyzer.hook", ""),
    821. 

  821.     HIVE_AUTHORIZATION_ENABLED("hive.security.authorization.enabled", false),
    822. 

  822.     HIVE_AUTHORIZATION_MANAGER("hive.security.authorization.manager",
    823. 

  823.         "org.apache.hadoop.hive.ql.security.authorization.DefaultHiveAuthorizationProvider"),
    824. 

  824.     HIVE_AUTHENTICATOR_MANAGER("hive.security.authenticator.manager",
    825. 

  825.         "org.apache.hadoop.hive.ql.security.HadoopDefaultAuthenticator"),
    826. 

  826.     HIVE_METASTORE_AUTHORIZATION_MANAGER("hive.security.metastore.authorization.manager",
    827. 

  827.         "org.apache.hadoop.hive.ql.security.authorization."
    828. 

  828.         + "DefaultHiveMetastoreAuthorizationProvider"),
    829. 

  829.     HIVE_METASTORE_AUTHENTICATOR_MANAGER("hive.security.metastore.authenticator.manager",
    830. 

  830.         "org.apache.hadoop.hive.ql.security.HadoopDefaultMetastoreAuthenticator"),
    831. 

  831.     HIVE_AUTHORIZATION_TABLE_USER_GRANTS("hive.security.authorization.createtable.user.grants", ""),
    832. 

  832.     HIVE_AUTHORIZATION_TABLE_GROUP_GRANTS("hive.security.authorization.createtable.group.grants",
    833. 

  833.         ""),
    834. 

  834.     HIVE_AUTHORIZATION_TABLE_ROLE_GRANTS("hive.security.authorization.createtable.role.grants", ""),
    835. 

  835.     HIVE_AUTHORIZATION_TABLE_OWNER_GRANTS("hive.security.authorization.createtable.owner.grants",
    836. 

  836.         ""),
    837. 

  837. 

  838.     // if this is not set default value is added by sql standard authorizer.
    839. 

  839.     // Default value can't be set in this constructor as it would refer names in other ConfVars
    840. 

  840.     // whose constructor would not have been called
    841. 

  841.     HIVE_AUTHORIZATION_SQL_STD_AUTH_CONFIG_WHITELIST("hive.security.authorization.sqlstd.confwhitelist", ""),
    842. 

  842. 

  843.     // Print column names in output
    844. 

  844.     HIVE_CLI_PRINT_HEADER("hive.cli.print.header", false),
    845. 

  845. 

  846.     HIVE_ERROR_ON_EMPTY_PARTITION("hive.error.on.empty.partition", false),
    847. 

  847. 

  848.     HIVE_INDEX_COMPACT_FILE("hive.index.compact.file", ""),           // internal variable
    849. 

  849.     HIVE_INDEX_BLOCKFILTER_FILE("hive.index.blockfilter.file", ""),   // internal variable
    850. 

  850.     HIVE_INDEX_IGNORE_HDFS_LOC("hive.index.compact.file.ignore.hdfs", false),
    851. 

  851. 

  852.     HIVE_EXIM_URI_SCHEME_WL("hive.exim.uri.scheme.whitelist", "hdfs,pfile"),
    853. 

  853.     // temporary variable for testing. This is added just to turn off this feature in case of a bug in
    854. 

  854.     // deployment. It has not been documented in hive-default.xml intentionally, this should be removed
    855. 

  855.     // once the feature is stable
    856. 

  856.     HIVE_MAPPER_CANNOT_SPAN_MULTIPLE_PARTITIONS("hive.mapper.cannot.span.multiple.partitions", false),
    857. 

  857.     HIVE_REWORK_MAPREDWORK("hive.rework.mapredwork", false),
    858. 

  858.     HIVE_CONCATENATE_CHECK_INDEX ("hive.exec.concatenate.check.index", true),
    859. 

  859.     HIVE_IO_EXCEPTION_HANDLERS("hive.io.exception.handlers", ""),
    860. 

  860. 

  861.     // logging configuration
    862. 

  862.     HIVE_LOG4J_FILE("hive.log4j.file", ""),
    863. 

  863.     HIVE_EXEC_LOG4J_FILE("hive.exec.log4j.file", ""),
    864. 

  864. 

  865.     // prefix used to auto generated column aliases (this should be started with '_')
    866. 

  866.     HIVE_AUTOGEN_COLUMNALIAS_PREFIX_LABEL("hive.autogen.columnalias.prefix.label", "_c"),
    867. 

  867.     HIVE_AUTOGEN_COLUMNALIAS_PREFIX_INCLUDEFUNCNAME(
    868. 

  868.                                "hive.autogen.columnalias.prefix.includefuncname", false),
    869. 

  869. 

  870.     // The class responsible for logging client side performance metrics
    871. 

  871.     // Must be a subclass of org.apache.hadoop.hive.ql.log.PerfLogger
    872. 

  872.     HIVE_PERF_LOGGER("hive.exec.perf.logger", "org.apache.hadoop.hive.ql.log.PerfLogger"),
    873. 

  873.     // Whether to delete the scratchdir while startup
    874. 

  874.     HIVE_START_CLEANUP_SCRATCHDIR("hive.start.cleanup.scratchdir", false),
    875. 

  875.     HIVE_INSERT_INTO_MULTILEVEL_DIRS("hive.insert.into.multilevel.dirs", false),
    876. 

  876.     HIVE_WAREHOUSE_SUBDIR_INHERIT_PERMS("hive.warehouse.subdir.inherit.perms", false),
    877. 

  877.     HIVE_WAREHOUSE_DATA_SKIPTRASH("hive.warehouse.data.skipTrash", false),
    878. 

  878.     // whether insert into external tables is allowed
    879. 

  879.     HIVE_INSERT_INTO_EXTERNAL_TABLES("hive.insert.into.external.tables", true),
    880. 

  880. 

  881.     // A comma separated list of hooks which implement HiveDriverRunHook and will be run at the
    882. 

  882.     // beginning and end of Dr…
    883.

Large files files are truncated, but you can click here to view the full file