http://git-wip-us.apache.org/repos/asf/tajo/blob/4841c656/tajo-plan/src/main/java/org/apache/tajo/plan/LogicalOptimizer.java ---------------------------------------------------------------------- diff --git a/tajo-plan/src/main/java/org/apache/tajo/plan/LogicalOptimizer.java b/tajo-plan/src/main/java/org/apache/tajo/plan/LogicalOptimizer.java index 2760722..d06c8e2 100644 --- a/tajo-plan/src/main/java/org/apache/tajo/plan/LogicalOptimizer.java +++ b/tajo-plan/src/main/java/org/apache/tajo/plan/LogicalOptimizer.java @@ -28,6 +28,7 @@ import org.apache.tajo.SessionVars; import org.apache.tajo.algebra.JoinType; import org.apache.tajo.conf.TajoConf; import org.apache.tajo.conf.TajoConf.ConfVars; +import org.apache.tajo.exception.TajoException; import org.apache.tajo.plan.expr.AlgebraicUtil; import org.apache.tajo.plan.expr.EvalNode; import org.apache.tajo.plan.expr.EvalTreeUtil; @@ -69,13 +70,13 @@ public class LogicalOptimizer { } @VisibleForTesting - public LogicalNode optimize(LogicalPlan plan) throws PlanningException { + public LogicalNode optimize(LogicalPlan plan) throws TajoException { OverridableConf conf = new OverridableConf(new TajoConf(), ConfigKey.ConfigType.SESSION, ConfigKey.ConfigType.QUERY, ConfigKey.ConfigType.SYSTEM); return optimize(conf, plan); } - public LogicalNode optimize(OverridableConf context, LogicalPlan plan) throws PlanningException { + public LogicalNode optimize(OverridableConf context, LogicalPlan plan) throws TajoException { rulesBeforeJoinOpt.rewrite(context, plan); DirectedGraphCursor<String, BlockEdge> blockCursor = @@ -93,7 +94,7 @@ public class LogicalOptimizer { return plan.getRootBlock().getRoot(); } - private void optimizeJoinOrder(LogicalPlan plan, String blockName) throws PlanningException { + private void optimizeJoinOrder(LogicalPlan plan, String blockName) throws TajoException { LogicalPlan.QueryBlock block = plan.getBlock(blockName); if (block.hasNode(NodeType.JOIN)) { @@ -186,7 +187,7 @@ public class LogicalOptimizer { @Override public LogicalNode visitJoin(Set<Target> ctx, LogicalPlan plan, LogicalPlan.QueryBlock block, JoinNode node, Stack<LogicalNode> stack) - throws PlanningException { + throws TajoException { super.visitJoin(ctx, plan, block, node, stack); if (node.hasTargets()) { @@ -228,7 +229,7 @@ public class LogicalOptimizer { * Otherwise, this method may build incorrectly a join graph. */ public static JoinGraphContext buildJoinGraph(LogicalPlan plan, LogicalPlan.QueryBlock block) - throws PlanningException { + throws TajoException { JoinGraphContext context = new JoinGraphContext(); instance.visit(context, plan, block); return context; @@ -236,7 +237,7 @@ public class LogicalOptimizer { @Override public LogicalNode visit(JoinGraphContext context, LogicalPlan plan, LogicalPlan.QueryBlock block, - LogicalNode node, Stack<LogicalNode> stack) throws PlanningException { + LogicalNode node, Stack<LogicalNode> stack) throws TajoException { if (node.getType() != NodeType.TABLE_SUBQUERY) { super.visit(context, plan, block, node, stack); } @@ -246,7 +247,7 @@ public class LogicalOptimizer { @Override public LogicalNode visitFilter(JoinGraphContext context, LogicalPlan plan, LogicalPlan.QueryBlock block, - SelectionNode node, Stack<LogicalNode> stack) throws PlanningException { + SelectionNode node, Stack<LogicalNode> stack) throws TajoException { // all join predicate candidates must be collected before building the join tree context.addCandidateJoinFilters( TUtil.newList(AlgebraicUtil.toConjunctiveNormalFormArray(node.getQual()))); @@ -257,7 +258,7 @@ public class LogicalOptimizer { @Override public LogicalNode visitJoin(JoinGraphContext context, LogicalPlan plan, LogicalPlan.QueryBlock block, JoinNode joinNode, Stack<LogicalNode> stack) - throws PlanningException { + throws TajoException { super.visitJoin(context, plan, block, joinNode, stack); // given a join node, find the relations which are nearest to the join in the query. @@ -321,7 +322,7 @@ public class LogicalOptimizer { return instance; } - public static String buildJoinOrderString(LogicalPlan plan, LogicalPlan.QueryBlock block) throws PlanningException { + public static String buildJoinOrderString(LogicalPlan plan, LogicalPlan.QueryBlock block) throws TajoException { StringBuilder originalOrder = new StringBuilder(); instance.visit(originalOrder, plan, block); return originalOrder.toString(); @@ -330,7 +331,7 @@ public class LogicalOptimizer { @Override public LogicalNode visitJoin(StringBuilder sb, LogicalPlan plan, LogicalPlan.QueryBlock block, JoinNode joinNode, Stack<LogicalNode> stack) - throws PlanningException { + throws TajoException { stack.push(joinNode); sb.append("("); visit(sb, plan, block, joinNode.getLeftChild(), stack); @@ -380,7 +381,7 @@ public class LogicalOptimizer { instance = new JoinCostComputer(); } - public static double computeCost(LogicalPlan plan, LogicalPlan.QueryBlock block) throws PlanningException { + public static double computeCost(LogicalPlan plan, LogicalPlan.QueryBlock block) throws TajoException { CostContext costContext = new CostContext(); instance.visit(costContext, plan, block); return costContext.accumulatedCost; @@ -389,7 +390,7 @@ public class LogicalOptimizer { @Override public LogicalNode visitJoin(CostContext joinGraphContext, LogicalPlan plan, LogicalPlan.QueryBlock block, JoinNode joinNode, Stack<LogicalNode> stack) - throws PlanningException { + throws TajoException { super.visitJoin(joinGraphContext, plan, block, joinNode, stack); double filterFactor = 1; @@ -417,10 +418,10 @@ public class LogicalOptimizer { * @param block query block in which the given join node is involved * @param from logical node where the search starts * @return found relation - * @throws PlanningException + * @throws TajoException */ public static RelationNode findMostLeftRelation(LogicalPlan plan, LogicalPlan.QueryBlock block, LogicalNode from) - throws PlanningException { + throws TajoException { RelationNodeFinderContext context = new RelationNodeFinderContext(); context.findMostLeft = true; RelationNodeFinder finder = new RelationNodeFinder(); @@ -435,10 +436,10 @@ public class LogicalOptimizer { * @param block query block in which the given join node is involved * @param from logical node where the search starts * @return found relation - * @throws PlanningException + * @throws TajoException */ public static RelationNode findMostRightRelation(LogicalPlan plan, LogicalPlan.QueryBlock block, LogicalNode from) - throws PlanningException { + throws TajoException { RelationNodeFinderContext context = new RelationNodeFinderContext(); context.findMostRight = true; RelationNodeFinder finder = new RelationNodeFinder(); @@ -459,7 +460,7 @@ public class LogicalOptimizer { @Override public LogicalNode visit(RelationNodeFinderContext context, LogicalPlan plan, LogicalPlan.QueryBlock block, - LogicalNode node, Stack<LogicalNode> stack) throws PlanningException { + LogicalNode node, Stack<LogicalNode> stack) throws TajoException { if (node.getType() != NodeType.TABLE_SUBQUERY) { super.visit(context, plan, block, node, stack); } @@ -473,7 +474,7 @@ public class LogicalOptimizer { @Override public LogicalNode visitJoin(RelationNodeFinderContext context, LogicalPlan plan, LogicalPlan.QueryBlock block, - JoinNode node, Stack<LogicalNode> stack) throws PlanningException { + JoinNode node, Stack<LogicalNode> stack) throws TajoException { stack.push(node); LogicalNode result = null; if (context.findMostLeft) {
http://git-wip-us.apache.org/repos/asf/tajo/blob/4841c656/tajo-plan/src/main/java/org/apache/tajo/plan/LogicalPlan.java ---------------------------------------------------------------------- diff --git a/tajo-plan/src/main/java/org/apache/tajo/plan/LogicalPlan.java b/tajo-plan/src/main/java/org/apache/tajo/plan/LogicalPlan.java index a6a3dbe..9cc1e78 100644 --- a/tajo-plan/src/main/java/org/apache/tajo/plan/LogicalPlan.java +++ b/tajo-plan/src/main/java/org/apache/tajo/plan/LogicalPlan.java @@ -25,8 +25,8 @@ import org.apache.tajo.algebra.*; import org.apache.tajo.annotation.NotThreadSafe; import org.apache.tajo.catalog.Column; import org.apache.tajo.catalog.Schema; -import org.apache.tajo.util.graph.DirectedGraphCursor; -import org.apache.tajo.util.graph.SimpleDirectedGraph; +import org.apache.tajo.exception.TajoException; +import org.apache.tajo.exception.TajoInternalError; import org.apache.tajo.plan.expr.ConstEval; import org.apache.tajo.plan.expr.EvalNode; import org.apache.tajo.plan.logical.LogicalNode; @@ -37,6 +37,8 @@ import org.apache.tajo.plan.nameresolver.NameResolver; import org.apache.tajo.plan.nameresolver.NameResolvingMode; import org.apache.tajo.plan.visitor.ExplainLogicalPlanVisitor; import org.apache.tajo.util.TUtil; +import org.apache.tajo.util.graph.DirectedGraphCursor; +import org.apache.tajo.util.graph.SimpleDirectedGraph; import java.lang.reflect.Constructor; import java.util.*; @@ -315,7 +317,7 @@ public class LogicalPlan { return queryBlockGraph; } - public Column resolveColumn(QueryBlock block, ColumnReferenceExpr columnRef) throws PlanningException { + public Column resolveColumn(QueryBlock block, ColumnReferenceExpr columnRef) throws TajoException { return NameResolver.resolve(this, block, columnRef, NameResolvingMode.LEGACY); } @@ -363,8 +365,8 @@ public class LogicalPlan { explains.append( ExplainLogicalPlanVisitor.printDepthString(explainContext.getMaxDepth(), explainContext.explains.pop())); } - } catch (PlanningException e) { - throw new RuntimeException(e); + } catch (TajoException e) { + throw new TajoInternalError(e); } return explains.toString(); @@ -575,12 +577,12 @@ public class LogicalPlan { return namedExprsMgr; } - public void updateCurrentNode(Expr expr) throws PlanningException { + public void updateCurrentNode(Expr expr) { if (expr.getType() != OpType.RelationList) { // skip relation list because it is a virtual expr. this.currentNode = exprToNodeMap.get(ObjectUtils.identityToString(expr)); if (currentNode == null) { - throw new PlanningException("Unregistered Algebra Expression: " + expr.getType()); + throw new TajoInternalError("Unregistered Algebra Expression: " + expr.getType()); } } } http://git-wip-us.apache.org/repos/asf/tajo/blob/4841c656/tajo-plan/src/main/java/org/apache/tajo/plan/LogicalPlanPreprocessor.java ---------------------------------------------------------------------- diff --git a/tajo-plan/src/main/java/org/apache/tajo/plan/LogicalPlanPreprocessor.java b/tajo-plan/src/main/java/org/apache/tajo/plan/LogicalPlanPreprocessor.java index 2006e88..0a8d1c4 100644 --- a/tajo-plan/src/main/java/org/apache/tajo/plan/LogicalPlanPreprocessor.java +++ b/tajo-plan/src/main/java/org/apache/tajo/plan/LogicalPlanPreprocessor.java @@ -23,6 +23,7 @@ import org.apache.tajo.algebra.*; import org.apache.tajo.catalog.*; import org.apache.tajo.catalog.exception.UndefinedColumnException; import org.apache.tajo.common.TajoDataTypes; +import org.apache.tajo.exception.TajoException; import org.apache.tajo.plan.LogicalPlan.QueryBlock; import org.apache.tajo.plan.algebra.BaseAlgebraVisitor; import org.apache.tajo.plan.expr.ConstEval; @@ -55,14 +56,14 @@ public class LogicalPlanPreprocessor extends BaseAlgebraVisitor<LogicalPlanner.P } @Override - public void preHook(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, Expr expr) throws PlanningException { + public void preHook(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, Expr expr) throws TajoException { ctx.queryBlock.setAlgebraicExpr(expr); ctx.plan.mapExprToBlock(expr, ctx.queryBlock.getName()); } @Override public LogicalNode postHook(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, Expr expr, LogicalNode result) - throws PlanningException { + throws TajoException { // If non-from statement, result can be null. It avoids that case. if (result != null) { // setNode method registers each node to corresponding block and plan. @@ -78,10 +79,10 @@ public class LogicalPlanPreprocessor extends BaseAlgebraVisitor<LogicalPlanner.P * @param ctx * @param asteriskExpr * @return array of columns - * @throws PlanningException + * @throws TajoException */ public static Column[] getColumns(LogicalPlanner.PlanContext ctx, QualifiedAsteriskExpr asteriskExpr) - throws PlanningException { + throws TajoException { RelationNode relationOp = null; QueryBlock block = ctx.queryBlock; Collection<QueryBlock> queryBlocks = ctx.plan.getQueryBlocks(); @@ -140,10 +141,10 @@ public class LogicalPlanPreprocessor extends BaseAlgebraVisitor<LogicalPlanner.P * @param ctx context * @param asteriskExpr asterisk expression * @return a list of NamedExpr each of which has ColumnReferenceExprs as its child - * @throws PlanningException + * @throws TajoException */ private static List<NamedExpr> resolveAsterisk(LogicalPlanner.PlanContext ctx, QualifiedAsteriskExpr asteriskExpr) - throws PlanningException { + throws TajoException { Column[] columns = getColumns(ctx, asteriskExpr); List<NamedExpr> newTargetExprs = new ArrayList<NamedExpr>(columns.length); int i; @@ -163,7 +164,7 @@ public class LogicalPlanPreprocessor extends BaseAlgebraVisitor<LogicalPlanner.P } private static NamedExpr [] voidResolveAsteriskNamedExpr(LogicalPlanner.PlanContext context, - NamedExpr [] namedExprs) throws PlanningException { + NamedExpr [] namedExprs) throws TajoException { List<NamedExpr> rewrittenTargets = TUtil.newList(); for (NamedExpr originTarget : namedExprs) { if (originTarget.getExpr().getType() == OpType.Asterisk) { @@ -178,14 +179,14 @@ public class LogicalPlanPreprocessor extends BaseAlgebraVisitor<LogicalPlanner.P @Override public LogicalNode visitSetSession(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, SetSession expr) - throws PlanningException { + throws TajoException { SetSessionNode setSession = ctx.plan.createNode(SetSessionNode.class); return setSession; } @Override public LogicalNode visitProjection(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, Projection expr) - throws PlanningException { + throws TajoException { // If Non-from statement, it immediately returns. if (!expr.hasChild()) { EvalExprNode exprNode = ctx.plan.createNode(EvalExprNode.class); @@ -231,7 +232,7 @@ public class LogicalPlanPreprocessor extends BaseAlgebraVisitor<LogicalPlanner.P return projectionNode; } - private Target [] buildTargets(LogicalPlanner.PlanContext context, NamedExpr [] exprs) throws PlanningException { + private Target [] buildTargets(LogicalPlanner.PlanContext context, NamedExpr [] exprs) throws TajoException { Target [] targets = new Target[exprs.length]; for (int i = 0; i < exprs.length; i++) { NamedExpr namedExpr = exprs[i]; @@ -249,7 +250,7 @@ public class LogicalPlanPreprocessor extends BaseAlgebraVisitor<LogicalPlanner.P @Override public LogicalNode visitLimit(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, Limit expr) - throws PlanningException { + throws TajoException { stack.push(expr); LogicalNode child = visit(ctx, stack, expr.getChild()); stack.pop(); @@ -261,7 +262,7 @@ public class LogicalPlanPreprocessor extends BaseAlgebraVisitor<LogicalPlanner.P } @Override - public LogicalNode visitSort(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, Sort expr) throws PlanningException { + public LogicalNode visitSort(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, Sort expr) throws TajoException { stack.push(expr); LogicalNode child = visit(ctx, stack, expr.getChild()); stack.pop(); @@ -274,7 +275,7 @@ public class LogicalPlanPreprocessor extends BaseAlgebraVisitor<LogicalPlanner.P @Override public LogicalNode visitHaving(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, Having expr) - throws PlanningException { + throws TajoException { stack.push(expr); LogicalNode child = visit(ctx, stack, expr.getChild()); stack.pop(); @@ -287,7 +288,7 @@ public class LogicalPlanPreprocessor extends BaseAlgebraVisitor<LogicalPlanner.P @Override public LogicalNode visitGroupBy(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, Aggregation expr) - throws PlanningException { + throws TajoException { stack.push(expr); // <--- push LogicalNode child = visit(ctx, stack, expr.getChild()); @@ -319,7 +320,7 @@ public class LogicalPlanPreprocessor extends BaseAlgebraVisitor<LogicalPlanner.P @Override public LogicalNode visitUnion(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, SetOperation expr) - throws PlanningException { + throws TajoException { LogicalPlan.QueryBlock leftBlock = ctx.plan.newQueryBlock(); LogicalPlanner.PlanContext leftContext = new LogicalPlanner.PlanContext(ctx, leftBlock); LogicalNode leftChild = visit(leftContext, new Stack<Expr>(), expr.getLeft()); @@ -343,7 +344,7 @@ public class LogicalPlanPreprocessor extends BaseAlgebraVisitor<LogicalPlanner.P } public LogicalNode visitFilter(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, Selection expr) - throws PlanningException { + throws TajoException { stack.push(expr); LogicalNode child = visit(ctx, stack, expr.getChild()); stack.pop(); @@ -355,7 +356,7 @@ public class LogicalPlanPreprocessor extends BaseAlgebraVisitor<LogicalPlanner.P } @Override - public LogicalNode visitJoin(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, Join expr) throws PlanningException { + public LogicalNode visitJoin(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, Join expr) throws TajoException { stack.push(expr); LogicalNode left = visit(ctx, stack, expr.getLeft()); LogicalNode right = visit(ctx, stack, expr.getRight()); @@ -372,7 +373,7 @@ public class LogicalPlanPreprocessor extends BaseAlgebraVisitor<LogicalPlanner.P @Override public LogicalNode visitRelation(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, Relation expr) - throws PlanningException { + throws TajoException { Relation relation = expr; String actualRelationName; @@ -400,7 +401,7 @@ public class LogicalPlanPreprocessor extends BaseAlgebraVisitor<LogicalPlanner.P @Override public LogicalNode visitTableSubQuery(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, TablePrimarySubQuery expr) - throws PlanningException { + throws TajoException { LogicalPlanner.PlanContext newContext; // Note: TableSubQuery always has a table name. @@ -423,21 +424,21 @@ public class LogicalPlanPreprocessor extends BaseAlgebraVisitor<LogicalPlanner.P @Override public LogicalNode visitCreateDatabase(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, CreateDatabase expr) - throws PlanningException { + throws TajoException { CreateDatabaseNode createDatabaseNode = ctx.plan.createNode(CreateDatabaseNode.class); return createDatabaseNode; } @Override public LogicalNode visitDropDatabase(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, DropDatabase expr) - throws PlanningException { + throws TajoException { DropDatabaseNode dropDatabaseNode = ctx.plan.createNode(DropDatabaseNode.class); return dropDatabaseNode; } @Override public LogicalNode visitCreateTable(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, CreateTable expr) - throws PlanningException { + throws TajoException { CreateTableNode createTableNode = ctx.plan.createNode(CreateTableNode.class); @@ -452,28 +453,28 @@ public class LogicalPlanPreprocessor extends BaseAlgebraVisitor<LogicalPlanner.P @Override public LogicalNode visitDropTable(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, DropTable expr) - throws PlanningException { + throws TajoException { DropTableNode dropTable = ctx.plan.createNode(DropTableNode.class); return dropTable; } @Override public LogicalNode visitAlterTablespace(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, AlterTablespace expr) - throws PlanningException { + throws TajoException { AlterTablespaceNode alterTablespace = ctx.plan.createNode(AlterTablespaceNode.class); return alterTablespace; } @Override public LogicalNode visitAlterTable(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, AlterTable expr) - throws PlanningException { + throws TajoException { AlterTableNode alterTableNode = ctx.plan.createNode(AlterTableNode.class); return alterTableNode; } @Override public LogicalNode visitTruncateTable(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, TruncateTable expr) - throws PlanningException { + throws TajoException { TruncateTableNode truncateTableNode = ctx.plan.createNode(TruncateTableNode.class); return truncateTableNode; } @@ -483,7 +484,7 @@ public class LogicalPlanPreprocessor extends BaseAlgebraVisitor<LogicalPlanner.P /////////////////////////////////////////////////////////////////////////////////////////////////////////// public LogicalNode visitInsert(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, Insert expr) - throws PlanningException { + throws TajoException { LogicalNode child = super.visitInsert(ctx, stack, expr); InsertNode insertNode = new InsertNode(ctx.plan.newPID()); @@ -499,14 +500,14 @@ public class LogicalPlanPreprocessor extends BaseAlgebraVisitor<LogicalPlanner.P instance = new NameRefInSelectListNormalizer(); } - public static void normalize(LogicalPlanner.PlanContext context, Expr expr) throws PlanningException { + public static void normalize(LogicalPlanner.PlanContext context, Expr expr) throws TajoException { NameRefInSelectListNormalizer normalizer = new NameRefInSelectListNormalizer(); normalizer.visit(context,new Stack<Expr>(), expr); } @Override public Expr visitColumnReference(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, ColumnReferenceExpr expr) - throws PlanningException { + throws TajoException { String normalized = NameResolver.resolve(ctx.plan, ctx.queryBlock, expr, NameResolvingMode.RELS_ONLY).getQualifiedName(); http://git-wip-us.apache.org/repos/asf/tajo/blob/4841c656/tajo-plan/src/main/java/org/apache/tajo/plan/LogicalPlanner.java ---------------------------------------------------------------------- diff --git a/tajo-plan/src/main/java/org/apache/tajo/plan/LogicalPlanner.java b/tajo-plan/src/main/java/org/apache/tajo/plan/LogicalPlanner.java index ef8663d..5011d87 100644 --- a/tajo-plan/src/main/java/org/apache/tajo/plan/LogicalPlanner.java +++ b/tajo-plan/src/main/java/org/apache/tajo/plan/LogicalPlanner.java @@ -36,11 +36,15 @@ import org.apache.tajo.algebra.*; import org.apache.tajo.algebra.WindowSpec; import org.apache.tajo.catalog.*; import org.apache.tajo.catalog.exception.UndefinedColumnException; +import org.apache.tajo.catalog.exception.UndefinedTableException; import org.apache.tajo.catalog.partition.PartitionMethodDesc; import org.apache.tajo.catalog.proto.CatalogProtos; import org.apache.tajo.common.TajoDataTypes; import org.apache.tajo.datum.NullDatum; import org.apache.tajo.exception.ExceptionUtil; +import org.apache.tajo.exception.TajoException; +import org.apache.tajo.exception.TajoInternalError; +import org.apache.tajo.exception.UnimplementedException; import org.apache.tajo.plan.LogicalPlan.QueryBlock; import org.apache.tajo.plan.algebra.BaseAlgebraVisitor; import org.apache.tajo.plan.expr.*; @@ -51,6 +55,7 @@ import org.apache.tajo.plan.rewrite.rules.ProjectionPushDownRule; import org.apache.tajo.plan.util.ExprFinder; import org.apache.tajo.plan.util.PlannerUtil; import org.apache.tajo.catalog.SchemaUtil; +import org.apache.tajo.plan.verifier.SyntaxErrorUtil; import org.apache.tajo.plan.verifier.VerifyException; import org.apache.tajo.storage.StorageService; import org.apache.tajo.util.KeyValueSet; @@ -64,6 +69,7 @@ import java.util.*; import static org.apache.tajo.algebra.CreateTable.PartitionType; import static org.apache.tajo.plan.ExprNormalizer.ExprNormalizedResult; import static org.apache.tajo.plan.LogicalPlan.BlockType; +import static org.apache.tajo.plan.verifier.SyntaxErrorUtil.makeSyntaxError; /** * This class creates a logical plan from a nested tajo algebra expression ({@link org.apache.tajo.algebra}) @@ -140,13 +146,12 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex * @param expr A relational algebraic expression for a query. * @return A logical plan */ - public LogicalPlan createPlan(OverridableConf context, Expr expr) throws PlanningException { + public LogicalPlan createPlan(OverridableConf context, Expr expr) throws TajoException { return createPlan(context, expr, false); } @VisibleForTesting - public LogicalPlan createPlan(OverridableConf queryContext, Expr expr, boolean debug) - throws PlanningException { + public LogicalPlan createPlan(OverridableConf queryContext, Expr expr, boolean debug) throws TajoException { LogicalPlan plan = new LogicalPlan(this); @@ -171,12 +176,12 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex return this.exprAnnotator; } - public void preHook(PlanContext context, Stack<Expr> stack, Expr expr) throws PlanningException { + public void preHook(PlanContext context, Stack<Expr> stack, Expr expr) throws TajoException { context.queryBlock.updateCurrentNode(expr); } public LogicalNode postHook(PlanContext context, Stack<Expr> stack, Expr expr, LogicalNode current) - throws PlanningException { + throws TajoException { // Some generated logical nodes (e.g., implicit aggregation) without exprs will pass NULL as a expr parameter. @@ -204,7 +209,7 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex } @Override - public LogicalNode visitSetSession(PlanContext context, Stack<Expr> stack, SetSession expr) throws PlanningException { + public LogicalNode visitSetSession(PlanContext context, Stack<Expr> stack, SetSession expr) throws TajoException { QueryBlock block = context.queryBlock; SetSessionNode setSessionNode = block.getNodeFromExpr(expr); @@ -213,7 +218,7 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex return setSessionNode; } - public LogicalNode visitExplain(PlanContext ctx, Stack<Expr> stack, Explain expr) throws PlanningException { + public LogicalNode visitExplain(PlanContext ctx, Stack<Expr> stack, Explain expr) throws TajoException { ctx.plan.setExplain(expr.isGlobal()); return visit(ctx, stack, expr.getChild()); } @@ -228,7 +233,7 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex ===============================================================================================*/ @Override public LogicalNode visitProjection(PlanContext context, Stack<Expr> stack, Projection projection) - throws PlanningException { + throws TajoException { LogicalPlan plan = context.plan; @@ -277,7 +282,7 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex projectionNode.setInSchema(child.getOutSchema()); if (projection.isDistinct() && block.hasNode(NodeType.GROUP_BY)) { - throw new VerifyException("Cannot support grouping and distinct at the same time yet"); + throw makeSyntaxError("Cannot support grouping and distinct at the same time yet"); } else { if (projection.isDistinct()) { insertDistinctOperator(context, projectionNode, child, stack); @@ -295,7 +300,7 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex } private void setRawTargets(PlanContext context, Target[] targets, String[] referenceNames, - Projection projection) throws PlanningException { + Projection projection) throws TajoException { LogicalPlan plan = context.plan; QueryBlock block = context.queryBlock; @@ -312,7 +317,7 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex } private void insertDistinctOperator(PlanContext context, ProjectionNode projectionNode, LogicalNode child, - Stack<Expr> stack) throws PlanningException { + Stack<Expr> stack) throws TajoException { LogicalPlan plan = context.plan; QueryBlock block = context.queryBlock; @@ -332,7 +337,7 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex private Pair<String [], ExprNormalizer.WindowSpecReferences []> doProjectionPrephase(PlanContext context, Projection projection) - throws PlanningException { + throws TajoException { QueryBlock block = context.queryBlock; @@ -373,7 +378,7 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex } public List<Integer> normalize(PlanContext context, Projection projection, ExprNormalizedResult [] normalizedExprList, - Matcher matcher) throws PlanningException { + Matcher matcher) throws TajoException { List<Integer> targetIds = new ArrayList<Integer>(); for (int i = 0; i < projection.size(); i++) { NamedExpr namedExpr = projection.getNamedExprs()[i]; @@ -406,7 +411,7 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex private void addNamedExprs(QueryBlock block, String [] referenceNames, ExprNormalizedResult [] normalizedExprList, List<ExprNormalizer.WindowSpecReferences> windowSpecReferencesList, Projection projection, - List<Integer> targetIds) throws PlanningException { + List<Integer> targetIds) throws TajoException { for (int i : targetIds) { NamedExpr namedExpr = projection.getNamedExprs()[i]; // Get all projecting references @@ -430,7 +435,7 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex * It builds non-from statement (only expressions) like '<code>SELECT 1+3 as plus</code>'. */ private EvalExprNode buildPlanForNoneFromStatement(PlanContext context, Stack<Expr> stack, Projection projection) - throws PlanningException { + throws TajoException { LogicalPlan plan = context.plan; QueryBlock block = context.queryBlock; @@ -455,7 +460,7 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex } private Target [] buildTargets(PlanContext context, String[] referenceNames) - throws PlanningException { + throws TajoException { QueryBlock block = context.queryBlock; Target [] targets = new Target[referenceNames.length]; @@ -483,9 +488,9 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex * * @param block QueryBlock which includes the Projectable node * @param projectable Projectable node to be valid - * @throws PlanningException + * @throws TajoException */ - public static void verifyProjectedFields(QueryBlock block, Projectable projectable) throws PlanningException { + public static void verifyProjectedFields(QueryBlock block, Projectable projectable) throws TajoException { if (projectable instanceof GroupbyNode) { GroupbyNode groupbyNode = (GroupbyNode) projectable; @@ -546,16 +551,16 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex } public static void prohibitNestedRecordProjection(Projectable projectable) - throws PlanningException { + throws TajoException { for (Target t : projectable.getTargets()) { if (t.getEvalTree().getValueType().getType() == TajoDataTypes.Type.RECORD) { - throw new PlanningException("Projecting RECORD fields is not supported yet: " + t); + throw new UnimplementedException("record field projection"); } } } public static void verifyIfEvalNodesCanBeEvaluated(Projectable projectable, EvalNode[] evalNodes) - throws PlanningException { + throws TajoException { for (EvalNode e : evalNodes) { Set<Column> columns = EvalTreeUtil.findUniqueColumns(e); for (Column c : columns) { @@ -567,7 +572,7 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex } public static void verifyIfTargetsCanBeEvaluated(Schema baseSchema, Projectable projectable) - throws PlanningException { + throws TajoException { for (Target target : projectable.getTargets()) { Set<Column> columns = EvalTreeUtil.findUniqueColumns(target.getEvalTree()); for (Column c : columns) { @@ -579,7 +584,7 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex } public static void verifyIfColumnCanBeEvaluated(Schema baseSchema, Projectable projectable, Column [] columns) - throws PlanningException { + throws TajoException { for (Column c : columns) { if (!baseSchema.contains(c)) { throwCannotEvaluateException(projectable, c.getQualifiedName()); @@ -587,13 +592,13 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex } } - public static void throwCannotEvaluateException(Projectable projectable, String columnName) throws PlanningException { + public static void throwCannotEvaluateException(Projectable projectable, String columnName) throws TajoException { if (projectable instanceof UnaryNode && ((UnaryNode) projectable).getChild().getType() == NodeType.GROUP_BY) { - throw new PlanningException(columnName + throw makeSyntaxError(columnName + " must appear in the GROUP BY clause or be used in an aggregate function at node (" + projectable.getPID() + ")"); } else { - throw new PlanningException(String.format("Cannot evaluate the field \"%s\" at node (%d)", + throw makeSyntaxError(String.format("Cannot evaluate the field \"%s\" at node (%d)", columnName, projectable.getPID())); } } @@ -601,7 +606,7 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex private LogicalNode insertWindowAggNode(PlanContext context, LogicalNode child, Stack<Expr> stack, String [] referenceNames, ExprNormalizer.WindowSpecReferences [] windowSpecReferenceses) - throws PlanningException { + throws TajoException { LogicalPlan plan = context.plan; QueryBlock block = context.queryBlock; WindowAggNode windowAggNode = context.plan.createNode(WindowAggNode.class); @@ -648,7 +653,7 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex if (block.namedExprsMgr.isEvaluated(partitionKey)) { partitionKeyColumns[i++] = block.namedExprsMgr.getTarget(partitionKey).getNamedColumn(); } else { - throw new PlanningException("Each grouping column expression must be a scalar expression."); + throw makeSyntaxError("Each grouping column expression must be a scalar expression."); } } windowAggNode.setPartitionKeys(partitionKeyColumns); @@ -738,7 +743,7 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex * It is used only when a group-by clause is not given. */ private LogicalNode insertGroupbyNode(PlanContext context, LogicalNode child, Stack<Expr> stack) - throws PlanningException { + throws TajoException { LogicalPlan plan = context.plan; QueryBlock block = context.queryBlock; @@ -792,7 +797,7 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex SORT SECTION ===============================================================================================*/ @Override - public LimitNode visitLimit(PlanContext context, Stack<Expr> stack, Limit limit) throws PlanningException { + public LimitNode visitLimit(PlanContext context, Stack<Expr> stack, Limit limit) throws TajoException { QueryBlock block = context.queryBlock; EvalNode firstFetNum; @@ -842,7 +847,7 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex } @Override - public LogicalNode visitSort(PlanContext context, Stack<Expr> stack, Sort sort) throws PlanningException { + public LogicalNode visitSort(PlanContext context, Stack<Expr> stack, Sort sort) throws TajoException { QueryBlock block = context.queryBlock; int sortKeyNum = sort.getSortSpecs().length; @@ -904,7 +909,7 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex ===============================================================================================*/ @Override - public LogicalNode visitHaving(PlanContext context, Stack<Expr> stack, Having expr) throws PlanningException { + public LogicalNode visitHaving(PlanContext context, Stack<Expr> stack, Having expr) throws TajoException { QueryBlock block = context.queryBlock; ExprNormalizedResult normalizedResult = normalizer.normalize(context, expr.getQual()); @@ -943,7 +948,7 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex @Override public LogicalNode visitGroupBy(PlanContext context, Stack<Expr> stack, Aggregation aggregation) - throws PlanningException { + throws TajoException { // Initialization Phase: LogicalPlan plan = context.plan; @@ -984,7 +989,7 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex } else if (block.namedExprsMgr.isEvaluated(groupingKeyRefNames[i])) { groupingColumns.add(block.namedExprsMgr.getTarget(groupingKeyRefNames[i]).getNamedColumn()); } else { - throw new PlanningException("Each grouping column expression must be a scalar expression."); + throw makeSyntaxError("Each grouping column expression must be a scalar expression."); } } @@ -1067,13 +1072,13 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex @Override public SelectionNode visitFilter(PlanContext context, Stack<Expr> stack, Selection selection) - throws PlanningException { + throws TajoException { QueryBlock block = context.queryBlock; ExprNormalizedResult normalizedResult = normalizer.normalize(context, selection.getQual()); block.namedExprsMgr.addExpr(normalizedResult.baseExpr); if (normalizedResult.aggExprs.size() > 0 || normalizedResult.scalarExprs.size() > 0) { - throw new VerifyException("Filter condition cannot include aggregation function"); + throw makeSyntaxError("Filter condition cannot include aggregation function"); } //////////////////////////////////////////////////////// @@ -1105,7 +1110,7 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex @Override public LogicalNode visitJoin(PlanContext context, Stack<Expr> stack, Join join) - throws PlanningException { + throws TajoException { // Phase 1: Init LogicalPlan plan = context.plan; QueryBlock block = context.queryBlock; @@ -1114,7 +1119,7 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex ExprNormalizedResult normalizedResult = normalizer.normalize(context, join.getQual(), true); block.namedExprsMgr.addExpr(normalizedResult.baseExpr); if (normalizedResult.aggExprs.size() > 0 || normalizedResult.scalarExprs.size() > 0) { - throw new VerifyException("Filter condition cannot include aggregation function"); + throw makeSyntaxError("Filter condition cannot include aggregation function"); } } @@ -1170,7 +1175,9 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex return joinNode; } - private List<String> getNewlyEvaluatedExprsForJoin(PlanContext context, JoinNode joinNode, boolean isTopMostJoin) { + private List<String> getNewlyEvaluatedExprsForJoin(PlanContext context, JoinNode joinNode, boolean isTopMostJoin) + throws TajoException { + QueryBlock block = context.queryBlock; EvalNode evalNode; @@ -1185,7 +1192,6 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex newlyEvaluatedExprs.add(namedExpr.getAlias()); } } catch (UndefinedColumnException ve) { - } catch (PlanningException e) { } } return newlyEvaluatedExprs; @@ -1235,7 +1241,7 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex } private LogicalNode createCartesianProduct(PlanContext context, LogicalNode left, LogicalNode right) - throws PlanningException { + throws TajoException { LogicalPlan plan = context.plan; QueryBlock block = context.queryBlock; @@ -1250,7 +1256,7 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex NamedExpr namedExpr = it.next(); try { evalNode = exprAnnotator.createEvalNode(context, namedExpr.getExpr(), NameResolvingMode.LEGACY); - if (EvalTreeUtil.findDistinctAggFunction(evalNode).size() == 0 + if (EvalTreeUtil.findDistinctAggFunction(evalNode).size() == 0 && EvalTreeUtil.findWindowFunction(evalNode).size() == 0) { block.namedExprsMgr.markAsEvaluated(namedExpr.getAlias(), evalNode); newlyEvaluatedExprs.add(namedExpr.getAlias()); @@ -1268,7 +1274,7 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex @Override public LogicalNode visitRelationList(PlanContext context, Stack<Expr> stack, RelationList relations) - throws PlanningException { + throws TajoException { LogicalNode current = visit(context, stack, relations.getRelations()[0]); @@ -1289,7 +1295,7 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex @Override public ScanNode visitRelation(PlanContext context, Stack<Expr> stack, Relation expr) - throws PlanningException { + throws TajoException { QueryBlock block = context.queryBlock; ScanNode scanNode = block.getNodeFromExpr(expr); @@ -1373,7 +1379,7 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex } public TableSubQueryNode visitTableSubQuery(PlanContext context, Stack<Expr> stack, TablePrimarySubQuery expr) - throws PlanningException { + throws TajoException { QueryBlock currentBlock = context.queryBlock; QueryBlock childBlock = context.plan.getBlock(context.plan.getBlockNameByExpr(expr.getSubQuery())); context.plan.connectBlocks(childBlock, currentBlock, BlockType.TableSubQuery); @@ -1388,7 +1394,7 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex return subQueryNode; } - private void setTargetOfTableSubQuery (PlanContext context, QueryBlock block, TableSubQueryNode subQueryNode) throws PlanningException { + private void setTargetOfTableSubQuery (PlanContext context, QueryBlock block, TableSubQueryNode subQueryNode) throws TajoException { // Add additional expressions required in upper nodes. Set<String> newlyEvaluatedExprs = TUtil.newHashSet(); for (NamedExpr rawTarget : block.namedExprsMgr.getAllNamedExprs()) { @@ -1419,7 +1425,7 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex @Override public LogicalNode visitUnion(PlanContext context, Stack<Expr> stack, SetOperation setOperation) - throws PlanningException { + throws TajoException { UnionNode unionNode = (UnionNode)buildSetPlan(context, stack, setOperation); LogicalNode resultingNode = unionNode; @@ -1445,7 +1451,7 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex return resultingNode; } - private ProjectionNode insertProjectionGroupbyBeforeSetOperation(PlanContext context, SetOperationNode setOperationNode) throws PlanningException { + private ProjectionNode insertProjectionGroupbyBeforeSetOperation(PlanContext context, SetOperationNode setOperationNode) throws TajoException { QueryBlock currentBlock = context.queryBlock; // make table subquery node which has set operation as its subquery @@ -1495,18 +1501,18 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex @Override public LogicalNode visitExcept(PlanContext context, Stack<Expr> stack, SetOperation setOperation) - throws PlanningException { + throws TajoException { return buildSetPlan(context, stack, setOperation); } @Override public LogicalNode visitIntersect(PlanContext context, Stack<Expr> stack, SetOperation setOperation) - throws PlanningException { + throws TajoException { return buildSetPlan(context, stack, setOperation); } private LogicalNode buildSetPlan(PlanContext context, Stack<Expr> stack, SetOperation setOperation) - throws PlanningException { + throws TajoException { // 1. Init Phase LogicalPlan plan = context.plan; @@ -1542,7 +1548,7 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex } else if (setOperation.getType() == OpType.Intersect) { setOp = block.getNodeFromExpr(setOperation); } else { - throw new VerifyException("Invalid Type: " + setOperation.getType()); + throw new TajoInternalError("Unknown set type: " + setOperation.getType()); } setOp.setLeftChild(leftChild); setOp.setRightChild(rightChild); @@ -1564,7 +1570,7 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex INSERT SECTION ===============================================================================================*/ - public LogicalNode visitInsert(PlanContext context, Stack<Expr> stack, Insert expr) throws PlanningException { + public LogicalNode visitInsert(PlanContext context, Stack<Expr> stack, Insert expr) throws TajoException { stack.push(expr); LogicalNode subQuery = super.visitInsert(context, stack, expr); stack.pop(); @@ -1596,7 +1602,7 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex * </pre> */ private InsertNode buildInsertIntoTablePlan(PlanContext context, InsertNode insertNode, Insert expr) - throws PlanningException { + throws TajoException { // Get and set a target table String databaseName; String tableName; @@ -1638,7 +1644,7 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex if (expr.hasTargetColumns()) { // when a user specified target columns if (expr.getTargetColumns().length > insertNode.getChild().getOutSchema().size()) { - throw new PlanningException("Target columns and projected columns are mismatched to each other"); + throw makeSyntaxError("Target columns and projected columns are mismatched to each other"); } // See PreLogicalPlanVerifier.visitInsert. @@ -1649,8 +1655,7 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex Column targetColumn = desc.getLogicalSchema().getColumn(targets[i]); if (targetColumn == null) { - throw new PlanningException("column \"" + targets[i] + "\" of relation \"" + - desc.getName() + "\" does not exist"); + throw makeSyntaxError("column '" + targets[i] + "' of relation '" + desc.getName() + "' does not exist"); } targetColumns.addColumn(targetColumn); @@ -1797,7 +1802,7 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex @Override public LogicalNode visitCreateDatabase(PlanContext context, Stack<Expr> stack, CreateDatabase expr) - throws PlanningException { + throws TajoException { CreateDatabaseNode createDatabaseNode = context.queryBlock.getNodeFromExpr(expr); createDatabaseNode.init(expr.getDatabaseName(), expr.isIfNotExists()); return createDatabaseNode; @@ -1805,40 +1810,42 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex @Override public LogicalNode visitDropDatabase(PlanContext context, Stack<Expr> stack, DropDatabase expr) - throws PlanningException { + throws TajoException { DropDatabaseNode dropDatabaseNode = context.queryBlock.getNodeFromExpr(expr); dropDatabaseNode.init(expr.getDatabaseName(), expr.isIfExists()); return dropDatabaseNode; } public LogicalNode handleCreateTableLike(PlanContext context, CreateTable expr, CreateTableNode createTableNode) - throws PlanningException { + throws TajoException { String parentTableName = expr.getLikeParentTableName(); if (CatalogUtil.isFQTableName(parentTableName) == false) { parentTableName = CatalogUtil.buildFQName(context.queryContext.get(SessionVars.CURRENT_DATABASE), parentTableName); } - TableDesc parentTableDesc = catalog.getTableDesc(parentTableName); - if(parentTableDesc == null) - throw new PlanningException("Table '"+parentTableName+"' does not exist"); - PartitionMethodDesc partitionDesc = parentTableDesc.getPartitionMethod(); - createTableNode.setTableSchema(parentTableDesc.getSchema()); + TableDesc baseTable = catalog.getTableDesc(parentTableName); + if(baseTable == null) { + throw new UndefinedTableException(parentTableName); + } + + PartitionMethodDesc partitionDesc = baseTable.getPartitionMethod(); + createTableNode.setTableSchema(baseTable.getSchema()); createTableNode.setPartitionMethod(partitionDesc); - createTableNode.setStorageType(parentTableDesc.getMeta().getStoreType()); - createTableNode.setOptions(parentTableDesc.getMeta().getOptions()); + createTableNode.setStorageType(baseTable.getMeta().getStoreType()); + createTableNode.setOptions(baseTable.getMeta().getOptions()); - createTableNode.setExternal(parentTableDesc.isExternal()); - if(parentTableDesc.isExternal()) { - createTableNode.setUri(parentTableDesc.getUri()); + createTableNode.setExternal(baseTable.isExternal()); + if(baseTable.isExternal()) { + createTableNode.setUri(baseTable.getUri()); } return createTableNode; } @Override public LogicalNode visitCreateTable(PlanContext context, Stack<Expr> stack, CreateTable expr) - throws PlanningException { + throws TajoException { CreateTableNode createTableNode = context.queryBlock.getNodeFromExpr(expr); createTableNode.setIfNotExists(expr.isIfNotExists()); @@ -1915,7 +1922,7 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex Schema partitionExpressionSchema = partitionMethod.getExpressionSchema(); if (partitionMethod.getPartitionType() == CatalogProtos.PartitionType.COLUMN && queryOutputSchema.size() < partitionExpressionSchema.size()) { - throw new VerifyException("Partition columns cannot be more than table columns."); + throw makeSyntaxError("Partition columns cannot be more than table columns."); } Schema tableSchema = new Schema(); for (int i = 0; i < queryOutputSchema.size() - partitionExpressionSchema.size(); i++) { @@ -1975,7 +1982,7 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex private PartitionMethodDesc getPartitionMethod(PlanContext context, String tableName, - CreateTable.PartitionMethodDescExpr expr) throws PlanningException { + CreateTable.PartitionMethodDescExpr expr) throws TajoException { PartitionMethodDesc partitionMethodDesc; if(expr.getPartitionType() == PartitionType.COLUMN) { @@ -1985,7 +1992,7 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex partitionMethodDesc = new PartitionMethodDesc(context.queryContext.get(SessionVars.CURRENT_DATABASE), tableName, CatalogProtos.PartitionType.COLUMN, partitionExpression, convertColumnsToSchema(partition.getColumns())); } else { - throw new PlanningException(String.format("Not supported PartitonType: %s", expr.getPartitionType())); + throw new UnimplementedException("partition type '" + expr.getPartitionType() + "'"); } return partitionMethodDesc; } @@ -2141,7 +2148,7 @@ public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContex @Override public LogicalNode visitTruncateTable(PlanContext context, Stack<Expr> stack, TruncateTable truncateTable) - throws PlanningException { + throws TajoException { TruncateTableNode truncateTableNode = context.queryBlock.getNodeFromExpr(truncateTable); truncateTableNode.setTableNames(truncateTable.getTableNames()); return truncateTableNode; http://git-wip-us.apache.org/repos/asf/tajo/blob/4841c656/tajo-plan/src/main/java/org/apache/tajo/plan/NamedExprsManager.java ---------------------------------------------------------------------- diff --git a/tajo-plan/src/main/java/org/apache/tajo/plan/NamedExprsManager.java b/tajo-plan/src/main/java/org/apache/tajo/plan/NamedExprsManager.java index 991860f..08a9bd1 100644 --- a/tajo-plan/src/main/java/org/apache/tajo/plan/NamedExprsManager.java +++ b/tajo-plan/src/main/java/org/apache/tajo/plan/NamedExprsManager.java @@ -142,7 +142,7 @@ public class NamedExprsManager { /** * Adds an expression and returns a reference name. */ - public String addExpr(Expr expr) throws PlanningException { + public String addExpr(Expr expr) { if (idToExprBiMap.inverse().containsKey(expr)) { int refId = idToExprBiMap.inverse().get(expr); return idToNamesMap.get(refId).get(0); @@ -160,7 +160,7 @@ public class NamedExprsManager { * Adds an expression with an alias name and returns a reference name. * It specifies the alias as an reference name. */ - public String addExpr(Expr expr, String alias) throws PlanningException { + public String addExpr(Expr expr, String alias) { if (OpType.isLiteralType(expr.getType())) { return alias; @@ -193,7 +193,7 @@ public class NamedExprsManager { * Adds an expression and returns a reference name. * If an alias is given, it specifies the alias as an reference name. */ - public String addNamedExpr(NamedExpr namedExpr) throws PlanningException { + public String addNamedExpr(NamedExpr namedExpr) { if (namedExpr.hasAlias()) { return addExpr(namedExpr.getExpr(), namedExpr.getAlias()); } else { @@ -205,7 +205,7 @@ public class NamedExprsManager { * Adds a list of expressions and returns a list of reference names. * If some NamedExpr has an alias, NamedExprsManager specifies the alias for the NamedExpr. */ - public String [] addNamedExprArray(@Nullable Collection<NamedExpr> namedExprs) throws PlanningException { + public String [] addNamedExprArray(@Nullable Collection<NamedExpr> namedExprs) { if (namedExprs != null && namedExprs.size() > 0) { String [] names = new String[namedExprs.size()]; int i = 0; @@ -233,7 +233,7 @@ public class NamedExprsManager { * @param referenceName The reference name to be marked as 'evaluated'. * @param evalNode EvalNode to be added. */ - public void markAsEvaluated(String referenceName, EvalNode evalNode) throws PlanningException { + public void markAsEvaluated(String referenceName, EvalNode evalNode) { String normalized = referenceName; int refId = nameToIdMap.get(normalized); http://git-wip-us.apache.org/repos/asf/tajo/blob/4841c656/tajo-plan/src/main/java/org/apache/tajo/plan/TypeDeterminant.java ---------------------------------------------------------------------- diff --git a/tajo-plan/src/main/java/org/apache/tajo/plan/TypeDeterminant.java b/tajo-plan/src/main/java/org/apache/tajo/plan/TypeDeterminant.java index 83542ec..a526efc 100644 --- a/tajo-plan/src/main/java/org/apache/tajo/plan/TypeDeterminant.java +++ b/tajo-plan/src/main/java/org/apache/tajo/plan/TypeDeterminant.java @@ -28,6 +28,8 @@ import org.apache.tajo.catalog.FunctionDesc; import org.apache.tajo.catalog.exception.UndefinedFunctionException; import org.apache.tajo.catalog.proto.CatalogProtos; import org.apache.tajo.common.TajoDataTypes; +import org.apache.tajo.exception.TajoException; +import org.apache.tajo.exception.TajoInternalError; import org.apache.tajo.plan.visitor.SimpleAlgebraVisitor; import java.util.Stack; @@ -44,13 +46,13 @@ public class TypeDeterminant extends SimpleAlgebraVisitor<LogicalPlanner.PlanCon this.catalog = catalog; } - public DataType determineDataType(LogicalPlanner.PlanContext ctx, Expr expr) throws PlanningException { + public DataType determineDataType(LogicalPlanner.PlanContext ctx, Expr expr) throws TajoException { return visit(ctx, new Stack<Expr>(), expr); } @Override public DataType visitUnaryOperator(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, UnaryOperator expr) - throws PlanningException { + throws TajoException { stack.push(expr); DataType dataType = null; switch (expr.getType()) { @@ -70,7 +72,7 @@ public class TypeDeterminant extends SimpleAlgebraVisitor<LogicalPlanner.PlanCon @Override public DataType visitBinaryOperator(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, BinaryOperator expr) - throws PlanningException { + throws TajoException { stack.push(expr); DataType lhsType = visit(ctx, stack, expr.getLeft()); DataType rhsType = visit(ctx, stack, expr.getRight()); @@ -78,7 +80,7 @@ public class TypeDeterminant extends SimpleAlgebraVisitor<LogicalPlanner.PlanCon return computeBinaryType(expr.getType(), lhsType, rhsType); } - public DataType computeBinaryType(OpType type, DataType lhsDataType, DataType rhsDataType) throws PlanningException { + public DataType computeBinaryType(OpType type, DataType lhsDataType, DataType rhsDataType) throws TajoException { Preconditions.checkNotNull(type); Preconditions.checkNotNull(lhsDataType); Preconditions.checkNotNull(rhsDataType); @@ -94,7 +96,7 @@ public class TypeDeterminant extends SimpleAlgebraVisitor<LogicalPlanner.PlanCon } else if (type == OpType.LikePredicate || type == OpType.SimilarToPredicate || type == OpType.Regexp) { return BOOL_TYPE; } else { - throw new PlanningException(type.name() + "is not binary type"); + throw new TajoInternalError(type.name() + "is not binary type"); } } @@ -104,13 +106,13 @@ public class TypeDeterminant extends SimpleAlgebraVisitor<LogicalPlanner.PlanCon @Override public DataType visitBetween(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, BetweenPredicate expr) - throws PlanningException { + throws TajoException { return CatalogUtil.newSimpleDataType(BOOLEAN); } @Override public DataType visitCaseWhen(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, CaseWhenPredicate caseWhen) - throws PlanningException { + throws TajoException { DataType lastDataType = null; for (CaseWhenPredicate.WhenExpr when : caseWhen.getWhens()) { @@ -136,7 +138,7 @@ public class TypeDeterminant extends SimpleAlgebraVisitor<LogicalPlanner.PlanCon @Override public DataType visitColumnReference(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, ColumnReferenceExpr expr) - throws PlanningException { + throws TajoException { stack.push(expr); Column column = ctx.plan.resolveColumn(ctx.queryBlock, expr); stack.pop(); @@ -149,7 +151,7 @@ public class TypeDeterminant extends SimpleAlgebraVisitor<LogicalPlanner.PlanCon @Override public DataType visitFunction(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, FunctionExpr expr) - throws PlanningException { + throws TajoException { stack.push(expr); // <--- Push // Given parameters @@ -178,7 +180,7 @@ public class TypeDeterminant extends SimpleAlgebraVisitor<LogicalPlanner.PlanCon @Override public DataType visitCountRowsFunction(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, CountRowsFunctionExpr expr) - throws PlanningException { + throws TajoException { FunctionDesc countRows = catalog.getFunction("count", CatalogProtos.FunctionType.AGGREGATION, new DataType[] {}); return countRows.getReturnType(); @@ -186,7 +188,7 @@ public class TypeDeterminant extends SimpleAlgebraVisitor<LogicalPlanner.PlanCon @Override public DataType visitGeneralSetFunction(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, - GeneralSetFunctionExpr setFunction) throws PlanningException { + GeneralSetFunctionExpr setFunction) throws TajoException { stack.push(setFunction); Expr[] params = setFunction.getParams(); @@ -214,7 +216,7 @@ public class TypeDeterminant extends SimpleAlgebraVisitor<LogicalPlanner.PlanCon @Override public DataType visitWindowFunction(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, WindowFunctionExpr windowFunc) - throws PlanningException { + throws TajoException { stack.push(windowFunc); // <--- Push String funcName = windowFunc.getSignature(); @@ -269,13 +271,13 @@ public class TypeDeterminant extends SimpleAlgebraVisitor<LogicalPlanner.PlanCon @Override public DataType visitDataType(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, DataTypeExpr expr) - throws PlanningException { + throws TajoException { return LogicalPlanner.convertDataType(expr).getDataType(); } @Override public DataType visitLiteral(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, LiteralValue expr) - throws PlanningException { + throws TajoException { // It must be the same to ExprAnnotator::visitLiteral. switch (expr.getValueType()) { @@ -296,31 +298,31 @@ public class TypeDeterminant extends SimpleAlgebraVisitor<LogicalPlanner.PlanCon @Override public DataType visitNullLiteral(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, NullLiteral expr) - throws PlanningException { + throws TajoException { return CatalogUtil.newSimpleDataType(NULL_TYPE); } @Override public DataType visitTimestampLiteral(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, TimestampLiteral expr) - throws PlanningException { + throws TajoException { return CatalogUtil.newSimpleDataType(TajoDataTypes.Type.TIMESTAMP); } @Override public DataType visitTimeLiteral(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, TimeLiteral expr) - throws PlanningException { + throws TajoException { return CatalogUtil.newSimpleDataType(TajoDataTypes.Type.TIME); } @Override public DataType visitDateLiteral(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, DateLiteral expr) - throws PlanningException { + throws TajoException { return CatalogUtil.newSimpleDataType(TajoDataTypes.Type.DATE); } @Override public DataType visitIntervalLiteral(LogicalPlanner.PlanContext ctx, Stack<Expr> stack, IntervalLiteral expr) - throws PlanningException { + throws TajoException { return CatalogUtil.newSimpleDataType(TajoDataTypes.Type.INTERVAL); } } http://git-wip-us.apache.org/repos/asf/tajo/blob/4841c656/tajo-plan/src/main/java/org/apache/tajo/plan/algebra/AlgebraVisitor.java ---------------------------------------------------------------------- diff --git a/tajo-plan/src/main/java/org/apache/tajo/plan/algebra/AlgebraVisitor.java b/tajo-plan/src/main/java/org/apache/tajo/plan/algebra/AlgebraVisitor.java index 1ac12c2..942dbb9 100644 --- a/tajo-plan/src/main/java/org/apache/tajo/plan/algebra/AlgebraVisitor.java +++ b/tajo-plan/src/main/java/org/apache/tajo/plan/algebra/AlgebraVisitor.java @@ -19,99 +19,99 @@ package org.apache.tajo.plan.algebra; import org.apache.tajo.algebra.*; -import org.apache.tajo.plan.PlanningException; +import org.apache.tajo.exception.TajoException; import java.util.Stack; public interface AlgebraVisitor<CONTEXT, RESULT> { // Relational Operators - RESULT visitSetSession(CONTEXT ctx, Stack<Expr> stack, SetSession expr) throws PlanningException; + RESULT visitSetSession(CONTEXT ctx, Stack<Expr> stack, SetSession expr) throws TajoException; // Relational Operators - RESULT visitProjection(CONTEXT ctx, Stack<Expr> stack, Projection expr) throws PlanningException; - RESULT visitLimit(CONTEXT ctx, Stack<Expr> stack, Limit expr) throws PlanningException; - RESULT visitSort(CONTEXT ctx, Stack<Expr> stack, Sort expr) throws PlanningException; - RESULT visitHaving(CONTEXT ctx, Stack<Expr> stack, Having expr) throws PlanningException; - RESULT visitGroupBy(CONTEXT ctx, Stack<Expr> stack, Aggregation expr) throws PlanningException; - RESULT visitJoin(CONTEXT ctx, Stack<Expr> stack, Join expr) throws PlanningException; - RESULT visitFilter(CONTEXT ctx, Stack<Expr> stack, Selection expr) throws PlanningException; - RESULT visitUnion(CONTEXT ctx, Stack<Expr> stack, SetOperation expr) throws PlanningException; - RESULT visitExcept(CONTEXT ctx, Stack<Expr> stack, SetOperation expr) throws PlanningException; - RESULT visitIntersect(CONTEXT ctx, Stack<Expr> stack, SetOperation expr) throws PlanningException; - RESULT visitSimpleTableSubQuery(CONTEXT ctx, Stack<Expr> stack, SimpleTableSubQuery expr) throws PlanningException; - RESULT visitTableSubQuery(CONTEXT ctx, Stack<Expr> stack, TablePrimarySubQuery expr) throws PlanningException; - RESULT visitRelationList(CONTEXT ctx, Stack<Expr> stack, RelationList expr) throws PlanningException; - RESULT visitRelation(CONTEXT ctx, Stack<Expr> stack, Relation expr) throws PlanningException; - RESULT visitScalarSubQuery(CONTEXT ctx, Stack<Expr> stack, ScalarSubQuery expr) throws PlanningException; - RESULT visitExplain(CONTEXT ctx, Stack<Expr> stack, Explain expr) throws PlanningException; + RESULT visitProjection(CONTEXT ctx, Stack<Expr> stack, Projection expr) throws TajoException; + RESULT visitLimit(CONTEXT ctx, Stack<Expr> stack, Limit expr) throws TajoException; + RESULT visitSort(CONTEXT ctx, Stack<Expr> stack, Sort expr) throws TajoException; + RESULT visitHaving(CONTEXT ctx, Stack<Expr> stack, Having expr) throws TajoException; + RESULT visitGroupBy(CONTEXT ctx, Stack<Expr> stack, Aggregation expr) throws TajoException; + RESULT visitJoin(CONTEXT ctx, Stack<Expr> stack, Join expr) throws TajoException; + RESULT visitFilter(CONTEXT ctx, Stack<Expr> stack, Selection expr) throws TajoException; + RESULT visitUnion(CONTEXT ctx, Stack<Expr> stack, SetOperation expr) throws TajoException; + RESULT visitExcept(CONTEXT ctx, Stack<Expr> stack, SetOperation expr) throws TajoException; + RESULT visitIntersect(CONTEXT ctx, Stack<Expr> stack, SetOperation expr) throws TajoException; + RESULT visitSimpleTableSubQuery(CONTEXT ctx, Stack<Expr> stack, SimpleTableSubQuery expr) throws TajoException; + RESULT visitTableSubQuery(CONTEXT ctx, Stack<Expr> stack, TablePrimarySubQuery expr) throws TajoException; + RESULT visitRelationList(CONTEXT ctx, Stack<Expr> stack, RelationList expr) throws TajoException; + RESULT visitRelation(CONTEXT ctx, Stack<Expr> stack, Relation expr) throws TajoException; + RESULT visitScalarSubQuery(CONTEXT ctx, Stack<Expr> stack, ScalarSubQuery expr) throws TajoException; + RESULT visitExplain(CONTEXT ctx, Stack<Expr> stack, Explain expr) throws TajoException; // Data definition language - RESULT visitCreateDatabase(CONTEXT ctx, Stack<Expr> stack, CreateDatabase expr) throws PlanningException; - RESULT visitDropDatabase(CONTEXT ctx, Stack<Expr> stack, DropDatabase expr) throws PlanningException; - RESULT visitCreateTable(CONTEXT ctx, Stack<Expr> stack, CreateTable expr) throws PlanningException; - RESULT visitDropTable(CONTEXT ctx, Stack<Expr> stack, DropTable expr) throws PlanningException; - RESULT visitAlterTablespace(CONTEXT ctx, Stack<Expr> stack, AlterTablespace expr) throws PlanningException; - RESULT visitAlterTable(CONTEXT ctx, Stack<Expr> stack, AlterTable expr) throws PlanningException; - RESULT visitTruncateTable(CONTEXT ctx, Stack<Expr> stack, TruncateTable expr) throws PlanningException; + RESULT visitCreateDatabase(CONTEXT ctx, Stack<Expr> stack, CreateDatabase expr) throws TajoException; + RESULT visitDropDatabase(CONTEXT ctx, Stack<Expr> stack, DropDatabase expr) throws TajoException; + RESULT visitCreateTable(CONTEXT ctx, Stack<Expr> stack, CreateTable expr) throws TajoException; + RESULT visitDropTable(CONTEXT ctx, Stack<Expr> stack, DropTable expr) throws TajoException; + RESULT visitAlterTablespace(CONTEXT ctx, Stack<Expr> stack, AlterTablespace expr) throws TajoException; + RESULT visitAlterTable(CONTEXT ctx, Stack<Expr> stack, AlterTable expr) throws TajoException; + RESULT visitTruncateTable(CONTEXT ctx, Stack<Expr> stack, TruncateTable expr) throws TajoException; // Insert or Update - RESULT visitInsert(CONTEXT ctx, Stack<Expr> stack, Insert expr) throws PlanningException; + RESULT visitInsert(CONTEXT ctx, Stack<Expr> stack, Insert expr) throws TajoException; // Logical operators - RESULT visitAnd(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws PlanningException; - RESULT visitOr(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws PlanningException; - RESULT visitNot(CONTEXT ctx, Stack<Expr> stack, NotExpr expr) throws PlanningException; + RESULT visitAnd(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws TajoException; + RESULT visitOr(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws TajoException; + RESULT visitNot(CONTEXT ctx, Stack<Expr> stack, NotExpr expr) throws TajoException; // comparison predicates - RESULT visitEquals(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws PlanningException; - RESULT visitNotEquals(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws PlanningException; - RESULT visitLessThan(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws PlanningException; - RESULT visitLessThanOrEquals(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws PlanningException; - RESULT visitGreaterThan(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws PlanningException; - RESULT visitGreaterThanOrEquals(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws PlanningException; + RESULT visitEquals(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws TajoException; + RESULT visitNotEquals(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws TajoException; + RESULT visitLessThan(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws TajoException; + RESULT visitLessThanOrEquals(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws TajoException; + RESULT visitGreaterThan(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws TajoException; + RESULT visitGreaterThanOrEquals(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws TajoException; // Other Predicates - RESULT visitBetween(CONTEXT ctx, Stack<Expr> stack, BetweenPredicate expr) throws PlanningException; - RESULT visitCaseWhen(CONTEXT ctx, Stack<Expr> stack, CaseWhenPredicate expr) throws PlanningException; - RESULT visitIsNullPredicate(CONTEXT ctx, Stack<Expr> stack, IsNullPredicate expr) throws PlanningException; - RESULT visitInPredicate(CONTEXT ctx, Stack<Expr> stack, InPredicate expr) throws PlanningException; - RESULT visitValueListExpr(CONTEXT ctx, Stack<Expr> stack, ValueListExpr expr) throws PlanningException; - RESULT visitExistsPredicate(CONTEXT ctx, Stack<Expr> stack, ExistsPredicate expr) throws PlanningException; + RESULT visitBetween(CONTEXT ctx, Stack<Expr> stack, BetweenPredicate expr) throws TajoException; + RESULT visitCaseWhen(CONTEXT ctx, Stack<Expr> stack, CaseWhenPredicate expr) throws TajoException; + RESULT visitIsNullPredicate(CONTEXT ctx, Stack<Expr> stack, IsNullPredicate expr) throws TajoException; + RESULT visitInPredicate(CONTEXT ctx, Stack<Expr> stack, InPredicate expr) throws TajoException; + RESULT visitValueListExpr(CONTEXT ctx, Stack<Expr> stack, ValueListExpr expr) throws TajoException; + RESULT visitExistsPredicate(CONTEXT ctx, Stack<Expr> stack, ExistsPredicate expr) throws TajoException; // String Operator or Pattern Matching Predicates - RESULT visitLikePredicate(CONTEXT ctx, Stack<Expr> stack, PatternMatchPredicate expr) throws PlanningException; - RESULT visitSimilarToPredicate(CONTEXT ctx, Stack<Expr> stack, PatternMatchPredicate expr) throws PlanningException; - RESULT visitRegexpPredicate(CONTEXT ctx, Stack<Expr> stack, PatternMatchPredicate expr) throws PlanningException; - RESULT visitConcatenate(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws PlanningException; + RESULT visitLikePredicate(CONTEXT ctx, Stack<Expr> stack, PatternMatchPredicate expr) throws TajoException; + RESULT visitSimilarToPredicate(CONTEXT ctx, Stack<Expr> stack, PatternMatchPredicate expr) throws TajoException; + RESULT visitRegexpPredicate(CONTEXT ctx, Stack<Expr> stack, PatternMatchPredicate expr) throws TajoException; + RESULT visitConcatenate(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws TajoException; // arithmetic operators - RESULT visitPlus(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws PlanningException; - RESULT visitMinus(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws PlanningException; - RESULT visitMultiply(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws PlanningException; - RESULT visitDivide(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws PlanningException; - RESULT visitModular(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws PlanningException; + RESULT visitPlus(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws TajoException; + RESULT visitMinus(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws TajoException; + RESULT visitMultiply(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws TajoException; + RESULT visitDivide(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws TajoException; + RESULT visitModular(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws TajoException; // other expressions - RESULT visitSign(CONTEXT ctx, Stack<Expr> stack, SignedExpr expr) throws PlanningException; - RESULT visitColumnReference(CONTEXT ctx, Stack<Expr> stack, ColumnReferenceExpr expr) throws PlanningException; - RESULT visitTargetExpr(CONTEXT ctx, Stack<Expr> stack, NamedExpr expr) throws PlanningException; - RESULT visitQualifiedAsterisk(CONTEXT ctx, Stack<Expr> stack, QualifiedAsteriskExpr expr) throws PlanningException; + RESULT visitSign(CONTEXT ctx, Stack<Expr> stack, SignedExpr expr) throws TajoException; + RESULT visitColumnReference(CONTEXT ctx, Stack<Expr> stack, ColumnReferenceExpr expr) throws TajoException; + RESULT visitTargetExpr(CONTEXT ctx, Stack<Expr> stack, NamedExpr expr) throws TajoException; + RESULT visitQualifiedAsterisk(CONTEXT ctx, Stack<Expr> stack, QualifiedAsteriskExpr expr) throws TajoException; // functions - RESULT visitFunction(CONTEXT ctx, Stack<Expr> stack, FunctionExpr expr) throws PlanningException; + RESULT visitFunction(CONTEXT ctx, Stack<Expr> stack, FunctionExpr expr) throws TajoException; RESULT visitGeneralSetFunction(CONTEXT ctx, Stack<Expr> stack, GeneralSetFunctionExpr expr) - throws PlanningException; - RESULT visitCountRowsFunction(CONTEXT ctx, Stack<Expr> stack, CountRowsFunctionExpr expr) throws PlanningException; - RESULT visitWindowFunction(CONTEXT ctx, Stack<Expr> stack, WindowFunctionExpr expr) throws PlanningException; + throws TajoException; + RESULT visitCountRowsFunction(CONTEXT ctx, Stack<Expr> stack, CountRowsFunctionExpr expr) throws TajoException; + RESULT visitWindowFunction(CONTEXT ctx, Stack<Expr> stack, WindowFunctionExpr expr) throws TajoException; // Literal - RESULT visitCastExpr(CONTEXT ctx, Stack<Expr> stack, CastExpr expr) throws PlanningException; - - RESULT visitDataType(CONTEXT ctx, Stack<Expr> stack, DataTypeExpr expr) throws PlanningException; - RESULT visitLiteral(CONTEXT ctx, Stack<Expr> stack, LiteralValue expr) throws PlanningException; - RESULT visitNullLiteral(CONTEXT ctx, Stack<Expr> stack, NullLiteral expr) throws PlanningException; - RESULT visitTimestampLiteral(CONTEXT ctx, Stack<Expr> stack, TimestampLiteral expr) throws PlanningException; - RESULT visitIntervalLiteral(CONTEXT ctx, Stack<Expr> stack, IntervalLiteral expr) throws PlanningException; - RESULT visitTimeLiteral(CONTEXT ctx, Stack<Expr> stack, TimeLiteral expr) throws PlanningException; - RESULT visitDateLiteral(CONTEXT ctx, Stack<Expr> stack, DateLiteral expr) throws PlanningException; + RESULT visitCastExpr(CONTEXT ctx, Stack<Expr> stack, CastExpr expr) throws TajoException; + + RESULT visitDataType(CONTEXT ctx, Stack<Expr> stack, DataTypeExpr expr) throws TajoException; + RESULT visitLiteral(CONTEXT ctx, Stack<Expr> stack, LiteralValue expr) throws TajoException; + RESULT visitNullLiteral(CONTEXT ctx, Stack<Expr> stack, NullLiteral expr) throws TajoException; + RESULT visitTimestampLiteral(CONTEXT ctx, Stack<Expr> stack, TimestampLiteral expr) throws TajoException; + RESULT visitIntervalLiteral(CONTEXT ctx, Stack<Expr> stack, IntervalLiteral expr) throws TajoException; + RESULT visitTimeLiteral(CONTEXT ctx, Stack<Expr> stack, TimeLiteral expr) throws TajoException; + RESULT visitDateLiteral(CONTEXT ctx, Stack<Expr> stack, DateLiteral expr) throws TajoException; } http://git-wip-us.apache.org/repos/asf/tajo/blob/4841c656/tajo-plan/src/main/java/org/apache/tajo/plan/algebra/AmbiguousFieldException.java ---------------------------------------------------------------------- diff --git a/tajo-plan/src/main/java/org/apache/tajo/plan/algebra/AmbiguousFieldException.java b/tajo-plan/src/main/java/org/apache/tajo/plan/algebra/AmbiguousFieldException.java deleted file mode 100644 index ea3081c..0000000 --- a/tajo-plan/src/main/java/org/apache/tajo/plan/algebra/AmbiguousFieldException.java +++ /dev/null @@ -1,32 +0,0 @@ -/** - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.apache.tajo.plan.algebra; - -import org.apache.tajo.plan.InvalidQueryException; - -public class AmbiguousFieldException extends InvalidQueryException { - private static final long serialVersionUID = 3102675985226352347L; - - /** - * @param fieldName - */ - public AmbiguousFieldException(String fieldName) { - super("ERROR: column name "+ fieldName + " is ambiguous"); - } -}
