Uses of Class
org.apache.tajo.plan.PlanningException

Packages that use PlanningException

Package	Description
org.apache.tajo.plan
org.apache.tajo.plan.algebra
org.apache.tajo.plan.joinorder
org.apache.tajo.plan.logical
org.apache.tajo.plan.nameresolver
org.apache.tajo.plan.rewrite
org.apache.tajo.plan.rewrite.rules
org.apache.tajo.plan.serder	This package provides (de)serialization API for logical plan and it related parts.
org.apache.tajo.plan.util
org.apache.tajo.plan.verifier
org.apache.tajo.plan.visitor

Uses of PlanningException in org.apache.tajo.plan

Methods in org.apache.tajo.plan that throw PlanningException

Modifier and Type	Method and Description
String	NamedExprsManager.addExpr(Expr expr) Adds an expression and returns a reference name.
String	NamedExprsManager.addExpr(Expr expr, String alias) Adds an expression with an alias name and returns a reference name.
String	NamedExprsManager.addNamedExpr(NamedExpr namedExpr) Adds an expression and returns a reference name.
String[]	NamedExprsManager.addNamedExprArray(Collection<NamedExpr> namedExprs) Adds a list of expressions and returns a list of reference names.
static void	ExprAnnotator.assertEval(boolean condition, String message)
static String	LogicalOptimizer.JoinOrderStringBuilder.buildJoinOrderString(LogicalPlan plan, LogicalPlan.QueryBlock block)
TajoDataTypes.DataType	TypeDeterminant.computeBinaryType(OpType type, TajoDataTypes.DataType lhsDataType, TajoDataTypes.DataType rhsDataType)
static double	LogicalOptimizer.JoinCostComputer.computeCost(LogicalPlan plan, LogicalPlan.QueryBlock block)
EvalNode	ExprAnnotator.createEvalNode(LogicalPlanner.PlanContext planContext, Expr expr, NameResolvingMode colRsvLevel)
LogicalPlan	LogicalPlanner.createPlan(OverridableConf context, Expr expr) This generates a logical plan.
LogicalPlan	LogicalPlanner.createPlan(OverridableConf queryContext, Expr expr, boolean debug)
static int[]	ExprAnnotator.dateToIntArray(String years, String months, String days)
TajoDataTypes.DataType	TypeDeterminant.determineDataType(LogicalPlanner.PlanContext ctx, Expr expr)
static Column[]	LogicalPlanPreprocessor.getColumns(LogicalPlanner.PlanContext ctx, QualifiedAsteriskExpr asteriskExpr) Get all columns of the relations correspondent to the asterisk expression.
LogicalNode	LogicalPlanner.handleCreateTableLike(LogicalPlanner.PlanContext context, CreateTable expr, CreateTableNode createTableNode)
void	NamedExprsManager.markAsEvaluated(String referenceName, EvalNode evalNode) It marks the expression identified by the reference name as evaluated.
List<Integer>	LogicalPlanner.normalize(LogicalPlanner.PlanContext context, Projection projection, ExprNormalizer.ExprNormalizedResult[] normalizedExprList, org.apache.tajo.plan.LogicalPlanner.Matcher matcher)
LogicalNode	LogicalOptimizer.optimize(LogicalPlan plan)
LogicalNode	LogicalOptimizer.optimize(OverridableConf context, LogicalPlan plan)
LogicalNode	LogicalPlanPreprocessor.postHook(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, Expr expr, LogicalNode result)
LogicalNode	LogicalPlanner.postHook(LogicalPlanner.PlanContext context, Stack<Expr> stack, Expr expr, LogicalNode current)
void	LogicalPlanPreprocessor.preHook(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, Expr expr)
void	LogicalPlanner.preHook(LogicalPlanner.PlanContext context, Stack<Expr> stack, Expr expr)
Column	LogicalPlan.resolveColumn(LogicalPlan.QueryBlock block, ColumnReferenceExpr columnRef)
static void	LogicalPlanner.throwCannotEvaluateException(Projectable projectable, String columnName)
static int[]	ExprAnnotator.timeToIntArray(String hours, String minutes, String seconds, String fractionOfSecond)
void	LogicalPlan.QueryBlock.updateCurrentNode(Expr expr)
static void	LogicalPlanner.verifyIfColumnCanBeEvaluated(Schema baseSchema, Projectable projectable, Column[] columns)
static void	LogicalPlanner.verifyIfEvalNodesCanBeEvaluated(Projectable projectable, EvalNode[] evalNodes)
static void	LogicalPlanner.verifyIfTargetsCanBeEvaluated(Schema baseSchema, Projectable projectable)
static void	LogicalPlanner.verifyProjectedFields(LogicalPlan.QueryBlock block, Projectable projectable) It checks if all targets of Projectable plan node can be evaluated from the child node.
LogicalNode	LogicalPlanPreprocessor.visitAlterTable(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, AlterTable expr)
LogicalNode	LogicalPlanPreprocessor.visitAlterTablespace(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, AlterTablespace expr)
EvalNode	ExprAnnotator.visitAnd(org.apache.tajo.plan.ExprAnnotator.Context ctx, Stack<Expr> stack, BinaryOperator expr)
EvalNode	ExprAnnotator.visitBetween(org.apache.tajo.plan.ExprAnnotator.Context ctx, Stack<Expr> stack, BetweenPredicate between)
TajoDataTypes.DataType	TypeDeterminant.visitBetween(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, BetweenPredicate expr)
TajoDataTypes.DataType	TypeDeterminant.visitBinaryOperator(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, BinaryOperator expr)
EvalNode	ExprAnnotator.visitCaseWhen(org.apache.tajo.plan.ExprAnnotator.Context ctx, Stack<Expr> stack, CaseWhenPredicate caseWhen)
TajoDataTypes.DataType	TypeDeterminant.visitCaseWhen(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, CaseWhenPredicate caseWhen)
EvalNode	ExprAnnotator.visitCastExpr(org.apache.tajo.plan.ExprAnnotator.Context ctx, Stack<Expr> stack, CastExpr expr)
EvalNode	ExprAnnotator.visitColumnReference(org.apache.tajo.plan.ExprAnnotator.Context ctx, Stack<Expr> stack, ColumnReferenceExpr expr)
TajoDataTypes.DataType	TypeDeterminant.visitColumnReference(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, ColumnReferenceExpr expr)
EvalNode	ExprAnnotator.visitCommonComparison(org.apache.tajo.plan.ExprAnnotator.Context ctx, Stack<Expr> stack, BinaryOperator expr)
EvalNode	ExprAnnotator.visitConcatenate(org.apache.tajo.plan.ExprAnnotator.Context ctx, Stack<Expr> stack, BinaryOperator expr)
EvalNode	ExprAnnotator.visitCountRowsFunction(org.apache.tajo.plan.ExprAnnotator.Context ctx, Stack<Expr> stack, CountRowsFunctionExpr expr)
TajoDataTypes.DataType	TypeDeterminant.visitCountRowsFunction(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, CountRowsFunctionExpr expr)
LogicalNode	LogicalPlanPreprocessor.visitCreateDatabase(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, CreateDatabase expr)
LogicalNode	LogicalPlanner.visitCreateDatabase(LogicalPlanner.PlanContext context, Stack<Expr> stack, CreateDatabase expr)
LogicalNode	LogicalPlanPreprocessor.visitCreateTable(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, CreateTable expr)
LogicalNode	LogicalPlanner.visitCreateTable(LogicalPlanner.PlanContext context, Stack<Expr> stack, CreateTable expr)
EvalNode	ExprAnnotator.visitDataType(org.apache.tajo.plan.ExprAnnotator.Context ctx, Stack<Expr> stack, DataTypeExpr expr)
TajoDataTypes.DataType	TypeDeterminant.visitDataType(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, DataTypeExpr expr)
EvalNode	ExprAnnotator.visitDateLiteral(org.apache.tajo.plan.ExprAnnotator.Context context, Stack<Expr> stack, DateLiteral expr)
TajoDataTypes.DataType	TypeDeterminant.visitDateLiteral(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, DateLiteral expr)
EvalNode	ExprAnnotator.visitDivide(org.apache.tajo.plan.ExprAnnotator.Context ctx, Stack<Expr> stack, BinaryOperator expr)
LogicalNode	LogicalPlanPreprocessor.visitDropDatabase(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, DropDatabase expr)
LogicalNode	LogicalPlanner.visitDropDatabase(LogicalPlanner.PlanContext context, Stack<Expr> stack, DropDatabase expr)
LogicalNode	LogicalPlanPreprocessor.visitDropTable(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, DropTable expr)
EvalNode	ExprAnnotator.visitEquals(org.apache.tajo.plan.ExprAnnotator.Context ctx, Stack<Expr> stack, BinaryOperator expr)
LogicalNode	LogicalPlanner.visitExcept(LogicalPlanner.PlanContext context, Stack<Expr> stack, SetOperation setOperation)
EvalNode	ExprAnnotator.visitExistsPredicate(org.apache.tajo.plan.ExprAnnotator.Context ctx, Stack<Expr> stack, ExistsPredicate expr)
LogicalNode	LogicalPlanner.visitExplain(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, Explain expr)
LogicalNode	LogicalPlanPreprocessor.visitFilter(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, Selection expr)
SelectionNode	LogicalPlanner.visitFilter(LogicalPlanner.PlanContext context, Stack<Expr> stack, Selection selection)
EvalNode	ExprAnnotator.visitFunction(org.apache.tajo.plan.ExprAnnotator.Context ctx, Stack<Expr> stack, FunctionExpr expr)
TajoDataTypes.DataType	TypeDeterminant.visitFunction(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, FunctionExpr expr)
EvalNode	ExprAnnotator.visitGeneralSetFunction(org.apache.tajo.plan.ExprAnnotator.Context ctx, Stack<Expr> stack, GeneralSetFunctionExpr setFunction)
TajoDataTypes.DataType	TypeDeterminant.visitGeneralSetFunction(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, GeneralSetFunctionExpr setFunction)
EvalNode	ExprAnnotator.visitGreaterThan(org.apache.tajo.plan.ExprAnnotator.Context ctx, Stack<Expr> stack, BinaryOperator expr)
EvalNode	ExprAnnotator.visitGreaterThanOrEquals(org.apache.tajo.plan.ExprAnnotator.Context ctx, Stack<Expr> stack, BinaryOperator expr)
LogicalNode	LogicalPlanPreprocessor.visitGroupBy(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, Aggregation expr)
LogicalNode	LogicalPlanner.visitGroupBy(LogicalPlanner.PlanContext context, Stack<Expr> stack, Aggregation aggregation)
LogicalNode	LogicalPlanPreprocessor.visitHaving(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, Having expr)
LogicalNode	LogicalPlanner.visitHaving(LogicalPlanner.PlanContext context, Stack<Expr> stack, Having expr)
EvalNode	ExprAnnotator.visitInPredicate(org.apache.tajo.plan.ExprAnnotator.Context ctx, Stack<Expr> stack, InPredicate expr)
LogicalNode	LogicalPlanPreprocessor.visitInsert(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, Insert expr)
LogicalNode	LogicalPlanner.visitInsert(LogicalPlanner.PlanContext context, Stack<Expr> stack, Insert expr)
LogicalNode	LogicalPlanner.visitIntersect(LogicalPlanner.PlanContext context, Stack<Expr> stack, SetOperation setOperation)
EvalNode	ExprAnnotator.visitIntervalLiteral(org.apache.tajo.plan.ExprAnnotator.Context ctx, Stack<Expr> stack, IntervalLiteral expr)
TajoDataTypes.DataType	TypeDeterminant.visitIntervalLiteral(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, IntervalLiteral expr)
EvalNode	ExprAnnotator.visitIsNullPredicate(org.apache.tajo.plan.ExprAnnotator.Context ctx, Stack<Expr> stack, IsNullPredicate expr)
LogicalNode	LogicalOptimizer.JoinCostComputer.visitJoin(org.apache.tajo.plan.LogicalOptimizer.CostContext joinGraphContext, LogicalPlan plan, LogicalPlan.QueryBlock block, JoinNode joinNode, Stack<LogicalNode> stack)
LogicalNode	LogicalPlanPreprocessor.visitJoin(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, Join expr)
LogicalNode	LogicalPlanner.visitJoin(LogicalPlanner.PlanContext context, Stack<Expr> stack, Join join)
LogicalNode	LogicalOptimizer.JoinOrderStringBuilder.visitJoin(StringBuilder sb, LogicalPlan plan, LogicalPlan.QueryBlock block, JoinNode joinNode, Stack<LogicalNode> stack)
EvalNode	ExprAnnotator.visitLessThan(org.apache.tajo.plan.ExprAnnotator.Context ctx, Stack<Expr> stack, BinaryOperator expr)
EvalNode	ExprAnnotator.visitLessThanOrEquals(org.apache.tajo.plan.ExprAnnotator.Context ctx, Stack<Expr> stack, BinaryOperator expr)
EvalNode	ExprAnnotator.visitLikePredicate(org.apache.tajo.plan.ExprAnnotator.Context ctx, Stack<Expr> stack, PatternMatchPredicate expr)
LogicalNode	LogicalPlanPreprocessor.visitLimit(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, Limit expr)
LimitNode	LogicalPlanner.visitLimit(LogicalPlanner.PlanContext context, Stack<Expr> stack, Limit limit)
EvalNode	ExprAnnotator.visitLiteral(org.apache.tajo.plan.ExprAnnotator.Context ctx, Stack<Expr> stack, LiteralValue expr)
TajoDataTypes.DataType	TypeDeterminant.visitLiteral(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, LiteralValue expr)
EvalNode	ExprAnnotator.visitMinus(org.apache.tajo.plan.ExprAnnotator.Context ctx, Stack<Expr> stack, BinaryOperator expr)
EvalNode	ExprAnnotator.visitModular(org.apache.tajo.plan.ExprAnnotator.Context ctx, Stack<Expr> stack, BinaryOperator expr)
EvalNode	ExprAnnotator.visitMultiply(org.apache.tajo.plan.ExprAnnotator.Context ctx, Stack<Expr> stack, BinaryOperator expr)
EvalNode	ExprAnnotator.visitNot(org.apache.tajo.plan.ExprAnnotator.Context ctx, Stack<Expr> stack, NotExpr expr)
EvalNode	ExprAnnotator.visitNotEquals(org.apache.tajo.plan.ExprAnnotator.Context ctx, Stack<Expr> stack, BinaryOperator expr)
EvalNode	ExprAnnotator.visitNullLiteral(org.apache.tajo.plan.ExprAnnotator.Context ctx, Stack<Expr> stack, NullLiteral expr)
TajoDataTypes.DataType	TypeDeterminant.visitNullLiteral(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, NullLiteral expr)
EvalNode	ExprAnnotator.visitOr(org.apache.tajo.plan.ExprAnnotator.Context ctx, Stack<Expr> stack, BinaryOperator expr)
EvalNode	ExprAnnotator.visitPlus(org.apache.tajo.plan.ExprAnnotator.Context ctx, Stack<Expr> stack, BinaryOperator expr)
LogicalNode	LogicalPlanPreprocessor.visitProjection(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, Projection expr)
LogicalNode	LogicalPlanner.visitProjection(LogicalPlanner.PlanContext context, Stack<Expr> stack, Projection projection)
EvalNode	ExprAnnotator.visitRegexpPredicate(org.apache.tajo.plan.ExprAnnotator.Context ctx, Stack<Expr> stack, PatternMatchPredicate expr)
LogicalNode	LogicalPlanPreprocessor.visitRelation(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, Relation expr)
ScanNode	LogicalPlanner.visitRelation(LogicalPlanner.PlanContext context, Stack<Expr> stack, Relation expr)
LogicalNode	LogicalPlanner.visitRelationList(LogicalPlanner.PlanContext context, Stack<Expr> stack, RelationList relations)
LogicalNode	LogicalPlanPreprocessor.visitSetSession(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, SetSession expr)
LogicalNode	LogicalPlanner.visitSetSession(LogicalPlanner.PlanContext context, Stack<Expr> stack, SetSession expr)
EvalNode	ExprAnnotator.visitSign(org.apache.tajo.plan.ExprAnnotator.Context ctx, Stack<Expr> stack, SignedExpr expr)
EvalNode	ExprAnnotator.visitSimilarToPredicate(org.apache.tajo.plan.ExprAnnotator.Context ctx, Stack<Expr> stack, PatternMatchPredicate expr)
LogicalNode	LogicalPlanPreprocessor.visitSort(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, Sort expr)
LogicalNode	LogicalPlanner.visitSort(LogicalPlanner.PlanContext context, Stack<Expr> stack, Sort sort)
LogicalNode	LogicalPlanPreprocessor.visitTableSubQuery(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, TablePrimarySubQuery expr)
TableSubQueryNode	LogicalPlanner.visitTableSubQuery(LogicalPlanner.PlanContext context, Stack<Expr> stack, TablePrimarySubQuery expr)
EvalNode	ExprAnnotator.visitTargetExpr(org.apache.tajo.plan.ExprAnnotator.Context ctx, Stack<Expr> stack, NamedExpr expr)
EvalNode	ExprAnnotator.visitTimeLiteral(org.apache.tajo.plan.ExprAnnotator.Context ctx, Stack<Expr> stack, TimeLiteral expr)
TajoDataTypes.DataType	TypeDeterminant.visitTimeLiteral(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, TimeLiteral expr)
EvalNode	ExprAnnotator.visitTimestampLiteral(org.apache.tajo.plan.ExprAnnotator.Context ctx, Stack<Expr> stack, TimestampLiteral expr)
TajoDataTypes.DataType	TypeDeterminant.visitTimestampLiteral(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, TimestampLiteral expr)
LogicalNode	LogicalPlanPreprocessor.visitTruncateTable(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, TruncateTable expr)
LogicalNode	LogicalPlanner.visitTruncateTable(LogicalPlanner.PlanContext context, Stack<Expr> stack, TruncateTable truncateTable)
TajoDataTypes.DataType	TypeDeterminant.visitUnaryOperator(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, UnaryOperator expr)
LogicalNode	LogicalPlanPreprocessor.visitUnion(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, SetOperation expr)
LogicalNode	LogicalPlanner.visitUnion(LogicalPlanner.PlanContext context, Stack<Expr> stack, SetOperation setOperation)
EvalNode	ExprAnnotator.visitValueListExpr(org.apache.tajo.plan.ExprAnnotator.Context ctx, Stack<Expr> stack, ValueListExpr expr)
EvalNode	ExprAnnotator.visitWindowFunction(org.apache.tajo.plan.ExprAnnotator.Context ctx, Stack<Expr> stack, WindowFunctionExpr windowFunc)
TajoDataTypes.DataType	TypeDeterminant.visitWindowFunction(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, WindowFunctionExpr windowFunc)

Uses of PlanningException in org.apache.tajo.plan.algebra

Methods in org.apache.tajo.plan.algebra that throw PlanningException

Modifier and Type	Method and Description
RESULT	BaseAlgebraVisitor.postHook(CONTEXT ctx, Stack<Expr> stack, Expr expr, RESULT current) The posthook is called before each expression is visited.
void	BaseAlgebraVisitor.preHook(CONTEXT ctx, Stack<Expr> stack, Expr expr) The prehook is called before each expression is visited.
RESULT	BaseAlgebraVisitor.visit(CONTEXT ctx, Stack<Expr> stack, Expr expr) visit visits each relational operator expression recursively.
RESULT	BaseAlgebraVisitor.visitAlterTable(CONTEXT ctx, Stack<Expr> stack, AlterTable expr)
RESULT	AlgebraVisitor.visitAlterTable(CONTEXT ctx, Stack<Expr> stack, AlterTable expr)
RESULT	BaseAlgebraVisitor.visitAlterTablespace(CONTEXT ctx, Stack<Expr> stack, AlterTablespace expr)
RESULT	AlgebraVisitor.visitAlterTablespace(CONTEXT ctx, Stack<Expr> stack, AlterTablespace expr)
RESULT	BaseAlgebraVisitor.visitAnd(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr)
RESULT	AlgebraVisitor.visitAnd(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr)
RESULT	BaseAlgebraVisitor.visitBetween(CONTEXT ctx, Stack<Expr> stack, BetweenPredicate expr)
RESULT	AlgebraVisitor.visitBetween(CONTEXT ctx, Stack<Expr> stack, BetweenPredicate expr)
RESULT	BaseAlgebraVisitor.visitCaseWhen(CONTEXT ctx, Stack<Expr> stack, CaseWhenPredicate expr)
RESULT	AlgebraVisitor.visitCaseWhen(CONTEXT ctx, Stack<Expr> stack, CaseWhenPredicate expr)
RESULT	BaseAlgebraVisitor.visitCastExpr(CONTEXT ctx, Stack<Expr> stack, CastExpr expr)
RESULT	AlgebraVisitor.visitCastExpr(CONTEXT ctx, Stack<Expr> stack, CastExpr expr)
RESULT	BaseAlgebraVisitor.visitColumnReference(CONTEXT ctx, Stack<Expr> stack, ColumnReferenceExpr expr)
RESULT	AlgebraVisitor.visitColumnReference(CONTEXT ctx, Stack<Expr> stack, ColumnReferenceExpr expr)
RESULT	BaseAlgebraVisitor.visitConcatenate(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr)
RESULT	AlgebraVisitor.visitConcatenate(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr)
RESULT	BaseAlgebraVisitor.visitCountRowsFunction(CONTEXT ctx, Stack<Expr> stack, CountRowsFunctionExpr expr)
RESULT	AlgebraVisitor.visitCountRowsFunction(CONTEXT ctx, Stack<Expr> stack, CountRowsFunctionExpr expr)
RESULT	BaseAlgebraVisitor.visitCreateDatabase(CONTEXT ctx, Stack<Expr> stack, CreateDatabase expr)
RESULT	AlgebraVisitor.visitCreateDatabase(CONTEXT ctx, Stack<Expr> stack, CreateDatabase expr)
RESULT	BaseAlgebraVisitor.visitCreateTable(CONTEXT ctx, Stack<Expr> stack, CreateTable expr)
RESULT	AlgebraVisitor.visitCreateTable(CONTEXT ctx, Stack<Expr> stack, CreateTable expr)
RESULT	BaseAlgebraVisitor.visitDataType(CONTEXT ctx, Stack<Expr> stack, DataTypeExpr expr)
RESULT	AlgebraVisitor.visitDataType(CONTEXT ctx, Stack<Expr> stack, DataTypeExpr expr)
RESULT	BaseAlgebraVisitor.visitDateLiteral(CONTEXT ctx, Stack<Expr> stack, DateLiteral expr)
RESULT	AlgebraVisitor.visitDateLiteral(CONTEXT ctx, Stack<Expr> stack, DateLiteral expr)
RESULT	BaseAlgebraVisitor.visitDivide(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr)
RESULT	AlgebraVisitor.visitDivide(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr)
RESULT	BaseAlgebraVisitor.visitDropDatabase(CONTEXT ctx, Stack<Expr> stack, DropDatabase expr)
RESULT	AlgebraVisitor.visitDropDatabase(CONTEXT ctx, Stack<Expr> stack, DropDatabase expr)
RESULT	BaseAlgebraVisitor.visitDropTable(CONTEXT ctx, Stack<Expr> stack, DropTable expr)
RESULT	AlgebraVisitor.visitDropTable(CONTEXT ctx, Stack<Expr> stack, DropTable expr)
RESULT	BaseAlgebraVisitor.visitEquals(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr)
RESULT	AlgebraVisitor.visitEquals(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr)
RESULT	BaseAlgebraVisitor.visitExcept(CONTEXT ctx, Stack<Expr> stack, SetOperation expr)
RESULT	AlgebraVisitor.visitExcept(CONTEXT ctx, Stack<Expr> stack, SetOperation expr)
RESULT	BaseAlgebraVisitor.visitExistsPredicate(CONTEXT ctx, Stack<Expr> stack, ExistsPredicate expr)
RESULT	AlgebraVisitor.visitExistsPredicate(CONTEXT ctx, Stack<Expr> stack, ExistsPredicate expr)
RESULT	BaseAlgebraVisitor.visitExplain(CONTEXT ctx, Stack<Expr> stack, Explain expr)
RESULT	AlgebraVisitor.visitExplain(CONTEXT ctx, Stack<Expr> stack, Explain expr)
RESULT	BaseAlgebraVisitor.visitFilter(CONTEXT ctx, Stack<Expr> stack, Selection expr)
RESULT	AlgebraVisitor.visitFilter(CONTEXT ctx, Stack<Expr> stack, Selection expr)
RESULT	BaseAlgebraVisitor.visitFunction(CONTEXT ctx, Stack<Expr> stack, FunctionExpr expr)
RESULT	AlgebraVisitor.visitFunction(CONTEXT ctx, Stack<Expr> stack, FunctionExpr expr)
RESULT	BaseAlgebraVisitor.visitGeneralSetFunction(CONTEXT ctx, Stack<Expr> stack, GeneralSetFunctionExpr expr)
RESULT	AlgebraVisitor.visitGeneralSetFunction(CONTEXT ctx, Stack<Expr> stack, GeneralSetFunctionExpr expr)
RESULT	BaseAlgebraVisitor.visitGreaterThan(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr)
RESULT	AlgebraVisitor.visitGreaterThan(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr)
RESULT	BaseAlgebraVisitor.visitGreaterThanOrEquals(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr)
RESULT	AlgebraVisitor.visitGreaterThanOrEquals(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr)
RESULT	BaseAlgebraVisitor.visitGroupBy(CONTEXT ctx, Stack<Expr> stack, Aggregation expr)
RESULT	AlgebraVisitor.visitGroupBy(CONTEXT ctx, Stack<Expr> stack, Aggregation expr)
RESULT	BaseAlgebraVisitor.visitHaving(CONTEXT ctx, Stack<Expr> stack, Having expr)
RESULT	AlgebraVisitor.visitHaving(CONTEXT ctx, Stack<Expr> stack, Having expr)
RESULT	BaseAlgebraVisitor.visitInPredicate(CONTEXT ctx, Stack<Expr> stack, InPredicate expr)
RESULT	AlgebraVisitor.visitInPredicate(CONTEXT ctx, Stack<Expr> stack, InPredicate expr)
RESULT	BaseAlgebraVisitor.visitInsert(CONTEXT ctx, Stack<Expr> stack, Insert expr)
RESULT	AlgebraVisitor.visitInsert(CONTEXT ctx, Stack<Expr> stack, Insert expr)
RESULT	BaseAlgebraVisitor.visitIntersect(CONTEXT ctx, Stack<Expr> stack, SetOperation expr)
RESULT	AlgebraVisitor.visitIntersect(CONTEXT ctx, Stack<Expr> stack, SetOperation expr)
RESULT	BaseAlgebraVisitor.visitIntervalLiteral(CONTEXT ctx, Stack<Expr> stack, IntervalLiteral expr)
RESULT	AlgebraVisitor.visitIntervalLiteral(CONTEXT ctx, Stack<Expr> stack, IntervalLiteral expr)
RESULT	BaseAlgebraVisitor.visitIsNullPredicate(CONTEXT ctx, Stack<Expr> stack, IsNullPredicate expr)
RESULT	AlgebraVisitor.visitIsNullPredicate(CONTEXT ctx, Stack<Expr> stack, IsNullPredicate expr)
RESULT	BaseAlgebraVisitor.visitJoin(CONTEXT ctx, Stack<Expr> stack, Join expr)
RESULT	AlgebraVisitor.visitJoin(CONTEXT ctx, Stack<Expr> stack, Join expr)
RESULT	BaseAlgebraVisitor.visitLessThan(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr)
RESULT	AlgebraVisitor.visitLessThan(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr)
RESULT	BaseAlgebraVisitor.visitLessThanOrEquals(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr)
RESULT	AlgebraVisitor.visitLessThanOrEquals(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr)
RESULT	BaseAlgebraVisitor.visitLikePredicate(CONTEXT ctx, Stack<Expr> stack, PatternMatchPredicate expr)
RESULT	AlgebraVisitor.visitLikePredicate(CONTEXT ctx, Stack<Expr> stack, PatternMatchPredicate expr)
RESULT	BaseAlgebraVisitor.visitLimit(CONTEXT ctx, Stack<Expr> stack, Limit expr)
RESULT	AlgebraVisitor.visitLimit(CONTEXT ctx, Stack<Expr> stack, Limit expr)
RESULT	BaseAlgebraVisitor.visitLiteral(CONTEXT ctx, Stack<Expr> stack, LiteralValue expr)
RESULT	AlgebraVisitor.visitLiteral(CONTEXT ctx, Stack<Expr> stack, LiteralValue expr)
RESULT	BaseAlgebraVisitor.visitMinus(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr)
RESULT	AlgebraVisitor.visitMinus(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr)
RESULT	BaseAlgebraVisitor.visitModular(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr)
RESULT	AlgebraVisitor.visitModular(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr)
RESULT	BaseAlgebraVisitor.visitMultiply(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr)
RESULT	AlgebraVisitor.visitMultiply(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr)
RESULT	BaseAlgebraVisitor.visitNot(CONTEXT ctx, Stack<Expr> stack, NotExpr expr)
RESULT	AlgebraVisitor.visitNot(CONTEXT ctx, Stack<Expr> stack, NotExpr expr)
RESULT	BaseAlgebraVisitor.visitNotEquals(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr)
RESULT	AlgebraVisitor.visitNotEquals(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr)
RESULT	BaseAlgebraVisitor.visitNullLiteral(CONTEXT ctx, Stack<Expr> stack, NullLiteral expr)
RESULT	AlgebraVisitor.visitNullLiteral(CONTEXT ctx, Stack<Expr> stack, NullLiteral expr)
RESULT	BaseAlgebraVisitor.visitOr(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr)
RESULT	AlgebraVisitor.visitOr(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr)
RESULT	BaseAlgebraVisitor.visitPlus(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr)
RESULT	AlgebraVisitor.visitPlus(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr)
RESULT	BaseAlgebraVisitor.visitProjection(CONTEXT ctx, Stack<Expr> stack, Projection expr)
RESULT	AlgebraVisitor.visitProjection(CONTEXT ctx, Stack<Expr> stack, Projection expr)
RESULT	BaseAlgebraVisitor.visitQualifiedAsterisk(CONTEXT ctx, Stack<Expr> stack, QualifiedAsteriskExpr expr)
RESULT	AlgebraVisitor.visitQualifiedAsterisk(CONTEXT ctx, Stack<Expr> stack, QualifiedAsteriskExpr expr)
RESULT	BaseAlgebraVisitor.visitRegexpPredicate(CONTEXT ctx, Stack<Expr> stack, PatternMatchPredicate expr)
RESULT	AlgebraVisitor.visitRegexpPredicate(CONTEXT ctx, Stack<Expr> stack, PatternMatchPredicate expr)
RESULT	BaseAlgebraVisitor.visitRelation(CONTEXT ctx, Stack<Expr> stack, Relation expr)
RESULT	AlgebraVisitor.visitRelation(CONTEXT ctx, Stack<Expr> stack, Relation expr)
RESULT	BaseAlgebraVisitor.visitRelationList(CONTEXT ctx, Stack<Expr> stack, RelationList expr)
RESULT	AlgebraVisitor.visitRelationList(CONTEXT ctx, Stack<Expr> stack, RelationList expr)
RESULT	BaseAlgebraVisitor.visitScalarSubQuery(CONTEXT ctx, Stack<Expr> stack, ScalarSubQuery expr)
RESULT	AlgebraVisitor.visitScalarSubQuery(CONTEXT ctx, Stack<Expr> stack, ScalarSubQuery expr)
RESULT	BaseAlgebraVisitor.visitSetSession(CONTEXT ctx, Stack<Expr> stack, SetSession expr)
RESULT	AlgebraVisitor.visitSetSession(CONTEXT ctx, Stack<Expr> stack, SetSession expr)
RESULT	BaseAlgebraVisitor.visitSign(CONTEXT ctx, Stack<Expr> stack, SignedExpr expr)
RESULT	AlgebraVisitor.visitSign(CONTEXT ctx, Stack<Expr> stack, SignedExpr expr)
RESULT	BaseAlgebraVisitor.visitSimilarToPredicate(CONTEXT ctx, Stack<Expr> stack, PatternMatchPredicate expr)
RESULT	AlgebraVisitor.visitSimilarToPredicate(CONTEXT ctx, Stack<Expr> stack, PatternMatchPredicate expr)
RESULT	BaseAlgebraVisitor.visitSimpleTableSubQuery(CONTEXT ctx, Stack<Expr> stack, SimpleTableSubQuery expr)
RESULT	AlgebraVisitor.visitSimpleTableSubQuery(CONTEXT ctx, Stack<Expr> stack, SimpleTableSubQuery expr)
RESULT	BaseAlgebraVisitor.visitSort(CONTEXT ctx, Stack<Expr> stack, Sort expr)
RESULT	AlgebraVisitor.visitSort(CONTEXT ctx, Stack<Expr> stack, Sort expr)
RESULT	BaseAlgebraVisitor.visitTableSubQuery(CONTEXT ctx, Stack<Expr> stack, TablePrimarySubQuery expr)
RESULT	AlgebraVisitor.visitTableSubQuery(CONTEXT ctx, Stack<Expr> stack, TablePrimarySubQuery expr)
RESULT	BaseAlgebraVisitor.visitTargetExpr(CONTEXT ctx, Stack<Expr> stack, NamedExpr expr)
RESULT	AlgebraVisitor.visitTargetExpr(CONTEXT ctx, Stack<Expr> stack, NamedExpr expr)
RESULT	BaseAlgebraVisitor.visitTimeLiteral(CONTEXT ctx, Stack<Expr> stack, TimeLiteral expr)
RESULT	AlgebraVisitor.visitTimeLiteral(CONTEXT ctx, Stack<Expr> stack, TimeLiteral expr)
RESULT	BaseAlgebraVisitor.visitTimestampLiteral(CONTEXT ctx, Stack<Expr> stack, TimestampLiteral expr)
RESULT	AlgebraVisitor.visitTimestampLiteral(CONTEXT ctx, Stack<Expr> stack, TimestampLiteral expr)
RESULT	BaseAlgebraVisitor.visitTruncateTable(CONTEXT ctx, Stack<Expr> stack, TruncateTable expr)
RESULT	AlgebraVisitor.visitTruncateTable(CONTEXT ctx, Stack<Expr> stack, TruncateTable expr)
RESULT	BaseAlgebraVisitor.visitUnion(CONTEXT ctx, Stack<Expr> stack, SetOperation expr)
RESULT	AlgebraVisitor.visitUnion(CONTEXT ctx, Stack<Expr> stack, SetOperation expr)
RESULT	BaseAlgebraVisitor.visitValueListExpr(CONTEXT ctx, Stack<Expr> stack, ValueListExpr expr)
RESULT	AlgebraVisitor.visitValueListExpr(CONTEXT ctx, Stack<Expr> stack, ValueListExpr expr)
RESULT	BaseAlgebraVisitor.visitWindowFunction(CONTEXT ctx, Stack<Expr> stack, WindowFunctionExpr expr)
RESULT	AlgebraVisitor.visitWindowFunction(CONTEXT ctx, Stack<Expr> stack, WindowFunctionExpr expr)

Uses of PlanningException in org.apache.tajo.plan.joinorder

Methods in org.apache.tajo.plan.joinorder that throw PlanningException

Modifier and Type	Method and Description
Collection<EvalNode>	JoinGraph.addJoin(LogicalPlan plan, LogicalPlan.QueryBlock block, JoinNode joinNode)
FoundJoinOrder	JoinOrderAlgorithm.findBestOrder(LogicalPlan plan, LogicalPlan.QueryBlock block, JoinGraph joinGraph, Set<String> relationsWithoutQual)
FoundJoinOrder	GreedyHeuristicJoinOrderAlgorithm.findBestOrder(LogicalPlan plan, LogicalPlan.QueryBlock block, JoinGraph joinGraph, Set<String> relationsWithoutQual)

Uses of PlanningException in org.apache.tajo.plan.logical

Subclasses of PlanningException in org.apache.tajo.plan.logical

Modifier and Type	Class and Description
class	NoSuchColumnException

Uses of PlanningException in org.apache.tajo.plan.nameresolver

Methods in org.apache.tajo.plan.nameresolver that throw PlanningException

Modifier and Type	Method and Description
Column	ResolverBySubExprsAndRels.resolve(LogicalPlan plan, LogicalPlan.QueryBlock block, ColumnReferenceExpr columnRef)
Column	ResolverByRelsAndSubExprs.resolve(LogicalPlan plan, LogicalPlan.QueryBlock block, ColumnReferenceExpr columnRef)
Column	ResolverByRels.resolve(LogicalPlan plan, LogicalPlan.QueryBlock block, ColumnReferenceExpr columnRef)
Column	ResolverByLegacy.resolve(LogicalPlan plan, LogicalPlan.QueryBlock block, ColumnReferenceExpr columnRef)
static Column	NameResolver.resolve(LogicalPlan plan, LogicalPlan.QueryBlock block, ColumnReferenceExpr column, NameResolvingMode mode)
static String	NameResolver.resolveDatabase(LogicalPlan.QueryBlock block, String tableName) Try to find the database name

Uses of PlanningException in org.apache.tajo.plan.rewrite

Methods in org.apache.tajo.plan.rewrite that throw PlanningException

Modifier and Type	Method and Description
LogicalPlan	LogicalPlanRewriteRule.rewrite(OverridableConf queryContext, LogicalPlan plan) Updates a logical plan and returns an updated logical plan rewritten by this rule.
LogicalPlan	LogicalPlanRewriteEngine.rewrite(OverridableConf queryContext, LogicalPlan plan) Rewrite a logical plan with all query rewrite rules added to this engine.
LogicalPlan	BaseLogicalPlanRewriteEngine.rewrite(OverridableConf queryContext, LogicalPlan plan) Rewrite a logical plan with all query rewrite rules added to this engine.

Uses of PlanningException in org.apache.tajo.plan.rewrite.rules

Methods in org.apache.tajo.plan.rewrite.rules that throw PlanningException

Modifier and Type	Method and Description
String	ProjectionPushDownRule.TargetListManager.add(EvalNode evalNode) Adds an expression without any name.
String	ProjectionPushDownRule.TargetListManager.add(Target target)
LogicalPlan	ProjectionPushDownRule.rewrite(OverridableConf queryContext, LogicalPlan plan)
LogicalPlan	PartitionedTableRewriter.rewrite(OverridableConf queryContext, LogicalPlan plan)
LogicalPlan	LogicalPlanEqualityTester.rewrite(OverridableConf queryContext, LogicalPlan plan)
LogicalPlan	FilterPushDownRule.rewrite(OverridableConf queryContext, LogicalPlan plan)
LogicalNode	FilterPushDownRule.visitFilter(org.apache.tajo.plan.rewrite.rules.FilterPushDownRule.FilterPushDownContext context, LogicalPlan plan, LogicalPlan.QueryBlock block, SelectionNode selNode, Stack<LogicalNode> stack)
LogicalNode	ProjectionPushDownRule.visitFilter(org.apache.tajo.plan.rewrite.rules.ProjectionPushDownRule.Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, SelectionNode node, Stack<LogicalNode> stack)
LogicalNode	FilterPushDownRule.visitGroupBy(org.apache.tajo.plan.rewrite.rules.FilterPushDownRule.FilterPushDownContext context, LogicalPlan plan, LogicalPlan.QueryBlock block, GroupbyNode groupbyNode, Stack<LogicalNode> stack)
LogicalNode	ProjectionPushDownRule.visitGroupBy(org.apache.tajo.plan.rewrite.rules.ProjectionPushDownRule.Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, GroupbyNode node, Stack<LogicalNode> stack)
LogicalNode	ProjectionPushDownRule.visitHaving(org.apache.tajo.plan.rewrite.rules.ProjectionPushDownRule.Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, HavingNode node, Stack<LogicalNode> stack)
LogicalNode	ProjectionPushDownRule.visitInsert(org.apache.tajo.plan.rewrite.rules.ProjectionPushDownRule.Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, InsertNode node, Stack<LogicalNode> stack)
LogicalNode	FilterPushDownRule.visitJoin(org.apache.tajo.plan.rewrite.rules.FilterPushDownRule.FilterPushDownContext context, LogicalPlan plan, LogicalPlan.QueryBlock block, JoinNode joinNode, Stack<LogicalNode> stack)
LogicalNode	ProjectionPushDownRule.visitJoin(org.apache.tajo.plan.rewrite.rules.ProjectionPushDownRule.Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, JoinNode node, Stack<LogicalNode> stack)
LogicalNode	ProjectionPushDownRule.visitLimit(org.apache.tajo.plan.rewrite.rules.ProjectionPushDownRule.Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, LimitNode node, Stack<LogicalNode> stack)
LogicalNode	ProjectionPushDownRule.visitPartitionedTableScan(org.apache.tajo.plan.rewrite.rules.ProjectionPushDownRule.Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, PartitionedTableScanNode node, Stack<LogicalNode> stack)
LogicalNode	FilterPushDownRule.visitProjection(org.apache.tajo.plan.rewrite.rules.FilterPushDownRule.FilterPushDownContext context, LogicalPlan plan, LogicalPlan.QueryBlock block, ProjectionNode projectionNode, Stack<LogicalNode> stack)
LogicalNode	ProjectionPushDownRule.visitProjection(org.apache.tajo.plan.rewrite.rules.ProjectionPushDownRule.Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, ProjectionNode node, Stack<LogicalNode> stack)
LogicalNode	ProjectionPushDownRule.visitRoot(org.apache.tajo.plan.rewrite.rules.ProjectionPushDownRule.Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, LogicalRootNode node, Stack<LogicalNode> stack)
LogicalNode	FilterPushDownRule.visitScan(org.apache.tajo.plan.rewrite.rules.FilterPushDownRule.FilterPushDownContext context, LogicalPlan plan, LogicalPlan.QueryBlock block, ScanNode scanNode, Stack<LogicalNode> stack)
LogicalNode	ProjectionPushDownRule.visitScan(org.apache.tajo.plan.rewrite.rules.ProjectionPushDownRule.Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, ScanNode node, Stack<LogicalNode> stack)
LogicalNode	ProjectionPushDownRule.visitSort(org.apache.tajo.plan.rewrite.rules.ProjectionPushDownRule.Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, SortNode node, Stack<LogicalNode> stack)
LogicalNode	FilterPushDownRule.visitTableSubQuery(org.apache.tajo.plan.rewrite.rules.FilterPushDownRule.FilterPushDownContext context, LogicalPlan plan, LogicalPlan.QueryBlock block, TableSubQueryNode node, Stack<LogicalNode> stack)
LogicalNode	ProjectionPushDownRule.visitTableSubQuery(org.apache.tajo.plan.rewrite.rules.ProjectionPushDownRule.Context upperContext, LogicalPlan plan, LogicalPlan.QueryBlock block, TableSubQueryNode node, Stack<LogicalNode> stack)
LogicalNode	FilterPushDownRule.visitUnion(org.apache.tajo.plan.rewrite.rules.FilterPushDownRule.FilterPushDownContext context, LogicalPlan plan, LogicalPlan.QueryBlock block, UnionNode unionNode, Stack<LogicalNode> stack)
LogicalNode	ProjectionPushDownRule.visitUnion(org.apache.tajo.plan.rewrite.rules.ProjectionPushDownRule.Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, UnionNode node, Stack<LogicalNode> stack)
LogicalNode	FilterPushDownRule.visitWindowAgg(org.apache.tajo.plan.rewrite.rules.FilterPushDownRule.FilterPushDownContext context, LogicalPlan plan, LogicalPlan.QueryBlock block, WindowAggNode winAggNode, Stack<LogicalNode> stack)
LogicalNode	ProjectionPushDownRule.visitWindowAgg(org.apache.tajo.plan.rewrite.rules.ProjectionPushDownRule.Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, WindowAggNode node, Stack<LogicalNode> stack)

Uses of PlanningException in org.apache.tajo.plan.serder

Methods in org.apache.tajo.plan.serder that throw PlanningException

Modifier and Type	Method and Description
LogicalNode	LogicalNodeSerializer.visitAlterTablespace(LogicalNodeSerializer.SerializeContext context, LogicalPlan plan, LogicalPlan.QueryBlock block, AlterTablespaceNode node, Stack<LogicalNode> stack)
LogicalNode	LogicalNodeSerializer.visitCreateDatabase(LogicalNodeSerializer.SerializeContext context, LogicalPlan plan, LogicalPlan.QueryBlock block, CreateDatabaseNode node, Stack<LogicalNode> stack)
LogicalNode	LogicalNodeSerializer.visitCreateTable(LogicalNodeSerializer.SerializeContext context, LogicalPlan plan, LogicalPlan.QueryBlock block, CreateTableNode node, Stack<LogicalNode> stack)
LogicalNode	LogicalNodeSerializer.visitDistinctGroupby(LogicalNodeSerializer.SerializeContext context, LogicalPlan plan, LogicalPlan.QueryBlock block, DistinctGroupbyNode node, Stack<LogicalNode> stack)
LogicalNode	LogicalNodeSerializer.visitDropDatabase(LogicalNodeSerializer.SerializeContext context, LogicalPlan plan, LogicalPlan.QueryBlock block, DropDatabaseNode node, Stack<LogicalNode> stack)
LogicalNode	LogicalNodeSerializer.visitEvalExpr(LogicalNodeSerializer.SerializeContext context, LogicalPlan plan, LogicalPlan.QueryBlock block, EvalExprNode exprEval, Stack<LogicalNode> stack)
LogicalNode	LogicalNodeSerializer.visitFilter(LogicalNodeSerializer.SerializeContext context, LogicalPlan plan, LogicalPlan.QueryBlock block, SelectionNode filter, Stack<LogicalNode> stack)
LogicalNode	LogicalNodeSerializer.visitGroupBy(LogicalNodeSerializer.SerializeContext context, LogicalPlan plan, LogicalPlan.QueryBlock block, GroupbyNode node, Stack<LogicalNode> stack)
LogicalNode	LogicalNodeSerializer.visitHaving(LogicalNodeSerializer.SerializeContext context, LogicalPlan plan, LogicalPlan.QueryBlock block, HavingNode having, Stack<LogicalNode> stack)
LogicalNode	LogicalNodeSerializer.visitInsert(LogicalNodeSerializer.SerializeContext context, LogicalPlan plan, LogicalPlan.QueryBlock block, InsertNode node, Stack<LogicalNode> stack)
LogicalNode	LogicalNodeSerializer.visitJoin(LogicalNodeSerializer.SerializeContext context, LogicalPlan plan, LogicalPlan.QueryBlock block, JoinNode join, Stack<LogicalNode> stack)
LogicalNode	LogicalNodeSerializer.visitLimit(LogicalNodeSerializer.SerializeContext context, LogicalPlan plan, LogicalPlan.QueryBlock block, LimitNode limit, Stack<LogicalNode> stack)
LogicalNode	LogicalNodeSerializer.visitPartitionedTableScan(LogicalNodeSerializer.SerializeContext context, LogicalPlan plan, LogicalPlan.QueryBlock block, PartitionedTableScanNode node, Stack<LogicalNode> stack)
LogicalNode	LogicalNodeSerializer.visitProjection(LogicalNodeSerializer.SerializeContext context, LogicalPlan plan, LogicalPlan.QueryBlock block, ProjectionNode projection, Stack<LogicalNode> stack)
LogicalNode	LogicalNodeSerializer.visitRoot(LogicalNodeSerializer.SerializeContext context, LogicalPlan plan, LogicalPlan.QueryBlock block, LogicalRootNode root, Stack<LogicalNode> stack)
LogicalNode	LogicalNodeSerializer.visitScan(LogicalNodeSerializer.SerializeContext context, LogicalPlan plan, LogicalPlan.QueryBlock block, ScanNode scan, Stack<LogicalNode> stack)
LogicalNode	LogicalNodeSerializer.visitSetSession(LogicalNodeSerializer.SerializeContext context, LogicalPlan plan, LogicalPlan.QueryBlock block, SetSessionNode node, Stack<LogicalNode> stack)
LogicalNode	LogicalNodeSerializer.visitSort(LogicalNodeSerializer.SerializeContext context, LogicalPlan plan, LogicalPlan.QueryBlock block, SortNode sort, Stack<LogicalNode> stack)
LogicalNode	LogicalNodeSerializer.visitTableSubQuery(LogicalNodeSerializer.SerializeContext context, LogicalPlan plan, LogicalPlan.QueryBlock block, TableSubQueryNode node, Stack<LogicalNode> stack)
LogicalNode	LogicalNodeSerializer.visitTruncateTable(LogicalNodeSerializer.SerializeContext context, LogicalPlan plan, LogicalPlan.QueryBlock block, TruncateTableNode node, Stack<LogicalNode> stack)
LogicalNode	LogicalNodeSerializer.visitUnion(LogicalNodeSerializer.SerializeContext context, LogicalPlan plan, LogicalPlan.QueryBlock block, UnionNode node, Stack<LogicalNode> stack)
LogicalNode	LogicalNodeSerializer.visitWindowAgg(LogicalNodeSerializer.SerializeContext context, LogicalPlan plan, LogicalPlan.QueryBlock block, WindowAggNode windowAgg, Stack<LogicalNode> stack)

Uses of PlanningException in org.apache.tajo.plan.util

Methods in org.apache.tajo.plan.util that throw PlanningException

Modifier and Type	Method and Description
static boolean	PlannerUtil.existsAggregationFunction(Expr expr)
static boolean	PlannerUtil.existsDistinctAggregationFunction(Expr expr)
static Collection<String>	PlannerUtil.getRelationLineageWithinQueryBlock(LogicalPlan plan, LogicalNode from) Get all RelationNodes which are descendant of a given LogicalNode.
Object	ExprFinder.visit(org.apache.tajo.plan.util.ExprFinder.Context ctx, Stack<Expr> stack, Expr expr)
LogicalNode	PlannerUtil.RelationFinderVisitor.visit(Object context, LogicalPlan plan, LogicalPlan.QueryBlock block, LogicalNode node, Stack<LogicalNode> stack)
LogicalNode	PlannerUtil.LogicalNodeReplaceVisitor.visit(org.apache.tajo.plan.util.PlannerUtil.ReplacerContext context, LogicalPlan plan, LogicalPlan.QueryBlock block, LogicalNode node, Stack<LogicalNode> stack)
LogicalNode	PlannerUtil.LogicalNodeReplaceVisitor.visitPartitionedTableScan(org.apache.tajo.plan.util.PlannerUtil.ReplacerContext context, LogicalPlan plan, LogicalPlan.QueryBlock block, PartitionedTableScanNode node, Stack<LogicalNode> stack)
LogicalNode	PlannerUtil.LogicalNodeReplaceVisitor.visitScan(org.apache.tajo.plan.util.PlannerUtil.ReplacerContext context, LogicalPlan plan, LogicalPlan.QueryBlock block, ScanNode node, Stack<LogicalNode> stack)

Uses of PlanningException in org.apache.tajo.plan.verifier

Subclasses of PlanningException in org.apache.tajo.plan.verifier

Modifier and Type	Class and Description
class	VerifyException

Methods in org.apache.tajo.plan.verifier that throw PlanningException

Modifier and Type	Method and Description
VerificationState	PreLogicalPlanVerifier.verify(OverridableConf queryContext, VerificationState state, Expr expr)
VerificationState	LogicalPlanVerifier.verify(OverridableConf queryContext, VerificationState state, LogicalPlan plan)
static VerificationState	ExprsVerifier.verify(VerificationState state, LogicalNode currentNode, EvalNode expression)
Expr	PreLogicalPlanVerifier.visitCreateDatabase(PreLogicalPlanVerifier.Context context, Stack<Expr> stack, CreateDatabase expr)
LogicalNode	LogicalPlanVerifier.visitCreateTable(LogicalPlanVerifier.Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, CreateTableNode node, Stack<LogicalNode> stack)
Expr	PreLogicalPlanVerifier.visitCreateTable(PreLogicalPlanVerifier.Context context, Stack<Expr> stack, CreateTable expr)
Expr	PreLogicalPlanVerifier.visitDropDatabase(PreLogicalPlanVerifier.Context context, Stack<Expr> stack, DropDatabase expr)
Expr	PreLogicalPlanVerifier.visitDropTable(PreLogicalPlanVerifier.Context context, Stack<Expr> stack, DropTable expr)
LogicalNode	LogicalPlanVerifier.visitExcept(LogicalPlanVerifier.Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, ExceptNode node, Stack<LogicalNode> stack)
LogicalNode	LogicalPlanVerifier.visitFilter(LogicalPlanVerifier.Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, SelectionNode node, Stack<LogicalNode> stack)
LogicalNode	LogicalPlanVerifier.visitGroupBy(LogicalPlanVerifier.Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, GroupbyNode node, Stack<LogicalNode> stack)
Expr	PreLogicalPlanVerifier.visitGroupBy(PreLogicalPlanVerifier.Context context, Stack<Expr> stack, Aggregation expr)
LogicalNode	LogicalPlanVerifier.visitInsert(LogicalPlanVerifier.Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, InsertNode node, Stack<LogicalNode> stack)
Expr	PreLogicalPlanVerifier.visitInsert(PreLogicalPlanVerifier.Context context, Stack<Expr> stack, Insert expr)
LogicalNode	LogicalPlanVerifier.visitIntersect(LogicalPlanVerifier.Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, IntersectNode node, Stack<LogicalNode> stack)
LogicalNode	LogicalPlanVerifier.visitJoin(LogicalPlanVerifier.Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, JoinNode node, Stack<LogicalNode> stack)
LogicalNode	LogicalPlanVerifier.visitLimit(LogicalPlanVerifier.Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, LimitNode node, Stack<LogicalNode> stack)
Expr	PreLogicalPlanVerifier.visitLimit(PreLogicalPlanVerifier.Context context, Stack<Expr> stack, Limit expr)
LogicalNode	LogicalPlanVerifier.visitProjection(LogicalPlanVerifier.Context state, LogicalPlan plan, LogicalPlan.QueryBlock block, ProjectionNode node, Stack<LogicalNode> stack)
Expr	PreLogicalPlanVerifier.visitProjection(PreLogicalPlanVerifier.Context context, Stack<Expr> stack, Projection expr)
Expr	PreLogicalPlanVerifier.visitRelation(PreLogicalPlanVerifier.Context context, Stack<Expr> stack, Relation expr)
LogicalNode	LogicalPlanVerifier.visitScan(LogicalPlanVerifier.Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, ScanNode node, Stack<LogicalNode> stack)
Expr	PreLogicalPlanVerifier.visitSetSession(PreLogicalPlanVerifier.Context ctx, Stack<Expr> stack, SetSession expr)
LogicalNode	LogicalPlanVerifier.visitStoreTable(LogicalPlanVerifier.Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, StoreTableNode node, Stack<LogicalNode> stack)
LogicalNode	LogicalPlanVerifier.visitTableSubQuery(LogicalPlanVerifier.Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, TableSubQueryNode node, Stack<LogicalNode> stack)
LogicalNode	LogicalPlanVerifier.visitUnion(LogicalPlanVerifier.Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, UnionNode node, Stack<LogicalNode> stack)

Uses of PlanningException in org.apache.tajo.plan.visitor

Methods in org.apache.tajo.plan.visitor that throw PlanningException

Modifier and Type	Method and Description
ExplainLogicalPlanVisitor.Context	ExplainLogicalPlanVisitor.getBlockPlanStrings(LogicalPlan plan, LogicalNode node)
void	BasicLogicalPlanVisitor.postHook(LogicalPlan plan, LogicalNode node, Stack<LogicalNode> stack, CONTEXT data) The posthook is called after each node is visited.
void	BasicLogicalPlanVisitor.preHook(LogicalPlan plan, LogicalNode node, Stack<LogicalNode> stack, CONTEXT data) The prehook is called before each node is visited.
CONTEXT	BasicLogicalPlanVisitor.visit(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block)
RESULT	BasicLogicalPlanVisitor.visit(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, LogicalNode node, Stack<LogicalNode> stack) visit visits each logicalNode recursively.
RESULT	SimpleAlgebraVisitor.visit(CONTEXT ctx, Stack<Expr> stack, Expr expr)
RESULT	LogicalPlanVisitor.visitAlterTable(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, AlterTableNode node, Stack<LogicalNode> stack)
RESULT	SimpleAlgebraVisitor.visitAlterTable(CONTEXT ctx, Stack<Expr> stack, AlterTable expr)
RESULT	LogicalPlanVisitor.visitAlterTablespace(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, AlterTablespaceNode node, Stack<LogicalNode> stack)
RESULT	BasicLogicalPlanVisitor.visitAlterTablespace(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, AlterTablespaceNode node, Stack<LogicalNode> stack)
RESULT	SimpleAlgebraVisitor.visitBetween(CONTEXT ctx, Stack<Expr> stack, BetweenPredicate expr)
RESULT	SimpleAlgebraVisitor.visitBinaryOperator(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr)
RESULT	SimpleAlgebraVisitor.visitCaseWhen(CONTEXT ctx, Stack<Expr> stack, CaseWhenPredicate expr)
RESULT	SimpleAlgebraVisitor.visitCountRowsFunction(CONTEXT ctx, Stack<Expr> stack, CountRowsFunctionExpr expr)
RESULT	LogicalPlanVisitor.visitCreateDatabase(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, CreateDatabaseNode node, Stack<LogicalNode> stack)
RESULT	BasicLogicalPlanVisitor.visitCreateDatabase(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, CreateDatabaseNode node, Stack<LogicalNode> stack)
LogicalNode	ExplainLogicalPlanVisitor.visitCreateDatabase(ExplainLogicalPlanVisitor.Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, CreateDatabaseNode node, Stack<LogicalNode> stack)
RESULT	LogicalPlanVisitor.visitCreateTable(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, CreateTableNode node, Stack<LogicalNode> stack)
RESULT	BasicLogicalPlanVisitor.visitCreateTable(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, CreateTableNode node, Stack<LogicalNode> stack)
RESULT	SimpleAlgebraVisitor.visitCreateTable(CONTEXT ctx, Stack<Expr> stack, CreateTable expr)
RESULT	SimpleAlgebraVisitor.visitDataType(CONTEXT ctx, Stack<Expr> stack, DataTypeExpr expr)
RESULT	LogicalPlanVisitor.visitDistinctGroupby(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, DistinctGroupbyNode node, Stack<LogicalNode> stack)
RESULT	BasicLogicalPlanVisitor.visitDistinctGroupby(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, DistinctGroupbyNode node, Stack<LogicalNode> stack)
LogicalNode	ExplainLogicalPlanVisitor.visitDistinctGroupby(ExplainLogicalPlanVisitor.Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, DistinctGroupbyNode node, Stack<LogicalNode> stack)
RESULT	LogicalPlanVisitor.visitDropDatabase(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, DropDatabaseNode node, Stack<LogicalNode> stack)
RESULT	BasicLogicalPlanVisitor.visitDropDatabase(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, DropDatabaseNode node, Stack<LogicalNode> stack)
LogicalNode	ExplainLogicalPlanVisitor.visitDropDatabase(ExplainLogicalPlanVisitor.Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, DropDatabaseNode node, Stack<LogicalNode> stack)
RESULT	LogicalPlanVisitor.visitDropTable(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, DropTableNode node, Stack<LogicalNode> stack)
RESULT	SimpleAlgebraVisitor.visitDropTable(CONTEXT ctx, Stack<Expr> stack, DropTable expr)
RESULT	LogicalPlanVisitor.visitEvalExpr(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, EvalExprNode node, Stack<LogicalNode> stack)
RESULT	BasicLogicalPlanVisitor.visitEvalExpr(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, EvalExprNode node, Stack<LogicalNode> stack)
RESULT	LogicalPlanVisitor.visitExcept(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, ExceptNode node, Stack<LogicalNode> stack)
RESULT	BasicLogicalPlanVisitor.visitExcept(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, ExceptNode node, Stack<LogicalNode> stack)
LogicalNode	ExplainLogicalPlanVisitor.visitExcept(ExplainLogicalPlanVisitor.Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, ExceptNode node, Stack<LogicalNode> stack)
RESULT	LogicalPlanVisitor.visitFilter(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, SelectionNode node, Stack<LogicalNode> stack)
RESULT	BasicLogicalPlanVisitor.visitFilter(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, SelectionNode node, Stack<LogicalNode> stack)
RESULT	SimpleAlgebraVisitor.visitFilter(CONTEXT ctx, Stack<Expr> stack, Selection expr)
LogicalNode	ExplainLogicalPlanVisitor.visitFilter(ExplainLogicalPlanVisitor.Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, SelectionNode node, Stack<LogicalNode> stack)
RESULT	SimpleAlgebraVisitor.visitFunction(CONTEXT ctx, Stack<Expr> stack, FunctionExpr expr)
RESULT	SimpleAlgebraVisitor.visitGeneralSetFunction(CONTEXT ctx, Stack<Expr> stack, GeneralSetFunctionExpr expr)
RESULT	LogicalPlanVisitor.visitGroupBy(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, GroupbyNode node, Stack<LogicalNode> stack)
RESULT	BasicLogicalPlanVisitor.visitGroupBy(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, GroupbyNode node, Stack<LogicalNode> stack)
RESULT	SimpleAlgebraVisitor.visitGroupBy(CONTEXT ctx, Stack<Expr> stack, Aggregation expr)
LogicalNode	ExplainLogicalPlanVisitor.visitGroupBy(ExplainLogicalPlanVisitor.Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, GroupbyNode node, Stack<LogicalNode> stack)
RESULT	LogicalPlanVisitor.visitHaving(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, HavingNode node, Stack<LogicalNode> stack)
RESULT	BasicLogicalPlanVisitor.visitHaving(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, HavingNode node, Stack<LogicalNode> stack)
RESULT	SimpleAlgebraVisitor.visitHaving(CONTEXT ctx, Stack<Expr> stack, Having expr)
LogicalNode	ExplainLogicalPlanVisitor.visitHaving(ExplainLogicalPlanVisitor.Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, HavingNode node, Stack<LogicalNode> stack)
RESULT	LogicalPlanVisitor.visitInsert(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, InsertNode node, Stack<LogicalNode> stack)
RESULT	BasicLogicalPlanVisitor.visitInsert(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, InsertNode node, Stack<LogicalNode> stack)
RESULT	SimpleAlgebraVisitor.visitInsert(CONTEXT ctx, Stack<Expr> stack, Insert expr)
LogicalNode	ExplainLogicalPlanVisitor.visitInsert(ExplainLogicalPlanVisitor.Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, InsertNode node, Stack<LogicalNode> stack)
RESULT	LogicalPlanVisitor.visitIntersect(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, IntersectNode node, Stack<LogicalNode> stack)
RESULT	BasicLogicalPlanVisitor.visitIntersect(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, IntersectNode node, Stack<LogicalNode> stack)
LogicalNode	ExplainLogicalPlanVisitor.visitIntersect(ExplainLogicalPlanVisitor.Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, IntersectNode node, Stack<LogicalNode> stack)
RESULT	LogicalPlanVisitor.visitJoin(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, JoinNode node, Stack<LogicalNode> stack)
RESULT	BasicLogicalPlanVisitor.visitJoin(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, JoinNode node, Stack<LogicalNode> stack)
RESULT	SimpleAlgebraVisitor.visitJoin(CONTEXT ctx, Stack<Expr> stack, Join expr)
LogicalNode	ExplainLogicalPlanVisitor.visitJoin(ExplainLogicalPlanVisitor.Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, JoinNode node, Stack<LogicalNode> stack)
RESULT	LogicalPlanVisitor.visitLimit(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, LimitNode node, Stack<LogicalNode> stack)
RESULT	BasicLogicalPlanVisitor.visitLimit(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, LimitNode node, Stack<LogicalNode> stack)
RESULT	SimpleAlgebraVisitor.visitLimit(CONTEXT ctx, Stack<Expr> stack, Limit expr)
LogicalNode	ExplainLogicalPlanVisitor.visitLimit(ExplainLogicalPlanVisitor.Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, LimitNode node, Stack<LogicalNode> stack)
RESULT	SimpleAlgebraVisitor.visitLiteral(CONTEXT ctx, Stack<Expr> stack, LiteralValue expr)
RESULT	SimpleAlgebraVisitor.visitNullLiteral(CONTEXT ctx, Stack<Expr> stack, NullLiteral expr)
RESULT	LogicalPlanVisitor.visitPartitionedTableScan(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, PartitionedTableScanNode node, Stack<LogicalNode> stack)
RESULT	BasicLogicalPlanVisitor.visitPartitionedTableScan(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, PartitionedTableScanNode node, Stack<LogicalNode> stack)
LogicalNode	ExplainLogicalPlanVisitor.visitPartitionedTableScan(ExplainLogicalPlanVisitor.Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, PartitionedTableScanNode node, Stack<LogicalNode> stack)
RESULT	LogicalPlanVisitor.visitProjection(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, ProjectionNode node, Stack<LogicalNode> stack)
RESULT	BasicLogicalPlanVisitor.visitProjection(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, ProjectionNode node, Stack<LogicalNode> stack)
RESULT	SimpleAlgebraVisitor.visitProjection(CONTEXT ctx, Stack<Expr> stack, Projection expr)
LogicalNode	ExplainLogicalPlanVisitor.visitProjection(ExplainLogicalPlanVisitor.Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, ProjectionNode node, Stack<LogicalNode> stack)
RESULT	SimpleAlgebraVisitor.visitRelationList(CONTEXT ctx, Stack<Expr> stack, RelationList expr)
RESULT	LogicalPlanVisitor.visitRoot(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, LogicalRootNode node, Stack<LogicalNode> stack)
RESULT	BasicLogicalPlanVisitor.visitRoot(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, LogicalRootNode node, Stack<LogicalNode> stack)
LogicalNode	ExplainLogicalPlanVisitor.visitRoot(ExplainLogicalPlanVisitor.Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, LogicalRootNode node, Stack<LogicalNode> stack)
RESULT	LogicalPlanVisitor.visitScan(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, ScanNode node, Stack<LogicalNode> stack)
RESULT	BasicLogicalPlanVisitor.visitScan(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, ScanNode node, Stack<LogicalNode> stack)
LogicalNode	ExplainLogicalPlanVisitor.visitScan(ExplainLogicalPlanVisitor.Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, ScanNode node, Stack<LogicalNode> stack)
RESULT	LogicalPlanVisitor.visitSetSession(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, SetSessionNode node, Stack<LogicalNode> stack)
RESULT	BasicLogicalPlanVisitor.visitSetSession(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, SetSessionNode node, Stack<LogicalNode> stack)
RESULT	LogicalPlanVisitor.visitSort(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, SortNode node, Stack<LogicalNode> stack)
RESULT	BasicLogicalPlanVisitor.visitSort(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, SortNode node, Stack<LogicalNode> stack)
RESULT	SimpleAlgebraVisitor.visitSort(CONTEXT ctx, Stack<Expr> stack, Sort expr)
LogicalNode	ExplainLogicalPlanVisitor.visitSort(ExplainLogicalPlanVisitor.Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, SortNode node, Stack<LogicalNode> stack)
RESULT	LogicalPlanVisitor.visitStoreTable(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, StoreTableNode node, Stack<LogicalNode> stack)
RESULT	BasicLogicalPlanVisitor.visitStoreTable(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, StoreTableNode node, Stack<LogicalNode> stack)
LogicalNode	ExplainLogicalPlanVisitor.visitStoreTable(ExplainLogicalPlanVisitor.Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, StoreTableNode node, Stack<LogicalNode> stack)
RESULT	LogicalPlanVisitor.visitTableSubQuery(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, TableSubQueryNode node, Stack<LogicalNode> stack)
RESULT	BasicLogicalPlanVisitor.visitTableSubQuery(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, TableSubQueryNode node, Stack<LogicalNode> stack)
RESULT	SimpleAlgebraVisitor.visitTableSubQuery(CONTEXT ctx, Stack<Expr> stack, TablePrimarySubQuery expr)
LogicalNode	ExplainLogicalPlanVisitor.visitTableSubQuery(ExplainLogicalPlanVisitor.Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, TableSubQueryNode node, Stack<LogicalNode> stack)
RESULT	SimpleAlgebraVisitor.visitTimeLiteral(CONTEXT ctx, Stack<Expr> stack, TimeLiteral expr)
RESULT	SimpleAlgebraVisitor.visitTimestampLiteral(CONTEXT ctx, Stack<Expr> stack, TimestampLiteral expr)
RESULT	LogicalPlanVisitor.visitTruncateTable(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, TruncateTableNode node, Stack<LogicalNode> stack)
RESULT	BasicLogicalPlanVisitor.visitTruncateTable(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, TruncateTableNode node, Stack<LogicalNode> stack)
RESULT	SimpleAlgebraVisitor.visitUnaryOperator(CONTEXT ctx, Stack<Expr> stack, UnaryOperator expr)
RESULT	LogicalPlanVisitor.visitUnion(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, UnionNode node, Stack<LogicalNode> stack)
RESULT	BasicLogicalPlanVisitor.visitUnion(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, UnionNode node, Stack<LogicalNode> stack)
LogicalNode	ExplainLogicalPlanVisitor.visitUnion(ExplainLogicalPlanVisitor.Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, UnionNode node, Stack<LogicalNode> stack)
RESULT	SimpleAlgebraVisitor.visitValueListExpr(CONTEXT ctx, Stack<Expr> stack, ValueListExpr expr)
RESULT	LogicalPlanVisitor.visitWindowAgg(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, WindowAggNode node, Stack<LogicalNode> stack)
RESULT	BasicLogicalPlanVisitor.visitWindowAgg(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, WindowAggNode node, Stack<LogicalNode> stack)
LogicalNode	ExplainLogicalPlanVisitor.visitWindowAgg(ExplainLogicalPlanVisitor.Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, WindowAggNode node, Stack<LogicalNode> stack)
RESULT	SimpleAlgebraVisitor.visitWindowFunction(CONTEXT ctx, Stack<Expr> stack, WindowFunctionExpr expr)