Java tutorial
/** * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.hadoop.hive.ql; import java.io.DataInput; import java.io.FileNotFoundException; import java.io.IOException; import java.net.URI; import java.text.SimpleDateFormat; import java.util.Date; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Random; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.atomic.AtomicInteger; import org.antlr.runtime.TokenRewriteStream; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.ContentSummary; import org.apache.hadoop.fs.FileStatus; import org.apache.hadoop.fs.FileSystem; import org.apache.hadoop.fs.Path; import org.apache.hadoop.fs.permission.FsPermission; import org.apache.hadoop.hive.common.FileUtils; import org.apache.hadoop.hive.common.BlobStorageUtils; import org.apache.hadoop.hive.conf.HiveConf; import org.apache.hadoop.hive.ql.exec.TaskRunner; import org.apache.hadoop.hive.ql.exec.Utilities; import org.apache.hadoop.hive.ql.hooks.WriteEntity; import org.apache.hadoop.hive.ql.lockmgr.DbTxnManager.Heartbeater; import org.apache.hadoop.hive.ql.lockmgr.HiveLock; import org.apache.hadoop.hive.ql.lockmgr.HiveLockObj; import org.apache.hadoop.hive.ql.lockmgr.HiveTxnManager; import org.apache.hadoop.hive.ql.lockmgr.LockException; import org.apache.hadoop.hive.ql.metadata.Table; import org.apache.hadoop.hive.ql.parse.ASTNode; import org.apache.hadoop.hive.ql.parse.ExplainConfiguration; import org.apache.hadoop.hive.ql.parse.ExplainConfiguration.AnalyzeState; import org.apache.hadoop.hive.ql.parse.HiveParser; import org.apache.hadoop.hive.ql.plan.LoadTableDesc; import org.apache.hadoop.hive.ql.session.SessionState; import org.apache.hadoop.hive.shims.ShimLoader; import org.apache.hadoop.util.StringUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** * Context for Semantic Analyzers. Usage: not reusable - construct a new one for * each query should call clear() at end of use to remove temporary folders */ public class Context { private boolean isHDFSCleanup; private Path resFile; private Path resDir; private FileSystem resFs; private static final Logger LOG = LoggerFactory.getLogger("hive.ql.Context"); private Path[] resDirPaths; private int resDirFilesNum; boolean initialized; String originalTracker = null; private CompilationOpContext opContext; private final Map<String, ContentSummary> pathToCS = new ConcurrentHashMap<String, ContentSummary>(); // scratch path to use for all non-local (ie. hdfs) file system tmp folders private final Path nonLocalScratchPath; // scratch directory to use for local file system tmp folders private final String localScratchDir; // the permission to scratch directory (local and hdfs) private final String scratchDirPermission; // Keeps track of scratch directories created for different scheme/authority private final Map<String, Path> fsScratchDirs = new HashMap<String, Path>(); private final Configuration conf; protected int pathid = 10000; protected ExplainConfiguration explainConfig = null; protected String cboInfo; protected boolean cboSucceeded; protected String cmd = ""; // number of previous attempts protected int tryCount = 0; private TokenRewriteStream tokenRewriteStream; private final String executionId; // List of Locks for this query protected List<HiveLock> hiveLocks; // Transaction manager for this query protected HiveTxnManager hiveTxnManager; private boolean needLockMgr; private AtomicInteger sequencer = new AtomicInteger(); private final Map<String, Table> cteTables = new HashMap<String, Table>(); // Keep track of the mapping from load table desc to the output and the lock private final Map<LoadTableDesc, WriteEntity> loadTableOutputMap = new HashMap<LoadTableDesc, WriteEntity>(); private final Map<WriteEntity, List<HiveLockObj>> outputLockObjects = new HashMap<WriteEntity, List<HiveLockObj>>(); private final String stagingDir; private Heartbeater heartbeater; private boolean skipTableMasking; // Identify whether the query involves an UPDATE, DELETE or MERGE private boolean isUpdateDeleteMerge; /** * This determines the prefix of the * {@link org.apache.hadoop.hive.ql.parse.SemanticAnalyzer.Phase1Ctx#dest} * name for a given subtree of the AST. Most of the times there is only 1 destination in a * given tree but multi-insert has several and multi-insert representing MERGE must use * different prefixes to encode the purpose of different Insert branches */ private Map<Integer, DestClausePrefix> insertBranchToNamePrefix = new HashMap<>(); private Operation operation = Operation.OTHER; public void setOperation(Operation operation) { this.operation = operation; } /** * These ops require special handling in various places * (note that Insert into Acid table is in OTHER category) */ public enum Operation { UPDATE, DELETE, MERGE, OTHER }; public enum DestClausePrefix { INSERT("insclause-"), UPDATE("updclause-"), DELETE("delclause-"); private final String prefix; DestClausePrefix(String prefix) { this.prefix = prefix; } public String toString() { return prefix; } } private String getMatchedText(ASTNode n) { return getTokenRewriteStream().toString(n.getTokenStartIndex(), n.getTokenStopIndex() + 1).trim(); } /** * The suffix is always relative to a given ASTNode */ public DestClausePrefix getDestNamePrefix(ASTNode curNode) { assert curNode != null : "must supply curNode"; if (curNode.getType() != HiveParser.TOK_INSERT_INTO) { //select statement assert curNode.getType() == HiveParser.TOK_DESTINATION; if (operation == Operation.OTHER) { //not an 'interesting' op return DestClausePrefix.INSERT; } //if it is an 'interesting' op but it's a select it must be a sub-query or a derived table //it doesn't require a special Acid code path - the reset of the code here is to ensure //the tree structure is what we expect boolean thisIsInASubquery = false; parentLoop: while (curNode.getParent() != null) { curNode = (ASTNode) curNode.getParent(); switch (curNode.getType()) { case HiveParser.TOK_SUBQUERY_EXPR: //this is a real subquery (foo IN (select ...)) case HiveParser.TOK_SUBQUERY: //this is a Derived Table Select * from (select a from ...)) //strictly speaking SetOps should have a TOK_SUBQUERY parent so next 6 items are redundant case HiveParser.TOK_UNIONALL: case HiveParser.TOK_UNIONDISTINCT: case HiveParser.TOK_EXCEPTALL: case HiveParser.TOK_EXCEPTDISTINCT: case HiveParser.TOK_INTERSECTALL: case HiveParser.TOK_INTERSECTDISTINCT: thisIsInASubquery = true; break parentLoop; } } if (!thisIsInASubquery) { throw new IllegalStateException( "Expected '" + getMatchedText(curNode) + "' to be in sub-query or set operation."); } return DestClausePrefix.INSERT; } switch (operation) { case OTHER: return DestClausePrefix.INSERT; case UPDATE: return DestClausePrefix.UPDATE; case DELETE: return DestClausePrefix.DELETE; case MERGE: /* This is the structrue expected here HiveParser.TOK_QUERY; HiveParser.TOK_FROM HiveParser.TOK_INSERT; HiveParser.TOK_INSERT_INTO; HiveParser.TOK_INSERT; HiveParser.TOK_INSERT_INTO; .....*/ ASTNode insert = (ASTNode) curNode.getParent(); assert insert != null && insert.getType() == HiveParser.TOK_INSERT; ASTNode query = (ASTNode) insert.getParent(); assert query != null && query.getType() == HiveParser.TOK_QUERY; for (int childIdx = 1; childIdx < query.getChildCount(); childIdx++) {//1st child is TOK_FROM assert query.getChild(childIdx).getType() == HiveParser.TOK_INSERT; if (insert == query.getChild(childIdx)) { DestClausePrefix prefix = insertBranchToNamePrefix.get(childIdx); if (prefix == null) { throw new IllegalStateException( "Found a node w/o branch mapping: '" + getMatchedText(insert) + "'"); } return prefix; } } throw new IllegalStateException("Could not locate '" + getMatchedText(insert) + "'"); default: throw new IllegalStateException("Unexpected operation: " + operation); } } /** * Will make SemanticAnalyzer.Phase1Ctx#dest in subtree rooted at 'tree' use 'prefix'. This to * handle multi-insert stmt that represents Merge stmt and has insert branches representing * update/delete/insert. * @param pos ordinal index of specific TOK_INSERT as child of TOK_QUERY * @return previous prefix for 'tree' or null */ public DestClausePrefix addDestNamePrefix(int pos, DestClausePrefix prefix) { return insertBranchToNamePrefix.put(pos, prefix); } public Context(Configuration conf) throws IOException { this(conf, generateExecutionId()); } /** * Create a Context with a given executionId. ExecutionId, together with * user name and conf, will determine the temporary directory locations. */ public Context(Configuration conf, String executionId) { this.conf = conf; this.executionId = executionId; // local & non-local tmp location is configurable. however it is the same across // all external file systems nonLocalScratchPath = new Path(SessionState.getHDFSSessionPath(conf), executionId); localScratchDir = new Path(SessionState.getLocalSessionPath(conf), executionId).toUri().getPath(); scratchDirPermission = HiveConf.getVar(conf, HiveConf.ConfVars.SCRATCHDIRPERMISSION); stagingDir = HiveConf.getVar(conf, HiveConf.ConfVars.STAGINGDIR); opContext = new CompilationOpContext(); } public Map<LoadTableDesc, WriteEntity> getLoadTableOutputMap() { return loadTableOutputMap; } public Map<WriteEntity, List<HiveLockObj>> getOutputLockObjects() { return outputLockObjects; } /** * Find whether we should execute the current query due to explain * @return true if the query needs to be executed, false if not */ public boolean isExplainSkipExecution() { return (explainConfig != null && explainConfig.getAnalyze() != AnalyzeState.RUNNING); } /** * Find whether the current query is a logical explain query */ public boolean getExplainLogical() { return explainConfig != null && explainConfig.isLogical(); } public AnalyzeState getExplainAnalyze() { if (explainConfig != null) { return explainConfig.getAnalyze(); } return null; } /** * Set the original query command. * @param cmd the original query command string */ public void setCmd(String cmd) { this.cmd = cmd; } /** * Find the original query command. * @return the original query command string */ public String getCmd() { return cmd; } /** * Gets a temporary staging directory related to a path. * If a path already contains a staging directory, then returns the current directory; otherwise * create the directory if needed. * * @param inputPath URI of the temporary directory * @param mkdir Create the directory if True. * @return A temporary path. */ private Path getStagingDir(Path inputPath, boolean mkdir) { final URI inputPathUri = inputPath.toUri(); final String inputPathName = inputPathUri.getPath(); final String fileSystem = inputPathUri.getScheme() + ":" + inputPathUri.getAuthority(); final FileSystem fs; try { fs = inputPath.getFileSystem(conf); } catch (IOException e) { throw new IllegalStateException("Error getting FileSystem for " + inputPath + ": " + e, e); } String stagingPathName; if (inputPathName.indexOf(stagingDir) == -1) { stagingPathName = new Path(inputPathName, stagingDir).toString(); } else { stagingPathName = inputPathName.substring(0, inputPathName.indexOf(stagingDir) + stagingDir.length()); } final String key = fileSystem + "-" + stagingPathName + "-" + TaskRunner.getTaskRunnerID(); Path dir = fsScratchDirs.get(key); if (dir == null) { // Append task specific info to stagingPathName, instead of creating a sub-directory. // This way we don't have to worry about deleting the stagingPathName separately at // end of query execution. dir = fs.makeQualified( new Path(stagingPathName + "_" + this.executionId + "-" + TaskRunner.getTaskRunnerID())); LOG.debug("Created staging dir = " + dir + " for path = " + inputPath); if (mkdir) { try { if (!FileUtils.mkdir(fs, dir, conf)) { throw new IllegalStateException( "Cannot create staging directory '" + dir.toString() + "'"); } if (isHDFSCleanup) { fs.deleteOnExit(dir); } } catch (IOException e) { throw new RuntimeException( "Cannot create staging directory '" + dir.toString() + "': " + e.getMessage(), e); } } fsScratchDirs.put(key, dir); } return dir; } /** * Get a tmp directory on specified URI * * @param scheme Scheme of the target FS * @param authority Authority of the target FS * @param mkdir create the directory if true * @param scratchDir path of tmp directory */ private Path getScratchDir(String scheme, String authority, boolean mkdir, String scratchDir) { String fileSystem = scheme + ":" + authority; Path dir = fsScratchDirs.get(fileSystem + "-" + TaskRunner.getTaskRunnerID()); if (dir == null) { Path dirPath = new Path(scheme, authority, scratchDir + "-" + TaskRunner.getTaskRunnerID()); if (mkdir) { try { FileSystem fs = dirPath.getFileSystem(conf); dirPath = new Path(fs.makeQualified(dirPath).toString()); FsPermission fsPermission = new FsPermission(scratchDirPermission); if (!fs.mkdirs(dirPath, fsPermission)) { throw new RuntimeException("Cannot make directory: " + dirPath.toString()); } if (isHDFSCleanup) { fs.deleteOnExit(dirPath); } } catch (IOException e) { throw new RuntimeException(e); } } dir = dirPath; fsScratchDirs.put(fileSystem + "-" + TaskRunner.getTaskRunnerID(), dir); } return dir; } /** * Create a local scratch directory on demand and return it. */ public Path getLocalScratchDir(boolean mkdir) { try { FileSystem fs = FileSystem.getLocal(conf); URI uri = fs.getUri(); return getScratchDir(uri.getScheme(), uri.getAuthority(), mkdir, localScratchDir); } catch (IOException e) { throw new RuntimeException(e); } } /** * Create a map-reduce scratch directory on demand and return it. * */ public Path getMRScratchDir() { // if we are executing entirely on the client side - then // just (re)use the local scratch directory if (isLocalOnlyExecutionMode()) { return getLocalScratchDir(!isExplainSkipExecution()); } try { Path dir = FileUtils.makeQualified(nonLocalScratchPath, conf); URI uri = dir.toUri(); Path newScratchDir = getScratchDir(uri.getScheme(), uri.getAuthority(), !isExplainSkipExecution(), uri.getPath()); LOG.info("New scratch dir is " + newScratchDir); return newScratchDir; } catch (IOException e) { throw new RuntimeException(e); } catch (IllegalArgumentException e) { throw new RuntimeException( "Error while making MR scratch " + "directory - check filesystem config (" + e.getCause() + ")", e); } } /** * Create a temporary directory depending of the path specified. * - If path is an Object store filesystem, then use the default MR scratch directory (HDFS), unless isFinalJob and * {@link BlobStorageUtils#areOptimizationsEnabled(Configuration)} are both true, then return a path on * the blobstore. * - If path is on HDFS, then create a staging directory inside the path * * @param path Path used to verify the Filesystem to use for temporary directory * @param isFinalJob true if the required {@link Path} will be used for the final job (e.g. the final FSOP) * * @return A path to the new temporary directory */ public Path getTempDirForPath(Path path, boolean isFinalJob) { if (((BlobStorageUtils.isBlobStoragePath(conf, path) && !BlobStorageUtils.isBlobStorageAsScratchDir(conf)) || isPathLocal(path))) { if (!(isFinalJob && BlobStorageUtils.areOptimizationsEnabled(conf))) { // For better write performance, we use HDFS for temporary data when object store is used. // Note that the scratch directory configuration variable must use HDFS or any other non-blobstorage system // to take advantage of this performance. return getMRTmpPath(); } } return getExtTmpPathRelTo(path); } /** * Create a temporary directory depending of the path specified. * - If path is an Object store filesystem, then use the default MR scratch directory (HDFS) * - If path is on HDFS, then create a staging directory inside the path * * @param path Path used to verify the Filesystem to use for temporary directory * @return A path to the new temporary directory */ public Path getTempDirForPath(Path path) { return getTempDirForPath(path, false); } /* * Checks if the path is for the local filesystem or not */ private boolean isPathLocal(Path path) { boolean isLocal = false; if (path != null) { String scheme = path.toUri().getScheme(); if (scheme != null) { isLocal = scheme.equals(Utilities.HADOOP_LOCAL_FS_SCHEME); } } return isLocal; } private Path getExternalScratchDir(URI extURI) { return getStagingDir(new Path(extURI.getScheme(), extURI.getAuthority(), extURI.getPath()), !isExplainSkipExecution()); } /** * Remove any created scratch directories. */ public void removeScratchDir() { for (Map.Entry<String, Path> entry : fsScratchDirs.entrySet()) { try { Path p = entry.getValue(); FileSystem fs = p.getFileSystem(conf); LOG.debug("Deleting scratch dir: {}", p); fs.delete(p, true); fs.cancelDeleteOnExit(p); } catch (Exception e) { LOG.warn("Error Removing Scratch: " + StringUtils.stringifyException(e)); } } fsScratchDirs.clear(); } /** * Remove any created directories for CTEs. */ public void removeMaterializedCTEs() { // clean CTE tables for (Table materializedTable : cteTables.values()) { Path location = materializedTable.getDataLocation(); try { FileSystem fs = location.getFileSystem(conf); boolean status = fs.delete(location, true); LOG.info("Removed " + location + " for materialized " + materializedTable.getTableName() + ", status=" + status); } catch (IOException e) { // ignore LOG.warn("Error removing " + location + " for materialized " + materializedTable.getTableName() + ": " + StringUtils.stringifyException(e)); } } cteTables.clear(); } private String nextPathId() { return Integer.toString(pathid++); } private static final String MR_PREFIX = "-mr-"; private static final String EXT_PREFIX = "-ext-"; private static final String LOCAL_PREFIX = "-local-"; /** * Check if path is for intermediate data * @return true if a uri is a temporary uri for map-reduce intermediate data, * false otherwise */ public boolean isMRTmpFileURI(String uriStr) { return (uriStr.indexOf(executionId) != -1) && (uriStr.indexOf(MR_PREFIX) != -1); } public Path getMRTmpPath(URI uri) { return new Path(getStagingDir(new Path(uri), !isExplainSkipExecution()), MR_PREFIX + nextPathId()); } /** * Get a path to store map-reduce intermediate data in. * * @return next available path for map-red intermediate data */ public Path getMRTmpPath() { return new Path(getMRScratchDir(), MR_PREFIX + nextPathId()); } /** * Get a tmp path on local host to store intermediate data. * * @return next available tmp path on local fs */ public Path getLocalTmpPath() { return new Path(getLocalScratchDir(true), LOCAL_PREFIX + nextPathId()); } /** * Get a path to store tmp data destined for external Path. * * @param path external Path to which the tmp data has to be eventually moved * @return next available tmp path on the file system corresponding extURI */ public Path getExternalTmpPath(Path path) { URI extURI = path.toUri(); if (extURI.getScheme().equals("viewfs")) { // if we are on viewfs we don't want to use /tmp as tmp dir since rename from /tmp/.. // to final /user/hive/warehouse/ will fail later, so instead pick tmp dir // on same namespace as tbl dir. return getExtTmpPathRelTo(path.getParent()); } return new Path(getExternalScratchDir(extURI), EXT_PREFIX + nextPathId()); } /** * This is similar to getExternalTmpPath() with difference being this method returns temp path * within passed in uri, whereas getExternalTmpPath() ignores passed in path and returns temp * path within /tmp */ public Path getExtTmpPathRelTo(Path path) { return new Path(getStagingDir(path, !isExplainSkipExecution()), EXT_PREFIX + nextPathId()); } /** * @return the resFile */ public Path getResFile() { return resFile; } /** * @param resFile * the resFile to set */ public void setResFile(Path resFile) { this.resFile = resFile; resDir = null; resDirPaths = null; resDirFilesNum = 0; } /** * @return the resDir */ public Path getResDir() { return resDir; } /** * @param resDir * the resDir to set */ public void setResDir(Path resDir) { this.resDir = resDir; resFile = null; resDirFilesNum = 0; resDirPaths = null; } public void clear() throws IOException { if (resDir != null) { try { FileSystem fs = resDir.getFileSystem(conf); LOG.debug("Deleting result dir: {}", resDir); fs.delete(resDir, true); } catch (IOException e) { LOG.info("Context clear error: " + StringUtils.stringifyException(e)); } } if (resFile != null) { try { FileSystem fs = resFile.getFileSystem(conf); LOG.debug("Deleting result file: {}", resFile); fs.delete(resFile, false); } catch (IOException e) { LOG.info("Context clear error: " + StringUtils.stringifyException(e)); } } removeMaterializedCTEs(); removeScratchDir(); originalTracker = null; setNeedLockMgr(false); } public DataInput getStream() { try { if (!initialized) { initialized = true; if ((resFile == null) && (resDir == null)) { return null; } if (resFile != null) { return resFile.getFileSystem(conf).open(resFile); } resFs = resDir.getFileSystem(conf); FileStatus status = resFs.getFileStatus(resDir); assert status.isDir(); FileStatus[] resDirFS = resFs.globStatus(new Path(resDir + "/*"), FileUtils.HIDDEN_FILES_PATH_FILTER); resDirPaths = new Path[resDirFS.length]; int pos = 0; for (FileStatus resFS : resDirFS) { if (!resFS.isDir()) { resDirPaths[pos++] = resFS.getPath(); } } if (pos == 0) { return null; } return resFs.open(resDirPaths[resDirFilesNum++]); } else { return getNextStream(); } } catch (FileNotFoundException e) { LOG.info("getStream error: " + StringUtils.stringifyException(e)); return null; } catch (IOException e) { LOG.info("getStream error: " + StringUtils.stringifyException(e)); return null; } } private DataInput getNextStream() { try { if (resDir != null && resDirFilesNum < resDirPaths.length && (resDirPaths[resDirFilesNum] != null)) { return resFs.open(resDirPaths[resDirFilesNum++]); } } catch (FileNotFoundException e) { LOG.info("getNextStream error: " + StringUtils.stringifyException(e)); return null; } catch (IOException e) { LOG.info("getNextStream error: " + StringUtils.stringifyException(e)); return null; } return null; } public void resetStream() { if (initialized) { resDirFilesNum = 0; initialized = false; } } /** * Little abbreviation for StringUtils. */ private static boolean strEquals(String str1, String str2) { return org.apache.commons.lang.StringUtils.equals(str1, str2); } /** * Set the token rewrite stream being used to parse the current top-level SQL * statement. Note that this should <b>not</b> be used for other parsing * activities; for example, when we encounter a reference to a view, we switch * to a new stream for parsing the stored view definition from the catalog, * but we don't clobber the top-level stream in the context. * * @param tokenRewriteStream * the stream being used */ public void setTokenRewriteStream(TokenRewriteStream tokenRewriteStream) { assert (this.tokenRewriteStream == null || this.getExplainAnalyze() == AnalyzeState.RUNNING); this.tokenRewriteStream = tokenRewriteStream; } /** * @return the token rewrite stream being used to parse the current top-level * SQL statement, or null if it isn't available (e.g. for parser * tests) */ public TokenRewriteStream getTokenRewriteStream() { return tokenRewriteStream; } /** * Generate a unique executionId. An executionId, together with user name and * the configuration, will determine the temporary locations of all intermediate * files. * * In the future, users can use the executionId to resume a query. */ public static String generateExecutionId() { Random rand = new Random(); SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd_HH-mm-ss_SSS"); String executionId = "hive_" + format.format(new Date()) + "_" + Math.abs(rand.nextLong()); return executionId; } /** * Does Hive wants to run tasks entirely on the local machine * (where the query is being compiled)? * * Today this translates into running hadoop jobs locally */ public boolean isLocalOnlyExecutionMode() { // Always allow spark to run in a cluster mode. Without this, depending on // user's local hadoop settings, true may be returned, which causes plan to be // stored in local path. if (HiveConf.getVar(conf, HiveConf.ConfVars.HIVE_EXECUTION_ENGINE).equals("spark")) { return false; } return ShimLoader.getHadoopShims().isLocalMode(conf); } public List<HiveLock> getHiveLocks() { return hiveLocks; } public void setHiveLocks(List<HiveLock> hiveLocks) { this.hiveLocks = hiveLocks; } public HiveTxnManager getHiveTxnManager() { return hiveTxnManager; } public void setHiveTxnManager(HiveTxnManager txnMgr) { hiveTxnManager = txnMgr; } public void setOriginalTracker(String originalTracker) { this.originalTracker = originalTracker; } public void restoreOriginalTracker() { if (originalTracker != null) { ShimLoader.getHadoopShims().setJobLauncherRpcAddress(conf, originalTracker); originalTracker = null; } } public void addCS(String path, ContentSummary cs) { pathToCS.put(path, cs); } public ContentSummary getCS(Path path) { return getCS(path.toString()); } public ContentSummary getCS(String path) { return pathToCS.get(path); } public Map<String, ContentSummary> getPathToCS() { return pathToCS; } public Configuration getConf() { return conf; } /** * @return the isHDFSCleanup */ public boolean isHDFSCleanup() { return isHDFSCleanup; } /** * @param isHDFSCleanup the isHDFSCleanup to set */ public void setHDFSCleanup(boolean isHDFSCleanup) { this.isHDFSCleanup = isHDFSCleanup; } public boolean isNeedLockMgr() { return needLockMgr; } public void setNeedLockMgr(boolean needLockMgr) { this.needLockMgr = needLockMgr; } public int getTryCount() { return tryCount; } public void setTryCount(int tryCount) { this.tryCount = tryCount; } public String getCboInfo() { return cboInfo; } public void setCboInfo(String cboInfo) { this.cboInfo = cboInfo; } public boolean isCboSucceeded() { return cboSucceeded; } public void setCboSucceeded(boolean cboSucceeded) { this.cboSucceeded = cboSucceeded; } public Table getMaterializedTable(String cteName) { return cteTables.get(cteName); } public void addMaterializedTable(String cteName, Table table) { cteTables.put(cteName, table); } public AtomicInteger getSequencer() { return sequencer; } public CompilationOpContext getOpContext() { return opContext; } public Heartbeater getHeartbeater() { return heartbeater; } public void setHeartbeater(Heartbeater heartbeater) { this.heartbeater = heartbeater; } public void checkHeartbeaterLockException() throws LockException { if (getHeartbeater() != null && getHeartbeater().getLockException() != null) { throw getHeartbeater().getLockException(); } } public boolean isSkipTableMasking() { return skipTableMasking; } public void setSkipTableMasking(boolean skipTableMasking) { this.skipTableMasking = skipTableMasking; } public ExplainConfiguration getExplainConfig() { return explainConfig; } private boolean isExplainPlan = false; public boolean isExplainPlan() { return isExplainPlan; } public void setExplainPlan(boolean t) { this.isExplainPlan = t; } public void setExplainConfig(ExplainConfiguration explainConfig) { this.explainConfig = explainConfig; } public void resetOpContext() { opContext = new CompilationOpContext(); sequencer = new AtomicInteger(); } public boolean getIsUpdateDeleteMerge() { return isUpdateDeleteMerge; } public void setIsUpdateDeleteMerge(boolean isUpdate) { this.isUpdateDeleteMerge = isUpdate; } }