Uses of Class
org.apache.hadoop.hive.ql.parse.SemanticException

Packages that use SemanticException

org.apache.hadoop.hive.ql.exec	Hive QL execution tasks, operators, functions and other handlers.
org.apache.hadoop.hive.ql.lib
org.apache.hadoop.hive.ql.metadata
org.apache.hadoop.hive.ql.optimizer
org.apache.hadoop.hive.ql.optimizer.correlation
org.apache.hadoop.hive.ql.optimizer.index
org.apache.hadoop.hive.ql.optimizer.lineage
org.apache.hadoop.hive.ql.optimizer.listbucketingpruner
org.apache.hadoop.hive.ql.optimizer.metainfo.annotation
org.apache.hadoop.hive.ql.optimizer.pcr
org.apache.hadoop.hive.ql.optimizer.physical
org.apache.hadoop.hive.ql.optimizer.physical.index
org.apache.hadoop.hive.ql.optimizer.ppr
org.apache.hadoop.hive.ql.optimizer.stats.annotation
org.apache.hadoop.hive.ql.optimizer.unionproc
org.apache.hadoop.hive.ql.parse
org.apache.hadoop.hive.ql.parse.authorization
org.apache.hadoop.hive.ql.plan
org.apache.hadoop.hive.ql.ppd
org.apache.hadoop.hive.ql.tools
org.apache.hadoop.hive.ql.udf.generic	Standard toolkit and framework for generic User-defined functions.
org.apache.hadoop.hive.ql.udf.ptf

Uses of SemanticException in org.apache.hadoop.hive.ql.exec

Subclasses of SemanticException in org.apache.hadoop.hive.ql.exec

class	AmbiguousMethodException Exception thrown by the UDF and UDAF method resolvers in case a unique method is not found.
class	NoMatchingMethodException Exception thrown by the UDF and UDAF method resolvers in case no matching method is found.
class	UDFArgumentException exception class, thrown when udf argument have something wrong.
class	UDFArgumentLengthException exception class, thrown when udf arguments have wrong length.
class	UDFArgumentTypeException exception class, thrown when udf arguments have wrong types.

Methods in org.apache.hadoop.hive.ql.exec that throw SemanticException

static GenericUDAFEvaluator	FunctionRegistry.getGenericUDAFEvaluator(String name, List<ObjectInspector> argumentOIs, boolean isDistinct, boolean isAllColumns) Get the GenericUDAF evaluator for the name and argumentClasses.
static GenericUDAFEvaluator	FunctionRegistry.getGenericWindowingEvaluator(String name, List<ObjectInspector> argumentOIs, boolean isDistinct, boolean isAllColumns)
void	Operator.removeChildAndAdoptItsChildren(Operator<? extends OperatorDesc> child) Remove a child and add all of the child's children to the location of the child
static void	Utilities.reworkMapRedWork(Task<? extends Serializable> task, boolean reworkMapredWork, HiveConf conf) The check here is kind of not clean.
static void	Utilities.validateColumnNames(List<String> colNames, List<String> checkCols)

Uses of SemanticException in org.apache.hadoop.hive.ql.lib

Methods in org.apache.hadoop.hive.ql.lib that throw SemanticException

int	RuleRegExp.cost(Stack<Node> stack) This function returns the cost of the rule for the specified stack.
int	RuleExactMatch.cost(Stack<Node> stack) This function returns the cost of the rule for the specified stack.
int	Rule.cost(Stack<Node> stack)
void	TaskGraphWalker.dispatch(Node nd, Stack<Node> ndStack)
void	DefaultGraphWalker.dispatch(Node nd, Stack<Node> ndStack) Dispatch the current operator.
Object	Dispatcher.dispatch(Node nd, Stack<Node> stack, Object... nodeOutputs) Dispatcher function.
Object	DefaultRuleDispatcher.dispatch(Node nd, Stack<Node> ndStack, Object... nodeOutputs) Dispatcher function.
void	TaskGraphWalker.dispatch(Node nd, Stack<Node> ndStack, TaskGraphWalker.TaskGraphWalkerContext walkerCtx) Dispatch the current operator.
<T> T	DefaultGraphWalker.dispatchAndReturn(Node nd, Stack<Node> ndStack) Returns dispatch result
Object	NodeProcessor.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs) Generic process for all ops that don't have specific implementations.
Object	CompositeProcessor.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
void	TaskGraphWalker.startWalking(Collection<Node> startNodes, HashMap<Node,Object> nodeOutput) starting point for walking.
void	GraphWalker.startWalking(Collection<Node> startNodes, HashMap<Node,Object> nodeOutput) starting point for walking.
void	DefaultGraphWalker.startWalking(Collection<Node> startNodes, HashMap<Node,Object> nodeOutput) starting point for walking.
void	TaskGraphWalker.walk(Node nd) walk the current operator and its descendants.
void	PreOrderWalker.walk(Node nd) Walk the current operator and its descendants.
void	ForwardWalker.walk(Node nd) walk the current operator and its descendants.
void	DefaultGraphWalker.walk(Node nd) walk the current operator and its descendants.

Uses of SemanticException in org.apache.hadoop.hive.ql.metadata

Methods in org.apache.hadoop.hive.ql.metadata that throw SemanticException

void	Table.validatePartColumnNames(Map<String,String> spec, boolean shouldBeFull)

Uses of SemanticException in org.apache.hadoop.hive.ql.optimizer

Methods in org.apache.hadoop.hive.ql.optimizer that throw SemanticException

protected boolean	AbstractSMBJoinProc.canConvertBucketMapJoinToSMBJoin(MapJoinOperator mapJoinOp, Stack<Node> stack, SortBucketJoinProcCtx smbJoinContext, Object... nodeOutputs)
protected boolean	AbstractSMBJoinProc.canConvertJoinToBucketMapJoin(JoinOperator joinOp, ParseContext pGraphContext, SortBucketJoinProcCtx context)
protected boolean	AbstractSMBJoinProc.canConvertJoinToSMBJoin(JoinOperator joinOperator, SortBucketJoinProcCtx smbJoinContext, ParseContext pGraphContext)
protected boolean	AbstractBucketJoinProc.canConvertMapJoinToBucketMapJoin(MapJoinOperator mapJoinOp, ParseContext pGraphContext, BucketJoinProcCtx context)
protected boolean	AbstractBucketJoinProc.checkConvertBucketMapJoin(ParseContext pGraphContext, BucketJoinProcCtx context, QBJoinTree joinCtx, Map<Byte,List<ExprNodeDesc>> keysMap, String baseBigAlias, List<String> joinAliases)
protected boolean	AbstractSMBJoinProc.checkConvertJoinToSMBJoin(JoinOperator joinOperator, SortBucketJoinProcCtx smbJoinContext, ParseContext pGraphContext)
protected GroupByOptimizer.GroupByOptimizerSortMatch	GroupByOptimizer.SortGroupByProcessor.checkSortGroupBy(Stack<Node> stack, GroupByOperator groupByOp)
MapJoinOperator	ConvertJoinMapJoin.convertJoinMapJoin(JoinOperator joinOp, OptimizeTezProcContext context, int bigTablePosition)
static MapJoinOperator	MapJoinProcessor.convertJoinOpMapJoinOp(HiveConf hconf, LinkedHashMap<Operator<? extends OperatorDesc>,OpParseContext> opParseCtxMap, JoinOperator op, QBJoinTree joinTree, int mapJoinPos, boolean noCheckOuterJoin)
protected MapJoinOperator	AbstractSMBJoinProc.convertJoinToBucketMapJoin(JoinOperator joinOp, SortBucketJoinProcCtx joinContext, ParseContext parseContext)
protected void	AbstractSMBJoinProc.convertJoinToSMBJoin(JoinOperator joinOp, SortBucketJoinProcCtx smbJoinContext, ParseContext parseContext)
static MapJoinOperator	MapJoinProcessor.convertMapJoin(HiveConf conf, LinkedHashMap<Operator<? extends OperatorDesc>,OpParseContext> opParseCtxMap, JoinOperator op, QBJoinTree joinTree, int mapJoinPos, boolean noCheckOuterJoin, boolean validateMapJoinTree) convert a regular join to a a map-side join.
protected void	AbstractBucketJoinProc.convertMapJoinToBucketMapJoin(MapJoinOperator mapJoinOp, BucketJoinProcCtx context)
static MapJoinOperator	MapJoinProcessor.convertSMBJoinToMapJoin(HiveConf hconf, Map<Operator<? extends OperatorDesc>,OpParseContext> opParseCtxMap, SMBMapJoinOperator smbJoinOp, QBJoinTree joinTree, int bigTablePos, boolean noCheckOuterJoin) convert a sortmerge join to a a map-side join.
static void	GenMapRedUtils.createMRWorkForMergingFiles(FileSinkOperator fsInput, org.apache.hadoop.fs.Path finalName, DependencyCollectionTask dependencyTask, List<Task<MoveWork>> mvTasks, HiveConf conf, Task<? extends Serializable> currTask)
static MapWork	GenMapRedUtils.createRCFileMergeTask(FileSinkDesc fsInputDesc, org.apache.hadoop.fs.Path finalName, boolean hasDynamicPartitions) Create a block level merge task for RCFiles.
List<String>	ColumnPrunerProcCtx.genColLists(Operator<? extends OperatorDesc> curOp) Creates the list of internal column names(these names are used in the RowResolver and are different from the external column names) that are needed in the subtree.
MapJoinOperator	MapJoinProcessor.generateMapJoinOperator(ParseContext pctx, JoinOperator op, QBJoinTree joinTree, int mapJoinPos)
protected abstract void	PrunerOperatorFactory.FilterPruner.generatePredicate(NodeProcessorCtx procCtx, FilterOperator fop, TableScanOperator top) Generate predicate.
static void	MapJoinProcessor.genLocalWorkForMapJoin(MapredWork newWork, MapJoinOperator newMapJoinOp, int mapJoinPos)
static void	MapJoinProcessor.genMapJoinOpAndLocalWork(HiveConf conf, MapredWork newWork, JoinOperator op, int mapJoinPos) Convert the join to a map-join and also generate any local work needed.
int	TableSizeBasedBigTableSelectorForAutoSMJ.getBigTablePosition(ParseContext parseCtx, JoinOperator joinOp, Set<Integer> bigTableCandidates)
int	BigTableSelectorForAutoSMJ.getBigTablePosition(ParseContext parseContext, JoinOperator joinOp, Set<Integer> joinCandidates)
int	AvgPartitionSizeBasedBigTableSelectorForAutoSMJ.getBigTablePosition(ParseContext parseCtx, JoinOperator joinOp, Set<Integer> bigTableCandidates)
static List<String>	AbstractBucketJoinProc.getBucketFilePathsOfPartition(org.apache.hadoop.fs.Path location, ParseContext pGraphContext)
static List<Index>	IndexUtils.getIndexes(Table baseTableMetaData, List<String> matchIndexTypes) Get a list of indexes on a table that match given types.
static List<org.apache.hadoop.fs.Path>	GenMapRedUtils.getInputPathsForPartialScan(QBParseInfo parseInfo, StringBuffer aggregationKey)
List<String>	ColumnPrunerProcCtx.getSelectColsFromLVJoin(RowResolver rr, List<String> colList) Create the list of internal columns for select tag of LV
static void	GenMapRedUtils.initPlan(ReduceSinkOperator op, GenMRProcContext opProcCtx) Initialize the current plan by adding it to root tasks.
static void	GenMapRedUtils.initUnionPlan(GenMRProcContext opProcCtx, UnionOperator currUnionOp, Task<? extends Serializable> currTask, boolean local)
static void	GenMapRedUtils.initUnionPlan(ReduceSinkOperator op, UnionOperator currUnionOp, GenMRProcContext opProcCtx, Task<? extends Serializable> unionTask) Initialize the current union plan.
static void	GenMapRedUtils.joinPlan(Task<? extends Serializable> currTask, Task<? extends Serializable> oldTask, GenMRProcContext opProcCtx) Merge the current task into the old task for the reducer
static void	GenMapRedUtils.joinUnionPlan(GenMRProcContext opProcCtx, UnionOperator currUnionOp, Task<? extends Serializable> currentUnionTask, Task<? extends Serializable> existingTask, boolean local)
static SamplePruner.LimitPruneRetStatus	SamplePruner.limitPrune(Partition part, long sizeLimit, int fileLimit, Collection<org.apache.hadoop.fs.Path> retPathList) Try to generate a list of subset of files in the partition to reach a size limit with number of files less than fileLimit
ParseContext	Optimizer.optimize() Invoke all the transformations one-by-one, and alter the query plan.
Object	SortedMergeJoinProc.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	SortedMergeBucketMapjoinProc.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	SkewJoinOptimizer.SkewJoinProc.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	SetReducerParallelism.process(Node nd, Stack<Node> stack, NodeProcessorCtx procContext, Object... nodeOutputs)
Object	SamplePruner.FilterPPR.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	SamplePruner.DefaultPPR.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	ReduceSinkMapJoinProc.process(Node nd, Stack<Node> stack, NodeProcessorCtx procContext, Object... nodeOutputs)
Object	PrunerOperatorFactory.FilterPruner.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	PrunerOperatorFactory.DefaultPruner.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	PrunerExpressionOperatorFactory.GenericFuncExprProcessor.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	PrunerExpressionOperatorFactory.FieldExprProcessor.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	PrunerExpressionOperatorFactory.ColumnExprProcessor.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	PrunerExpressionOperatorFactory.DefaultExprProcessor.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	MapJoinProcessor.CurrentMapJoin.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs) Store the current mapjoin in the context.
Object	MapJoinProcessor.MapJoinFS.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs) Store the current mapjoin in a list of mapjoins followed by a filesink.
Object	MapJoinProcessor.MapJoinDefault.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs) Store the mapjoin in a rejected list.
Object	MapJoinProcessor.Default.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs) Nothing to do.
Object	GroupByOptimizer.SortGroupByProcessor.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	GroupByOptimizer.SortGroupBySkewProcessor.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	GenMRUnion1.process(Node nd, Stack<Node> stack, NodeProcessorCtx opProcCtx, Object... nodeOutputs) Union Operator encountered .
Object	GenMRTableScan1.process(Node nd, Stack<Node> stack, NodeProcessorCtx opProcCtx, Object... nodeOutputs) Table Sink encountered.
Object	GenMRRedSink3.process(Node nd, Stack<Node> stack, NodeProcessorCtx opProcCtx, Object... nodeOutputs) Reduce Scan encountered.
Object	GenMRRedSink2.process(Node nd, Stack<Node> stack, NodeProcessorCtx opProcCtx, Object... nodeOutputs) Reduce Scan encountered.
Object	GenMRRedSink1.process(Node nd, Stack<Node> stack, NodeProcessorCtx opProcCtx, Object... nodeOutputs) Reduce Sink encountered.
Object	GenMROperator.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs) Reduce Scan encountered.
Object	GenMRFileSink1.process(Node nd, Stack<Node> stack, NodeProcessorCtx opProcCtx, Object... nodeOutputs) File Sink Operator encountered.
Object	ConvertJoinMapJoin.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	ColumnPrunerProcFactory.ColumnPrunerFilterProc.process(Node nd, Stack<Node> stack, NodeProcessorCtx ctx, Object... nodeOutputs)
Object	ColumnPrunerProcFactory.ColumnPrunerGroupByProc.process(Node nd, Stack<Node> stack, NodeProcessorCtx ctx, Object... nodeOutputs)
Object	ColumnPrunerProcFactory.ColumnPrunerPTFProc.process(Node nd, Stack<Node> stack, NodeProcessorCtx ctx, Object... nodeOutputs)
Object	ColumnPrunerProcFactory.ColumnPrunerDefaultProc.process(Node nd, Stack<Node> stack, NodeProcessorCtx ctx, Object... nodeOutputs)
Object	ColumnPrunerProcFactory.ColumnPrunerTableScanProc.process(Node nd, Stack<Node> stack, NodeProcessorCtx ctx, Object... nodeOutputs)
Object	ColumnPrunerProcFactory.ColumnPrunerReduceSinkProc.process(Node nd, Stack<Node> stack, NodeProcessorCtx ctx, Object... nodeOutputs)
Object	ColumnPrunerProcFactory.ColumnPrunerLateralViewJoinProc.process(Node nd, Stack<Node> stack, NodeProcessorCtx ctx, Object... nodeOutputs)
Object	ColumnPrunerProcFactory.ColumnPrunerLateralViewForwardProc.process(Node nd, Stack<Node> stack, NodeProcessorCtx ctx, Object... nodeOutputs)
Object	ColumnPrunerProcFactory.ColumnPrunerSelectProc.process(Node nd, Stack<Node> stack, NodeProcessorCtx ctx, Object... nodeOutputs)
Object	ColumnPrunerProcFactory.ColumnPrunerJoinProc.process(Node nd, Stack<Node> stack, NodeProcessorCtx ctx, Object... nodeOutputs)
Object	ColumnPrunerProcFactory.ColumnPrunerMapJoinProc.process(Node nd, Stack<Node> stack, NodeProcessorCtx ctx, Object... nodeOutputs)
Object	BucketMapjoinProc.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	BucketingSortingReduceSinkOptimizer.BucketSortReduceSinkProcessor.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
abstract Object	AbstractSMBJoinProc.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
abstract Object	AbstractBucketJoinProc.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
protected void	GroupByOptimizer.SortGroupByProcessor.processGroupBy(GroupByOptimizer.GroupByOptimizerContext ctx, Stack<Node> stack, GroupByOperator groupByOp, int depth)
static org.apache.hadoop.fs.Path[]	SamplePruner.prune(Partition part, FilterDesc.sampleDesc sampleDescr) Prunes to get all the files in the partition that satisfy the TABLESAMPLE clause.
static void	GenMapRedUtils.setMapWork(MapWork plan, ParseContext parseCtx, Set<ReadEntity> inputs, PrunedPartitionList partsList, Operator<? extends OperatorDesc> topOp, String alias_id, HiveConf conf, boolean local) initialize MapWork
static void	GenMapRedUtils.setTaskPlan(String alias_id, Operator<? extends OperatorDesc> topOp, Task<?> task, boolean local, GenMRProcContext opProcCtx) set the current task in the mapredWork.
static void	GenMapRedUtils.setTaskPlan(String alias_id, Operator<? extends OperatorDesc> topOp, Task<?> task, boolean local, GenMRProcContext opProcCtx, PrunedPartitionList pList) set the current task in the mapredWork.
static void	GenMapRedUtils.setTaskPlan(String path, String alias, Operator<? extends OperatorDesc> topOp, MapWork plan, boolean local, TableDesc tt_desc) set the current task in the mapredWork.
ParseContext	Transform.transform(ParseContext pctx) All transformation steps implement this interface.
ParseContext	StatsOptimizer.transform(ParseContext pctx)
ParseContext	SortedMergeBucketMapJoinOptimizer.transform(ParseContext pctx)
ParseContext	SortedDynPartitionOptimizer.transform(ParseContext pCtx)
ParseContext	SkewJoinOptimizer.transform(ParseContext pctx)
ParseContext	SimpleFetchOptimizer.transform(ParseContext pctx)
ParseContext	SimpleFetchAggregation.transform(ParseContext pctx)
ParseContext	SamplePruner.transform(ParseContext pctx)
ParseContext	NonBlockingOpDeDupProc.transform(ParseContext pctx)
ParseContext	MapJoinProcessor.transform(ParseContext pactx) Transform the query tree.
ParseContext	LimitPushdownOptimizer.transform(ParseContext pctx)
ParseContext	JoinReorder.transform(ParseContext pactx) Transform the query tree.
ParseContext	GroupByOptimizer.transform(ParseContext pctx)
ParseContext	GlobalLimitOptimizer.transform(ParseContext pctx)
ParseContext	ColumnPruner.transform(ParseContext pactx) Transform the query tree.
ParseContext	BucketMapJoinOptimizer.transform(ParseContext pctx)
ParseContext	BucketingSortingReduceSinkOptimizer.transform(ParseContext pctx)
void	ColumnPruner.ColumnPrunerWalker.walk(Node nd) Walk the given operator.
static Map<Node,Object>	PrunerUtils.walkExprTree(ExprNodeDesc pred, NodeProcessorCtx ctx, NodeProcessor colProc, NodeProcessor fieldProc, NodeProcessor genFuncProc, NodeProcessor defProc) Walk expression tree for pruner generation.
static void	PrunerUtils.walkOperatorTree(ParseContext pctx, NodeProcessorCtx opWalkerCtx, NodeProcessor filterProc, NodeProcessor defaultProc) Walk operator tree for pruner generation.

Uses of SemanticException in org.apache.hadoop.hive.ql.optimizer.correlation

Methods in org.apache.hadoop.hive.ql.optimizer.correlation that throw SemanticException

protected static void	QueryPlanTreeTransformation.applyCorrelation(ParseContext pCtx, CorrelationOptimizer.CorrelationNodeProcCtx corrCtx, IntraQueryCorrelation correlation) Based on the correlation, we transform the query plan tree (operator tree).
protected static <T extends Operator<?>> T[]	CorrelationUtilities.findParents(JoinOperator join, Class<T> target)
protected static <T extends Operator<?>> T	CorrelationUtilities.findPossibleParent(Operator<?> start, Class<T> target, boolean trustScript)
protected static <T extends Operator<?>> T[]	CorrelationUtilities.findPossibleParents(Operator<?> start, Class<T> target, boolean trustScript)
static List<Operator<? extends OperatorDesc>>	CorrelationUtilities.findSiblingOperators(Operator<? extends OperatorDesc> op) Find all sibling operators (which have the same child operator of op) of op (op included).
static List<ReduceSinkOperator>	CorrelationUtilities.findSiblingReduceSinkOperators(ReduceSinkOperator op) Find all sibling ReduceSinkOperators (which have the same child operator of op) of op (op included).
protected static Operator<?>	CorrelationUtilities.getSingleChild(Operator<?> operator)
protected static Operator<?>	CorrelationUtilities.getSingleChild(Operator<?> operator, boolean throwException)
protected static <T> T	CorrelationUtilities.getSingleChild(Operator<?> operator, Class<T> type)
protected static Operator<?>	CorrelationUtilities.getSingleParent(Operator<?> operator)
protected static Operator<?>	CorrelationUtilities.getSingleParent(Operator<?> operator, boolean throwException)
protected static <T> T	CorrelationUtilities.getSingleParent(Operator<?> operator, Class<T> type)
protected static Operator<?>	CorrelationUtilities.getStartForGroupBy(ReduceSinkOperator cRS)
protected static boolean	CorrelationUtilities.hasGroupingSet(ReduceSinkOperator cRS)
protected static int	CorrelationUtilities.indexOf(ExprNodeDesc cexpr, ExprNodeDesc[] pexprs, Operator child, Operator[] parents, boolean[] sorted)
protected static void	CorrelationUtilities.insertOperatorBetween(Operator<?> newOperator, Operator<?> parent, Operator<?> child)
protected static void	CorrelationUtilities.isNullOperator(Operator<?> operator) throw a exception if the input operator is null
protected boolean	ReduceSinkDeDuplication.AbsctractReducerReducerProc.merge(ReduceSinkOperator cRS, JoinOperator pJoin, int minReducer)
protected boolean	ReduceSinkDeDuplication.AbsctractReducerReducerProc.merge(ReduceSinkOperator cRS, ReduceSinkOperator pRS, int minReducer) Current RSDedup remove/replace child RS.
Object	ReduceSinkDeDuplication.AbsctractReducerReducerProc.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
protected abstract Object	ReduceSinkDeDuplication.AbsctractReducerReducerProc.process(ReduceSinkOperator cRS, GroupByOperator cGBY, ReduceSinkDeDuplication.ReduceSinkDeduplicateProcCtx dedupCtx)
protected abstract Object	ReduceSinkDeDuplication.AbsctractReducerReducerProc.process(ReduceSinkOperator cRS, ReduceSinkDeDuplication.ReduceSinkDeduplicateProcCtx dedupCtx)
protected static void	CorrelationUtilities.removeReduceSinkForGroupBy(ReduceSinkOperator cRS, GroupByOperator cGBYr, ParseContext context, org.apache.hadoop.hive.ql.optimizer.correlation.AbstractCorrelationProcCtx procCtx)
protected static SelectOperator	CorrelationUtilities.replaceOperatorWithSelect(Operator<?> operator, ParseContext context, org.apache.hadoop.hive.ql.optimizer.correlation.AbstractCorrelationProcCtx procCtx)
protected static SelectOperator	CorrelationUtilities.replaceReduceSinkWithSelectOperator(ReduceSinkOperator childRS, ParseContext context, org.apache.hadoop.hive.ql.optimizer.correlation.AbstractCorrelationProcCtx procCtx)
protected Integer	ReduceSinkDeDuplication.AbsctractReducerReducerProc.sameKeys(List<ExprNodeDesc> cexprs, List<ExprNodeDesc> pexprs, Operator<?> child, Operator<?> parent)
ParseContext	ReduceSinkDeDuplication.transform(ParseContext pctx)
ParseContext	CorrelationOptimizer.transform(ParseContext pctx) Detect correlations and transform the query tree.

Uses of SemanticException in org.apache.hadoop.hive.ql.optimizer.index

Methods in org.apache.hadoop.hive.ql.optimizer.index that throw SemanticException

static ParseContext	RewriteParseContextGenerator.generateOperatorTree(HiveConf conf, String command) Parse the input String command and generate a ASTNode tree.
void	RewriteQueryUsingAggregateIndexCtx.invokeRewriteQueryProc(Operator<? extends OperatorDesc> topOp) Walk the original operator tree using the DefaultGraphWalker using the rules.
ParseContext	RewriteGBUsingIndex.transform(ParseContext pctx)

Uses of SemanticException in org.apache.hadoop.hive.ql.optimizer.lineage

Methods in org.apache.hadoop.hive.ql.optimizer.lineage that throw SemanticException

static LineageInfo.Dependency	ExprProcFactory.getExprDependency(LineageCtx lctx, Operator<? extends OperatorDesc> inpOp, ExprNodeDesc expr) Gets the expression dependencies for the expression.
Object	OpProcFactory.TransformLineage.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	OpProcFactory.TableScanLineage.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	OpProcFactory.JoinLineage.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	OpProcFactory.LateralViewJoinLineage.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	OpProcFactory.SelectLineage.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	OpProcFactory.GroupByLineage.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	OpProcFactory.UnionLineage.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	OpProcFactory.ReduceSinkLineage.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	OpProcFactory.DefaultLineage.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	ExprProcFactory.ColumnExprProcessor.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	ExprProcFactory.GenericExprProcessor.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	ExprProcFactory.DefaultExprProcessor.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
ParseContext	Generator.transform(ParseContext pctx)

Uses of SemanticException in org.apache.hadoop.hive.ql.optimizer.listbucketingpruner

Methods in org.apache.hadoop.hive.ql.optimizer.listbucketingpruner that throw SemanticException

static List<List<String>>	ListBucketingPruner.DynamicMultiDimensionalCollection.flat(List<List<String>> uniqSkewedElements) Flat a dynamic-multi-dimension collection.
static List<List<String>>	ListBucketingPruner.DynamicMultiDimensionalCollection.generateCollection(List<List<String>> values) Find out complete skewed-element collection For example: 1.
protected void	LBProcFactory.LBPRFilterPruner.generatePredicate(NodeProcessorCtx procCtx, FilterOperator fop, TableScanOperator top)
protected void	LBPartitionProcFactory.LBPRPartitionFilterPruner.generatePredicate(NodeProcessorCtx procCtx, FilterOperator fop, TableScanOperator top)
static ExprNodeDesc	LBExprProcFactory.genPruner(String tabAlias, ExprNodeDesc pred, Partition part) Generates the list bucketing pruner for the expression tree.
ParseContext	ListBucketingPruner.transform(ParseContext pctx)

Uses of SemanticException in org.apache.hadoop.hive.ql.optimizer.metainfo.annotation

Methods in org.apache.hadoop.hive.ql.optimizer.metainfo.annotation that throw SemanticException

boolean	OpTraitsRulesProcFactory.TableScanRule.checkBucketedTable(Table tbl, ParseContext pGraphContext, PrunedPartitionList prunedParts)
Object	OpTraitsRulesProcFactory.DefaultRule.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	OpTraitsRulesProcFactory.ReduceSinkRule.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	OpTraitsRulesProcFactory.TableScanRule.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	OpTraitsRulesProcFactory.GroupByRule.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	OpTraitsRulesProcFactory.SelectRule.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	OpTraitsRulesProcFactory.JoinRule.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	OpTraitsRulesProcFactory.MultiParentRule.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
ParseContext	AnnotateWithOpTraits.transform(ParseContext pctx)

Uses of SemanticException in org.apache.hadoop.hive.ql.optimizer.pcr

Methods in org.apache.hadoop.hive.ql.optimizer.pcr that throw SemanticException

Object	PcrOpProcFactory.FilterPCR.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	PcrOpProcFactory.DefaultPCR.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	PcrExprProcFactory.ColumnExprProcessor.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	PcrExprProcFactory.GenericFuncExprProcessor.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	PcrExprProcFactory.FieldExprProcessor.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	PcrExprProcFactory.DefaultExprProcessor.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
ParseContext	PartitionConditionRemover.transform(ParseContext pctx)
static PcrExprProcFactory.NodeInfoWrapper	PcrExprProcFactory.walkExprTree(String tabAlias, ArrayList<Partition> parts, List<VirtualColumn> vcs, ExprNodeDesc pred) Remove partition conditions when necessary from the the expression tree.

Uses of SemanticException in org.apache.hadoop.hive.ql.optimizer.physical

Methods in org.apache.hadoop.hive.ql.optimizer.physical that throw SemanticException

Object	CrossProductCheck.dispatch(Node nd, Stack<Node> stack, Object... nodeOutputs)
Object	AbstractJoinTaskDispatcher.dispatch(Node nd, Stack<Node> stack, Object... nodeOutputs)
long	AbstractJoinTaskDispatcher.getTotalKnownInputSize(Context context, MapWork currWork, Map<String,ArrayList<String>> pathToAliases, HashMap<String,Long> aliasToSize)
PhysicalContext	PhysicalOptimizer.optimize() invoke all the resolvers one-by-one, and alter the physical plan.
Object	SkewJoinProcFactory.SkewJoinJoinProcessor.process(Node nd, Stack<Node> stack, NodeProcessorCtx ctx, Object... nodeOutputs)
Object	SkewJoinProcFactory.SkewJoinDefaultProcessor.process(Node nd, Stack<Node> stack, NodeProcessorCtx ctx, Object... nodeOutputs)
Object	LocalMapJoinProcFactory.MapJoinFollowedByGroupByProcessor.process(Node nd, Stack<Node> stack, NodeProcessorCtx ctx, Object... nodeOutputs)
Object	LocalMapJoinProcFactory.LocalMapJoinProcessor.process(Node nd, Stack<Node> stack, NodeProcessorCtx ctx, Object... nodeOutputs)
Object	BucketingSortingOpProcFactory.DefaultInferrer.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	BucketingSortingOpProcFactory.JoinInferrer.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	BucketingSortingOpProcFactory.SelectInferrer.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	BucketingSortingOpProcFactory.FileSinkInferrer.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	BucketingSortingOpProcFactory.ExtractInferrer.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	BucketingSortingOpProcFactory.MultiGroupByInferrer.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	BucketingSortingOpProcFactory.GroupByInferrer.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	BucketingSortingOpProcFactory.ForwardingInferrer.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Task<? extends Serializable>	SortMergeJoinTaskDispatcher.processCurrentTask(MapRedTask currTask, ConditionalTask conditionalTask, Context context)
Task<? extends Serializable>	CommonJoinTaskDispatcher.processCurrentTask(MapRedTask currTask, ConditionalTask conditionalTask, Context context)
abstract Task<? extends Serializable>	AbstractJoinTaskDispatcher.processCurrentTask(MapRedTask currTask, ConditionalTask conditionalTask, Context context)
static void	GenMRSkewJoinProcessor.processSkewJoin(JoinOperator joinOp, Task<? extends Serializable> currTask, ParseContext parseCtx) Create tasks for processing skew joins.
PhysicalContext	Vectorizer.resolve(PhysicalContext pctx)
PhysicalContext	StageIDsRearranger.resolve(PhysicalContext pctx)
PhysicalContext	SortMergeJoinResolver.resolve(PhysicalContext pctx)
PhysicalContext	SkewJoinResolver.resolve(PhysicalContext pctx)
PhysicalContext	SamplingOptimizer.resolve(PhysicalContext pctx)
PhysicalContext	PhysicalPlanResolver.resolve(PhysicalContext pctx) All physical plan resolvers have to implement this entry method.
PhysicalContext	MetadataOnlyOptimizer.resolve(PhysicalContext pctx)
PhysicalContext	MapJoinResolver.resolve(PhysicalContext pctx)
PhysicalContext	IndexWhereResolver.resolve(PhysicalContext physicalContext)
PhysicalContext	CrossProductCheck.resolve(PhysicalContext pctx)
PhysicalContext	CommonJoinResolver.resolve(PhysicalContext pctx)
PhysicalContext	BucketingSortingInferenceOptimizer.resolve(PhysicalContext pctx)

Uses of SemanticException in org.apache.hadoop.hive.ql.optimizer.physical.index

Methods in org.apache.hadoop.hive.ql.optimizer.physical.index that throw SemanticException

Object	IndexWhereTaskDispatcher.dispatch(Node nd, Stack<Node> stack, Object... nodeOutputs)
Object	IndexWhereProcessor.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)

Uses of SemanticException in org.apache.hadoop.hive.ql.optimizer.ppr

Methods in org.apache.hadoop.hive.ql.optimizer.ppr that throw SemanticException

protected void	OpProcFactory.FilterPPR.generatePredicate(NodeProcessorCtx procCtx, FilterOperator fop, TableScanOperator top)
static ExprNodeDesc	ExprProcFactory.genPruner(String tabAlias, ExprNodeDesc pred) Generates the partition pruner for the expression tree.
ParseContext	PartitionPruner.transform(ParseContext pctx)

Uses of SemanticException in org.apache.hadoop.hive.ql.optimizer.stats.annotation

Methods in org.apache.hadoop.hive.ql.optimizer.stats.annotation that throw SemanticException

Object	StatsRulesProcFactory.TableScanStatsRule.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	StatsRulesProcFactory.SelectStatsRule.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	StatsRulesProcFactory.FilterStatsRule.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	StatsRulesProcFactory.GroupByStatsRule.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	StatsRulesProcFactory.JoinStatsRule.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	StatsRulesProcFactory.LimitStatsRule.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	StatsRulesProcFactory.DefaultStatsRule.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
ParseContext	AnnotateWithStatistics.transform(ParseContext pctx)

Uses of SemanticException in org.apache.hadoop.hive.ql.optimizer.unionproc

Methods in org.apache.hadoop.hive.ql.optimizer.unionproc that throw SemanticException

Object	UnionProcFactory.MapRedUnion.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	UnionProcFactory.MapUnion.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	UnionProcFactory.UnknownUnion.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	UnionProcFactory.UnionNoProcessFile.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	UnionProcFactory.NoUnion.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
ParseContext	UnionProcessor.transform(ParseContext pCtx) Transform the query tree.

Uses of SemanticException in org.apache.hadoop.hive.ql.parse

Methods in org.apache.hadoop.hive.ql.parse that throw SemanticException

protected static ArrayList<PTFInvocationSpec.OrderExpression>	PTFTranslator.addPartitionExpressionsToOrderList(ArrayList<PTFInvocationSpec.PartitionExpression> partCols, ArrayList<PTFInvocationSpec.OrderExpression> orderCols)
void	ColumnStatsSemanticAnalyzer.analyze(ASTNode ast, Context origCtx)
void	BaseSemanticAnalyzer.analyze(ASTNode ast, Context ctx)
ColumnAccessInfo	ColumnAccessAnalyzer.analyzeColumnAccess()
protected void	BaseSemanticAnalyzer.analyzeDDLSkewedValues(List<List<String>> skewedValues, ASTNode child) Handle skewed values in DDL.
void	SemanticAnalyzer.analyzeInternal(ASTNode ast)
void	MacroSemanticAnalyzer.analyzeInternal(ASTNode ast)
void	LoadSemanticAnalyzer.analyzeInternal(ASTNode ast)
void	ImportSemanticAnalyzer.analyzeInternal(ASTNode ast)
void	FunctionSemanticAnalyzer.analyzeInternal(ASTNode ast)
void	ExportSemanticAnalyzer.analyzeInternal(ASTNode ast)
void	ExplainSemanticAnalyzer.analyzeInternal(ASTNode ast)
void	DDLSemanticAnalyzer.analyzeInternal(ASTNode ast)
abstract void	BaseSemanticAnalyzer.analyzeInternal(ASTNode ast)
protected List<String>	BaseSemanticAnalyzer.analyzeSkewedTablDDLColNames(List<String> skewedColNames, ASTNode child) Analyze list bucket column names
TableAccessInfo	TableAccessAnalyzer.analyzeTableAccess()
protected static RowResolver	PTFTranslator.buildRowResolverForNoop(String tabAlias, StructObjectInspector rowObjectInspector, RowResolver inputRowResolver)
protected static RowResolver	PTFTranslator.buildRowResolverForPTF(String tbFnName, String tabAlias, StructObjectInspector rowObjectInspector, List<String> outputColNames, RowResolver inputRR)
protected RowResolver	PTFTranslator.buildRowResolverForWindowing(WindowTableFunctionDef def)
static String	BaseSemanticAnalyzer.charSetString(String charSetName, String charSetString)
void	RowResolver.checkColumn(String tableAlias, String columnAlias) check if column name is already exist in RR
void	TaskCompiler.compile(ParseContext pCtx, List<Task<? extends Serializable>> rootTasks, HashSet<ReadEntity> inputs, HashSet<WriteEntity> outputs)
static ArrayList<PTFInvocationSpec>	PTFTranslator.componentize(PTFInvocationSpec ptfInvocation)
static void	EximUtil.createExportDump(org.apache.hadoop.fs.FileSystem fs, org.apache.hadoop.fs.Path metadataPath, Table tableHandle, List<Partition> partitions)
protected static Hive	BaseSemanticAnalyzer.createHiveDB(HiveConf conf)
MapWork	GenTezUtils.createMapWork(GenTezProcContext context, Operator<?> root, TezWork tezWork, PrunedPartitionList partitions)
protected void	TezCompiler.decideExecMode(List<Task<? extends Serializable>> rootTasks, Context ctx, GlobalLimitCtx globalLimitCtx)
protected abstract void	TaskCompiler.decideExecMode(List<Task<? extends Serializable>> rootTasks, Context ctx, GlobalLimitCtx globalLimitCtx)
protected void	MapReduceCompiler.decideExecMode(List<Task<? extends Serializable>> rootTasks, Context ctx, GlobalLimitCtx globalLimitCtx)
static void	EximUtil.doCheckCompatibility(String currVersion, String version, String fcVersion)
boolean	SemanticAnalyzer.doPhase1(ASTNode ast, QB qb, org.apache.hadoop.hive.ql.parse.SemanticAnalyzer.Phase1Ctx ctx_1) Phase 1: (including, but not limited to): 1.
void	SemanticAnalyzer.doPhase1QBExpr(ASTNode ast, QBExpr qbexpr, String id, String alias)
protected HashMap<String,String>	BaseSemanticAnalyzer.extractPartitionSpecs(org.antlr.runtime.tree.Tree partspec)
Map<ASTNode,ExprNodeDesc>	SemanticAnalyzer.genAllExprNodeDesc(ASTNode expr, RowResolver input) Generates an expression node descriptors for the expression and children of it with default TypeCheckCtx.
Map<ASTNode,ExprNodeDesc>	SemanticAnalyzer.genAllExprNodeDesc(ASTNode expr, RowResolver input, TypeCheckCtx tcCtx) Generates all of the expression node descriptors for the expression and children of it passed in the arguments.
protected void	TezCompiler.generateTaskTree(List<Task<? extends Serializable>> rootTasks, ParseContext pCtx, List<Task<MoveWork>> mvTask, Set<ReadEntity> inputs, Set<WriteEntity> outputs)
protected abstract void	TaskCompiler.generateTaskTree(List<Task<? extends Serializable>> rootTasks, ParseContext pCtx, List<Task<MoveWork>> mvTask, Set<ReadEntity> inputs, Set<WriteEntity> outputs)
protected void	MapReduceCompiler.generateTaskTree(List<Task<? extends Serializable>> rootTasks, ParseContext pCtx, List<Task<MoveWork>> mvTask, Set<ReadEntity> inputs, Set<WriteEntity> outputs)
static Map<ASTNode,ExprNodeDesc>	TypeCheckProcFactory.genExprNode(ASTNode expr, TypeCheckCtx tcCtx)
ExprNodeDesc	SemanticAnalyzer.genExprNodeDesc(ASTNode expr, RowResolver input) Generates an expression node descriptor for the expression with TypeCheckCtx.
ExprNodeDesc	SemanticAnalyzer.genExprNodeDesc(ASTNode expr, RowResolver input, TypeCheckCtx tcCtx) Returns expression node descriptor for the expression.
Operator	SemanticAnalyzer.genPlan(QB qb)
static QBSubQuery.SubQueryType	QBSubQuery.SubQueryType.get(ASTNode opNode)
static BaseSemanticAnalyzer	SemanticAnalyzerFactory.get(HiveConf conf, ASTNode tree)
ColumnInfo	RowResolver.get(String tab_alias, String col_alias) Gets the column Info to tab_alias.col_alias type of a column reference.
static ASTNode	PTFTranslator.getASTNode(ColumnInfo cInfo, RowResolver rr)
static CharTypeInfo	ParseUtils.getCharTypeInfo(ASTNode node)
protected List<FieldSchema>	BaseSemanticAnalyzer.getColumns(ASTNode ast)
static List<FieldSchema>	BaseSemanticAnalyzer.getColumns(ASTNode ast, boolean lowerCase) Get the list of FieldSchema out of the ASTNode.
protected Database	BaseSemanticAnalyzer.getDatabase(String dbName)
protected Database	BaseSemanticAnalyzer.getDatabase(String dbName, boolean throwException)
static DecimalTypeInfo	ParseUtils.getDecimalTypeTypeInfo(ASTNode node)
ColumnInfo	RowResolver.getExpression(ASTNode node) Retrieves the ColumnInfo corresponding to a source expression which exactly matches the string rendering of the given ASTNode.
void	SemanticAnalyzer.getMetaData(QB qb)
void	SemanticAnalyzer.getMetaData(QB qb, ReadEntity parentInput)
protected Partition	BaseSemanticAnalyzer.getPartition(Table table, Map<String,String> partSpec, boolean throwException)
protected List<Partition>	BaseSemanticAnalyzer.getPartitions(Table table, Map<String,String> partSpec, boolean throwException)
static HashMap<String,String>	DDLSemanticAnalyzer.getPartSpec(ASTNode partspec)
protected List<String>	BaseSemanticAnalyzer.getSkewedValuesFromASTNode(Node node) Retrieve skewed values from ASTNode.
protected Table	BaseSemanticAnalyzer.getTable(String tblName)
protected Table	BaseSemanticAnalyzer.getTable(String tblName, boolean throwException)
protected Table	BaseSemanticAnalyzer.getTable(String database, String tblName, boolean throwException)
protected Table	BaseSemanticAnalyzer.getTableWithQN(String qnName, boolean throwException)
static String	DDLSemanticAnalyzer.getTypeName(ASTNode node)
protected static String	BaseSemanticAnalyzer.getTypeStringFromAST(ASTNode typeNode)
static VarcharTypeInfo	ParseUtils.getVarcharTypeInfo(ASTNode node)
protected void	BaseSemanticAnalyzer.handleGenericFileFormat(ASTNode node)
WindowingSpec	WindowingComponentizer.next(HiveConf hCfg, SemanticAnalyzer semAly, org.apache.hadoop.hive.ql.parse.UnparseTranslator unparseT, RowResolver inputRR)
protected void	TezCompiler.optimizeOperatorPlan(ParseContext pCtx, Set<ReadEntity> inputs, Set<WriteEntity> outputs)
protected void	TaskCompiler.optimizeOperatorPlan(ParseContext pCtxSet, Set<ReadEntity> inputs, Set<WriteEntity> outputs)
protected void	TezCompiler.optimizeTaskPlan(List<Task<? extends Serializable>> rootTasks, ParseContext pCtx, Context ctx)
protected abstract void	TaskCompiler.optimizeTaskPlan(List<Task<? extends Serializable>> rootTasks, ParseContext pCtx, Context ctx)
protected void	MapReduceCompiler.optimizeTaskPlan(List<Task<? extends Serializable>> rootTasks, ParseContext pCtx, Context ctx)
static ArrayList<WindowingSpec.WindowExpressionSpec>	SemanticAnalyzer.parseSelect(String selectExprStr)
void	HiveSemanticAnalyzerHook.postAnalyze(HiveSemanticAnalyzerHookContext context, List<Task<? extends Serializable>> rootTasks) Invoked after Hive performs its own semantic analysis on a statement (including optimization).
void	AbstractSemanticAnalyzerHook.postAnalyze(HiveSemanticAnalyzerHookContext context, List<Task<? extends Serializable>> rootTasks)
ASTNode	HiveSemanticAnalyzerHook.preAnalyze(HiveSemanticAnalyzerHookContext context, ASTNode ast) Invoked before Hive performs its own semantic analysis on a statement.
ASTNode	AbstractSemanticAnalyzerHook.preAnalyze(HiveSemanticAnalyzerHookContext context, ASTNode ast)
Object	TypeCheckProcFactory.NullExprProcessor.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	TypeCheckProcFactory.NumExprProcessor.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	TypeCheckProcFactory.StrExprProcessor.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	TypeCheckProcFactory.BoolExprProcessor.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	TypeCheckProcFactory.DateExprProcessor.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	TypeCheckProcFactory.ColumnExprProcessor.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	TypeCheckProcFactory.DefaultExprProcessor.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	TypeCheckProcFactory.SubQueryExprProcessor.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	ProcessAnalyzeTable.process(Node nd, Stack<Node> stack, NodeProcessorCtx procContext, Object... nodeOutputs)
Object	PrintOpTreeProcessor.process(Node nd, Stack<Node> stack, NodeProcessorCtx ctx, Object... nodeOutputs)
Object	GenTezWork.process(Node nd, Stack<Node> stack, NodeProcessorCtx procContext, Object... nodeOutputs)
Object	FileSinkProcessor.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
void	GenTezUtils.processFileSink(GenTezProcContext context, FileSinkOperator fileSink)
static ExprNodeDesc	TypeCheckProcFactory.processGByExpr(Node nd, Object procCtx) Function to do groupby subexpression elimination.
protected void	SemanticAnalyzer.processNoScanCommand(ASTNode tree) process analyze ...
protected void	SemanticAnalyzer.processPartialScanCommand(ASTNode tree) process analyze ...
static Map.Entry<Table,List<Partition>>	EximUtil.readMetaData(org.apache.hadoop.fs.FileSystem fs, org.apache.hadoop.fs.Path metadataPath)
static String	EximUtil.relativeToAbsolutePath(HiveConf conf, String location)
void	GenTezUtils.removeUnionOperators(org.apache.hadoop.conf.Configuration conf, GenTezProcContext context, BaseWork work)
protected void	GenTezUtils.setupMapWork(MapWork mapWork, GenTezProcContext context, PrunedPartitionList partitions, Operator<? extends OperatorDesc> root, String alias)
void	GenTezWorkWalker.startWalking(Collection<Node> startNodes, HashMap<Node,Object> nodeOutput) starting point for walking.
PTFDesc	PTFTranslator.translate(PTFInvocationSpec qSpec, SemanticAnalyzer semAly, HiveConf hCfg, RowResolver inputRR, org.apache.hadoop.hive.ql.parse.UnparseTranslator unparseT)
PTFDesc	PTFTranslator.translate(WindowingSpec wdwSpec, SemanticAnalyzer semAly, HiveConf hCfg, RowResolver inputRR, org.apache.hadoop.hive.ql.parse.UnparseTranslator unparseT)
void	SemanticAnalyzer.validate()
void	BaseSemanticAnalyzer.validate()
void	WindowingSpec.validateAndMakeEffective()
static List<String>	ParseUtils.validateColumnNameUniqueness(List<FieldSchema> fieldSchemas)
protected static void	PTFTranslator.validateComparable(ObjectInspector OI, String errMsg)
static void	PTFTranslator.validateNoLeadLagInValueBoundarySpec(ASTNode node)
static void	BaseSemanticAnalyzer.validatePartSpec(Table tbl, Map<String,String> partSpec, ASTNode astNode, HiveConf conf, boolean shouldBeFull)
void	TezWalker.walk(Node nd) Walk the given operator.
void	GenTezWorkWalker.walk(Node nd) Walk the given operator.
void	GenMapRedWalker.walk(Node nd) Walk the given operator.

Constructors in org.apache.hadoop.hive.ql.parse that throw SemanticException

BaseSemanticAnalyzer.tableSpec(Hive db, HiveConf conf, ASTNode ast)

BaseSemanticAnalyzer.tableSpec(Hive db, HiveConf conf, ASTNode ast, boolean allowDynamicPartitionsSpec, boolean allowPartialPartitionsSpec)

BaseSemanticAnalyzer(HiveConf conf)

BaseSemanticAnalyzer(HiveConf conf, Hive db)

ColumnStatsSemanticAnalyzer(HiveConf conf)

ColumnStatsSemanticAnalyzer(HiveConf conf, ASTNode tree)

DDLSemanticAnalyzer(HiveConf conf)

DDLSemanticAnalyzer(HiveConf conf, Hive db)

ExplainSemanticAnalyzer(HiveConf conf)

ExportSemanticAnalyzer(HiveConf conf)

FunctionSemanticAnalyzer(HiveConf conf)

ImportSemanticAnalyzer(HiveConf conf)

LoadSemanticAnalyzer(HiveConf conf)

MacroSemanticAnalyzer(HiveConf conf)

SemanticAnalyzer(HiveConf conf)

WindowingComponentizer(WindowingSpec originalSpec)

Uses of SemanticException in org.apache.hadoop.hive.ql.parse.authorization

Methods in org.apache.hadoop.hive.ql.parse.authorization that throw SemanticException

Task<? extends Serializable>	HiveAuthorizationTaskFactory.createCreateRoleTask(ASTNode node, HashSet<ReadEntity> inputs, HashSet<WriteEntity> outputs)
Task<? extends Serializable>	HiveAuthorizationTaskFactory.createDropRoleTask(ASTNode node, HashSet<ReadEntity> inputs, HashSet<WriteEntity> outputs)
Task<? extends Serializable>	HiveAuthorizationTaskFactory.createGrantRoleTask(ASTNode node, HashSet<ReadEntity> inputs, HashSet<WriteEntity> outputs)
Task<? extends Serializable>	HiveAuthorizationTaskFactoryImpl.createGrantTask(ASTNode ast, HashSet<ReadEntity> inputs, HashSet<WriteEntity> outputs)
Task<? extends Serializable>	HiveAuthorizationTaskFactory.createGrantTask(ASTNode node, HashSet<ReadEntity> inputs, HashSet<WriteEntity> outputs)
Task<? extends Serializable>	HiveAuthorizationTaskFactory.createRevokeRoleTask(ASTNode node, HashSet<ReadEntity> inputs, HashSet<WriteEntity> outputs)
Task<? extends Serializable>	HiveAuthorizationTaskFactoryImpl.createRevokeTask(ASTNode ast, HashSet<ReadEntity> inputs, HashSet<WriteEntity> outputs)
Task<? extends Serializable>	HiveAuthorizationTaskFactory.createRevokeTask(ASTNode node, HashSet<ReadEntity> inputs, HashSet<WriteEntity> outputs)
Task<? extends Serializable>	HiveAuthorizationTaskFactoryImpl.createSetRoleTask(String roleName, HashSet<ReadEntity> inputs, HashSet<WriteEntity> outputs)
Task<? extends Serializable>	HiveAuthorizationTaskFactory.createSetRoleTask(String roleName, HashSet<ReadEntity> inputs, HashSet<WriteEntity> outputs)
Task<? extends Serializable>	HiveAuthorizationTaskFactoryImpl.createShowCurrentRoleTask(HashSet<ReadEntity> inputs, HashSet<WriteEntity> outputs, org.apache.hadoop.fs.Path resFile)
Task<? extends Serializable>	HiveAuthorizationTaskFactory.createShowCurrentRoleTask(HashSet<ReadEntity> inputs, HashSet<WriteEntity> outputs, org.apache.hadoop.fs.Path resFile)
Task<? extends Serializable>	HiveAuthorizationTaskFactoryImpl.createShowGrantTask(ASTNode ast, org.apache.hadoop.fs.Path resultFile, HashSet<ReadEntity> inputs, HashSet<WriteEntity> outputs)
Task<? extends Serializable>	HiveAuthorizationTaskFactory.createShowGrantTask(ASTNode node, org.apache.hadoop.fs.Path resultFile, HashSet<ReadEntity> inputs, HashSet<WriteEntity> outputs)
Task<? extends Serializable>	HiveAuthorizationTaskFactory.createShowRoleGrantTask(ASTNode node, org.apache.hadoop.fs.Path resultFile, HashSet<ReadEntity> inputs, HashSet<WriteEntity> outputs)
Task<? extends Serializable>	HiveAuthorizationTaskFactoryImpl.createShowRolePrincipalsTask(ASTNode ast, org.apache.hadoop.fs.Path resFile, HashSet<ReadEntity> inputs, HashSet<WriteEntity> outputs)
Task<? extends Serializable>	HiveAuthorizationTaskFactory.createShowRolePrincipalsTask(ASTNode ast, org.apache.hadoop.fs.Path resFile, HashSet<ReadEntity> inputs, HashSet<WriteEntity> outputs)

Uses of SemanticException in org.apache.hadoop.hive.ql.plan

Methods in org.apache.hadoop.hive.ql.plan that throw SemanticException

static ExprNodeDesc	ExprNodeDescUtils.backtrack(ExprNodeDesc source, Operator<?> current, Operator<?> terminal)
static ArrayList<ExprNodeDesc>	ExprNodeDescUtils.backtrack(List<ExprNodeDesc> sources, Operator<?> current, Operator<?> terminal) Convert expressions in current operator to those in terminal operator, which is an ancestor of current or null (back to top operator).
static ReduceSinkDesc	PlanUtils.getReduceSinkDesc(ArrayList<ExprNodeDesc> keyCols, ArrayList<ExprNodeDesc> valueCols, List<String> outputColumnNames, boolean includeKey, int tag, int numPartitionFields, int numReducers) Create the reduce sink descriptor.
static ReduceSinkDesc	PlanUtils.getReduceSinkDesc(ArrayList<ExprNodeDesc> keyCols, int numKeys, ArrayList<ExprNodeDesc> valueCols, List<List<Integer>> distinctColIndices, List<String> outputKeyColumnNames, List<String> outputValueColumnNames, boolean includeKey, int tag, int numPartitionFields, int numReducers) Create the reduce sink descriptor.
static Operator<?>	ExprNodeDescUtils.getSingleParent(Operator<?> current, Operator<?> terminal)
void	AlterTableDesc.validate() Validate alter table description.
void	CreateTableDesc.validate(HiveConf conf)
static void	ValidationUtility.validateSkewedColNames(List<String> colNames, List<String> skewedColNames) Skewed column name should be a valid column defined.
static void	ValidationUtility.validateSkewedColNameValueNumberMatch(List<String> skewedColNames, List<List<String>> skewedColValues) Skewed column name and value should match.
static void	ValidationUtility.validateSkewedColumnNameUniqueness(List<String> names) Find out duplicate name.
static void	ValidationUtility.validateSkewedInformation(List<String> colNames, List<String> skewedColNames, List<List<String>> skewedColValues) Validate skewed table information.

Uses of SemanticException in org.apache.hadoop.hive.ql.ppd

Methods in org.apache.hadoop.hive.ql.ppd that throw SemanticException

static ExprWalkerInfo	ExprWalkerProcFactory.extractPushdownPreds(OpWalkerInfo opContext, Operator<? extends OperatorDesc> op, ExprNodeDesc pred)
static ExprWalkerInfo	ExprWalkerProcFactory.extractPushdownPreds(OpWalkerInfo opContext, Operator<? extends OperatorDesc> op, List<ExprNodeDesc> preds) Extracts pushdown predicates from the given list of predicate expression.
protected Set<String>	OpProcFactory.JoinerPPD.getAliases(Node nd, OpWalkerInfo owi)
protected Object	OpProcFactory.JoinerPPD.handlePredicates(Node nd, ExprWalkerInfo prunePreds, OpWalkerInfo owi)
protected Object	OpProcFactory.JoinPPD.handlePredicates(Node nd, ExprWalkerInfo prunePreds, OpWalkerInfo owi)
protected ExprWalkerInfo	OpProcFactory.DefaultPPD.mergeChildrenPred(Node nd, OpWalkerInfo owi, Set<String> excludedAliases, boolean ignoreAliases)
protected boolean	OpProcFactory.DefaultPPD.mergeWithChildrenPred(Node nd, OpWalkerInfo owi, ExprWalkerInfo ewi, Set<String> aliases) Take current operators pushdown predicates and merges them with children's pushdown predicates.
Object	OpProcFactory.ScriptPPD.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	OpProcFactory.UDTFPPD.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	OpProcFactory.LateralViewForwardPPD.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	OpProcFactory.TableScanPPD.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	OpProcFactory.FilterPPD.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	OpProcFactory.JoinerPPD.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	OpProcFactory.DefaultPPD.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	ExprWalkerProcFactory.ColumnExprProcessor.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs) Converts the reference from child row resolver to current row resolver.
Object	ExprWalkerProcFactory.FieldExprProcessor.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	ExprWalkerProcFactory.GenericFuncExprProcessor.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
Object	ExprWalkerProcFactory.DefaultExprProcessor.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs)
ParseContext	PredicateTransitivePropagate.transform(ParseContext pctx)
ParseContext	PredicatePushDown.transform(ParseContext pctx)

Uses of SemanticException in org.apache.hadoop.hive.ql.tools

Methods in org.apache.hadoop.hive.ql.tools that throw SemanticException

void	LineageInfo.getLineageInfo(String query) parses given query and gets the lineage info.
static void	LineageInfo.main(String[] args)
Object	LineageInfo.process(Node nd, Stack<Node> stack, NodeProcessorCtx procCtx, Object... nodeOutputs) Implements the process method for the NodeProcessor interface.

Uses of SemanticException in org.apache.hadoop.hive.ql.udf.generic

Methods in org.apache.hadoop.hive.ql.udf.generic that throw SemanticException

GenericUDAFEvaluator	GenericUDAFResolver2.getEvaluator(GenericUDAFParameterInfo info) Get the evaluator for the parameter types.
GenericUDAFEvaluator	GenericUDAFPercentileApprox.getEvaluator(GenericUDAFParameterInfo info)
GenericUDAFEvaluator	GenericUDAFLeadLag.getEvaluator(GenericUDAFParameterInfo parameters)
GenericUDAFEvaluator	GenericUDAFCount.getEvaluator(GenericUDAFParameterInfo paramInfo)
GenericUDAFEvaluator	AbstractGenericUDAFResolver.getEvaluator(GenericUDAFParameterInfo info)
GenericUDAFEvaluator	GenericUDAFVarianceSample.getEvaluator(TypeInfo[] parameters)
GenericUDAFEvaluator	GenericUDAFVariance.getEvaluator(TypeInfo[] parameters)
GenericUDAFEvaluator	GenericUDAFSum.getEvaluator(TypeInfo[] parameters)
GenericUDAFEvaluator	GenericUDAFStdSample.getEvaluator(TypeInfo[] parameters)
GenericUDAFEvaluator	GenericUDAFStd.getEvaluator(TypeInfo[] parameters)
GenericUDAFEvaluator	GenericUDAFRowNumber.getEvaluator(TypeInfo[] parameters)
GenericUDAFEvaluator	GenericUDAFResolver.getEvaluator(TypeInfo[] parameters) Deprecated. Get the evaluator for the parameter types.
GenericUDAFEvaluator	GenericUDAFRank.getEvaluator(TypeInfo[] parameters)
GenericUDAFEvaluator	GenericUDAFNTile.getEvaluator(TypeInfo[] parameters)
GenericUDAFEvaluator	GenericUDAFnGrams.getEvaluator(TypeInfo[] parameters)
GenericUDAFEvaluator	GenericUDAFMin.getEvaluator(TypeInfo[] parameters)
GenericUDAFEvaluator	GenericUDAFMax.getEvaluator(TypeInfo[] parameters)
GenericUDAFEvaluator	GenericUDAFLastValue.getEvaluator(TypeInfo[] parameters)
GenericUDAFEvaluator	GenericUDAFHistogramNumeric.getEvaluator(TypeInfo[] parameters)
GenericUDAFEvaluator	GenericUDAFFirstValue.getEvaluator(TypeInfo[] parameters)
GenericUDAFEvaluator	GenericUDAFEWAHBitmap.getEvaluator(TypeInfo[] parameters)
GenericUDAFEvaluator	GenericUDAFCovarianceSample.getEvaluator(TypeInfo[] parameters)
GenericUDAFEvaluator	GenericUDAFCovariance.getEvaluator(TypeInfo[] parameters)
GenericUDAFEvaluator	GenericUDAFCount.getEvaluator(TypeInfo[] parameters)
GenericUDAFEvaluator	GenericUDAFCorrelation.getEvaluator(TypeInfo[] parameters)
GenericUDAFEvaluator	GenericUDAFContextNGrams.getEvaluator(TypeInfo[] parameters)
GenericUDAFEvaluator	GenericUDAFComputeStats.getEvaluator(TypeInfo[] parameters)
GenericUDAFEvaluator	GenericUDAFCollectSet.getEvaluator(TypeInfo[] parameters)
GenericUDAFEvaluator	GenericUDAFCollectList.getEvaluator(TypeInfo[] parameters)
GenericUDAFEvaluator	GenericUDAFBridge.getEvaluator(TypeInfo[] parameters)
GenericUDAFEvaluator	GenericUDAFAverage.getEvaluator(TypeInfo[] parameters)
GenericUDAFEvaluator	AbstractGenericUDAFResolver.getEvaluator(TypeInfo[] info)

Uses of SemanticException in org.apache.hadoop.hive.ql.udf.ptf

Methods in org.apache.hadoop.hive.ql.udf.ptf that throw SemanticException

static ExprNodeDesc	MatchPath.ResultExpressionParser.buildExprNode(ASTNode expr, TypeCheckCtx typeCheckCtx)
protected static RowResolver	MatchPath.createSelectListRR(MatchPath evaluator, PTFInputDef inpDef)
abstract List<String>	TableFunctionResolver.getOutputColumnNames()
List<String>	TableFunctionResolver.getRawInputColumnNames()
ArrayList<String>	NoopWithMap.NoopWithMapResolver.getRawInputColumnNames()
void	TableFunctionResolver.initialize(HiveConf cfg, PTFDesc ptfDesc, PartitionedTableFunctionDef tDef)
void	MatchPath.SymbolParser.parse()
void	WindowingTableFunction.WindowingTableFunctionResolver.setupOutputOI()
abstract void	TableFunctionResolver.setupOutputOI()
void	NoopWithMap.NoopWithMapResolver.setupOutputOI()
void	Noop.NoopResolver.setupOutputOI()
void	MatchPath.MatchPathResolver.setupOutputOI() check structure of Arguments: First arg should be a String then there should be an even number of Arguments: String, expression; expression should be Convertible to Boolean.
void	TableFunctionResolver.setupRawInputOI()
void	NoopWithMap.NoopWithMapResolver.setupRawInputOI()
void	MatchPath.ResultExpressionParser.translate()