http://git-wip-us.apache.org/repos/asf/tajo/blob/4841c656/tajo-plan/src/main/java/org/apache/tajo/plan/algebra/BaseAlgebraVisitor.java ---------------------------------------------------------------------- diff --git a/tajo-plan/src/main/java/org/apache/tajo/plan/algebra/BaseAlgebraVisitor.java b/tajo-plan/src/main/java/org/apache/tajo/plan/algebra/BaseAlgebraVisitor.java index eb11f33..e32bd85 100644 --- a/tajo-plan/src/main/java/org/apache/tajo/plan/algebra/BaseAlgebraVisitor.java +++ b/tajo-plan/src/main/java/org/apache/tajo/plan/algebra/BaseAlgebraVisitor.java @@ -19,7 +19,8 @@ package org.apache.tajo.plan.algebra; import org.apache.tajo.algebra.*; -import org.apache.tajo.plan.PlanningException; +import org.apache.tajo.exception.TajoException; +import org.apache.tajo.exception.TajoInternalError; import java.util.Stack; @@ -28,14 +29,14 @@ public class BaseAlgebraVisitor<CONTEXT, RESULT> implements AlgebraVisitor<CONTE /** * The prehook is called before each expression is visited. */ - public void preHook(CONTEXT ctx, Stack<Expr> stack, Expr expr) throws PlanningException { + public void preHook(CONTEXT ctx, Stack<Expr> stack, Expr expr) throws TajoException { } /** * The posthook is called before each expression is visited. */ - public RESULT postHook(CONTEXT ctx, Stack<Expr> stack, Expr expr, RESULT current) throws PlanningException { + public RESULT postHook(CONTEXT ctx, Stack<Expr> stack, Expr expr, RESULT current) throws TajoException { return current; } @@ -45,7 +46,7 @@ public class BaseAlgebraVisitor<CONTEXT, RESULT> implements AlgebraVisitor<CONTE * @param stack The stack contains the upper operators' type. * @param expr The visiting relational operator */ - public RESULT visit(CONTEXT ctx, Stack<Expr> stack, Expr expr) throws PlanningException { + public RESULT visit(CONTEXT ctx, Stack<Expr> stack, Expr expr) throws TajoException { preHook(ctx, stack, expr); RESULT current; @@ -264,9 +265,8 @@ public class BaseAlgebraVisitor<CONTEXT, RESULT> implements AlgebraVisitor<CONTE current = visitIntervalLiteral(ctx, stack, (IntervalLiteral) expr); break; - default: - throw new PlanningException("Cannot support this type algebra \"" + expr.getType() + "\""); + throw new TajoInternalError("Cannot support this type algebra \"" + expr.getType() + "\""); } // skip postHook against only one relation @@ -281,7 +281,7 @@ public class BaseAlgebraVisitor<CONTEXT, RESULT> implements AlgebraVisitor<CONTE return current; } - private RESULT visitDefaultUnaryExpr(CONTEXT ctx, Stack<Expr> stack, UnaryOperator expr) throws PlanningException { + private RESULT visitDefaultUnaryExpr(CONTEXT ctx, Stack<Expr> stack, UnaryOperator expr) throws TajoException { stack.push(expr); RESULT child = visit(ctx, stack, expr.getChild()); stack.pop(); @@ -289,7 +289,7 @@ public class BaseAlgebraVisitor<CONTEXT, RESULT> implements AlgebraVisitor<CONTE } private RESULT visitDefaultBinaryExpr(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) - throws PlanningException { + throws TajoException { stack.push(expr); RESULT child = visit(ctx, stack, expr.getLeft()); visit(ctx, stack, expr.getRight()); @@ -298,12 +298,12 @@ public class BaseAlgebraVisitor<CONTEXT, RESULT> implements AlgebraVisitor<CONTE } @Override - public RESULT visitSetSession(CONTEXT ctx, Stack<Expr> stack, SetSession expr) throws PlanningException { + public RESULT visitSetSession(CONTEXT ctx, Stack<Expr> stack, SetSession expr) throws TajoException { return null; } @Override - public RESULT visitProjection(CONTEXT ctx, Stack<Expr> stack, Projection expr) throws PlanningException { + public RESULT visitProjection(CONTEXT ctx, Stack<Expr> stack, Projection expr) throws TajoException { stack.push(expr); try { for (NamedExpr target : expr.getNamedExprs()) { @@ -319,7 +319,7 @@ public class BaseAlgebraVisitor<CONTEXT, RESULT> implements AlgebraVisitor<CONTE } @Override - public RESULT visitLimit(CONTEXT ctx, Stack<Expr> stack, Limit expr) throws PlanningException { + public RESULT visitLimit(CONTEXT ctx, Stack<Expr> stack, Limit expr) throws TajoException { stack.push(expr); visit(ctx, stack, expr.getFetchFirstNum()); RESULT result = visit(ctx, stack, expr.getChild()); @@ -328,7 +328,7 @@ public class BaseAlgebraVisitor<CONTEXT, RESULT> implements AlgebraVisitor<CONTE } @Override - public RESULT visitSort(CONTEXT ctx, Stack<Expr> stack, Sort expr) throws PlanningException { + public RESULT visitSort(CONTEXT ctx, Stack<Expr> stack, Sort expr) throws TajoException { stack.push(expr); for (Sort.SortSpec sortSpec : expr.getSortSpecs()) { visit(ctx, stack, sortSpec.getKey()); @@ -338,7 +338,7 @@ public class BaseAlgebraVisitor<CONTEXT, RESULT> implements AlgebraVisitor<CONTE } @Override - public RESULT visitHaving(CONTEXT ctx, Stack<Expr> stack, Having expr) throws PlanningException { + public RESULT visitHaving(CONTEXT ctx, Stack<Expr> stack, Having expr) throws TajoException { stack.push(expr); visit(ctx, stack, expr.getQual()); RESULT result = visit(ctx, stack, expr.getChild()); @@ -347,7 +347,7 @@ public class BaseAlgebraVisitor<CONTEXT, RESULT> implements AlgebraVisitor<CONTE } @Override - public RESULT visitGroupBy(CONTEXT ctx, Stack<Expr> stack, Aggregation expr) throws PlanningException { + public RESULT visitGroupBy(CONTEXT ctx, Stack<Expr> stack, Aggregation expr) throws TajoException { stack.push(expr); for (org.apache.tajo.algebra.Aggregation.GroupElement groupElement : expr.getGroupSet()) { @@ -362,7 +362,7 @@ public class BaseAlgebraVisitor<CONTEXT, RESULT> implements AlgebraVisitor<CONTE } @Override - public RESULT visitJoin(CONTEXT ctx, Stack<Expr> stack, Join expr) throws PlanningException { + public RESULT visitJoin(CONTEXT ctx, Stack<Expr> stack, Join expr) throws TajoException { stack.push(expr); if (expr.getQual() != null) { visit(ctx, stack, expr.getQual()); @@ -374,7 +374,7 @@ public class BaseAlgebraVisitor<CONTEXT, RESULT> implements AlgebraVisitor<CONTE } @Override - public RESULT visitFilter(CONTEXT ctx, Stack<Expr> stack, Selection expr) throws PlanningException { + public RESULT visitFilter(CONTEXT ctx, Stack<Expr> stack, Selection expr) throws TajoException { stack.push(expr); visit(ctx, stack, expr.getQual()); RESULT result = visit(ctx, stack, expr.getChild()); @@ -383,29 +383,29 @@ public class BaseAlgebraVisitor<CONTEXT, RESULT> implements AlgebraVisitor<CONTE } @Override - public RESULT visitUnion(CONTEXT ctx, Stack<Expr> stack, SetOperation expr) throws PlanningException { + public RESULT visitUnion(CONTEXT ctx, Stack<Expr> stack, SetOperation expr) throws TajoException { return visitDefaultBinaryExpr(ctx, stack, expr); } @Override - public RESULT visitExcept(CONTEXT ctx, Stack<Expr> stack, SetOperation expr) throws PlanningException { + public RESULT visitExcept(CONTEXT ctx, Stack<Expr> stack, SetOperation expr) throws TajoException { return visitDefaultBinaryExpr(ctx, stack, expr); } @Override - public RESULT visitIntersect(CONTEXT ctx, Stack<Expr> stack, SetOperation expr) throws PlanningException { + public RESULT visitIntersect(CONTEXT ctx, Stack<Expr> stack, SetOperation expr) throws TajoException { return visitDefaultBinaryExpr(ctx, stack, expr); } @Override public RESULT visitSimpleTableSubQuery(CONTEXT ctx, Stack<Expr> stack, SimpleTableSubQuery expr) - throws PlanningException { + throws TajoException { return visitDefaultUnaryExpr(ctx, stack, expr); } @Override public RESULT visitTableSubQuery(CONTEXT ctx, Stack<Expr> stack, TablePrimarySubQuery expr) - throws PlanningException { + throws TajoException { stack.push(expr); RESULT child = visit(ctx, stack, expr.getSubQuery()); stack.pop(); @@ -413,7 +413,7 @@ public class BaseAlgebraVisitor<CONTEXT, RESULT> implements AlgebraVisitor<CONTE } @Override - public RESULT visitRelationList(CONTEXT ctx, Stack<Expr> stack, RelationList expr) throws PlanningException { + public RESULT visitRelationList(CONTEXT ctx, Stack<Expr> stack, RelationList expr) throws TajoException { stack.push(expr); RESULT child = null; for (Expr e : expr.getRelations()) { @@ -424,17 +424,17 @@ public class BaseAlgebraVisitor<CONTEXT, RESULT> implements AlgebraVisitor<CONTE } @Override - public RESULT visitRelation(CONTEXT ctx, Stack<Expr> stack, Relation expr) throws PlanningException { + public RESULT visitRelation(CONTEXT ctx, Stack<Expr> stack, Relation expr) throws TajoException { return null; } @Override - public RESULT visitScalarSubQuery(CONTEXT ctx, Stack<Expr> stack, ScalarSubQuery expr) throws PlanningException { + public RESULT visitScalarSubQuery(CONTEXT ctx, Stack<Expr> stack, ScalarSubQuery expr) throws TajoException { return visitDefaultUnaryExpr(ctx, stack, expr); } @Override - public RESULT visitExplain(CONTEXT ctx, Stack<Expr> stack, Explain expr) throws PlanningException { + public RESULT visitExplain(CONTEXT ctx, Stack<Expr> stack, Explain expr) throws TajoException { stack.push(expr); RESULT child = visit(ctx, stack, expr.getChild()); stack.pop(); @@ -446,17 +446,17 @@ public class BaseAlgebraVisitor<CONTEXT, RESULT> implements AlgebraVisitor<CONTE /////////////////////////////////////////////////////////////////////////////////////////////////////////// @Override - public RESULT visitCreateDatabase(CONTEXT ctx, Stack<Expr> stack, CreateDatabase expr) throws PlanningException { + public RESULT visitCreateDatabase(CONTEXT ctx, Stack<Expr> stack, CreateDatabase expr) throws TajoException { return null; } @Override - public RESULT visitDropDatabase(CONTEXT ctx, Stack<Expr> stack, DropDatabase expr) throws PlanningException { + public RESULT visitDropDatabase(CONTEXT ctx, Stack<Expr> stack, DropDatabase expr) throws TajoException { return null; } @Override - public RESULT visitCreateTable(CONTEXT ctx, Stack<Expr> stack, CreateTable expr) throws PlanningException { + public RESULT visitCreateTable(CONTEXT ctx, Stack<Expr> stack, CreateTable expr) throws TajoException { stack.push(expr); RESULT child = null; if (expr.hasSubQuery()) { @@ -467,28 +467,28 @@ public class BaseAlgebraVisitor<CONTEXT, RESULT> implements AlgebraVisitor<CONTE } @Override - public RESULT visitDropTable(CONTEXT ctx, Stack<Expr> stack, DropTable expr) throws PlanningException { + public RESULT visitDropTable(CONTEXT ctx, Stack<Expr> stack, DropTable expr) throws TajoException { return null; } @Override - public RESULT visitAlterTablespace(CONTEXT ctx, Stack<Expr> stack, AlterTablespace expr) throws PlanningException { + public RESULT visitAlterTablespace(CONTEXT ctx, Stack<Expr> stack, AlterTablespace expr) throws TajoException { return null; } @Override - public RESULT visitAlterTable(CONTEXT ctx, Stack<Expr> stack, AlterTable expr) throws PlanningException { + public RESULT visitAlterTable(CONTEXT ctx, Stack<Expr> stack, AlterTable expr) throws TajoException { return null; } - public RESULT visitTruncateTable(CONTEXT ctx, Stack<Expr> stack, TruncateTable expr) throws PlanningException { + public RESULT visitTruncateTable(CONTEXT ctx, Stack<Expr> stack, TruncateTable expr) throws TajoException { return null; } /////////////////////////////////////////////////////////////////////////////////////////////////////////// // Insert or Update Section /////////////////////////////////////////////////////////////////////////////////////////////////////////// - public RESULT visitInsert(CONTEXT ctx, Stack<Expr> stack, Insert expr) throws PlanningException { + public RESULT visitInsert(CONTEXT ctx, Stack<Expr> stack, Insert expr) throws TajoException { stack.push(expr); RESULT child = visit(ctx, stack, expr.getSubQuery()); stack.pop(); @@ -500,17 +500,17 @@ public class BaseAlgebraVisitor<CONTEXT, RESULT> implements AlgebraVisitor<CONTE /////////////////////////////////////////////////////////////////////////////////////////////////////////// @Override - public RESULT visitAnd(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws PlanningException { + public RESULT visitAnd(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws TajoException { return visitDefaultBinaryExpr(ctx, stack, expr); } @Override - public RESULT visitOr(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws PlanningException { + public RESULT visitOr(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws TajoException { return visitDefaultBinaryExpr(ctx, stack, expr); } @Override - public RESULT visitNot(CONTEXT ctx, Stack<Expr> stack, NotExpr expr) throws PlanningException { + public RESULT visitNot(CONTEXT ctx, Stack<Expr> stack, NotExpr expr) throws TajoException { return visitDefaultUnaryExpr(ctx, stack, expr); } @@ -518,33 +518,33 @@ public class BaseAlgebraVisitor<CONTEXT, RESULT> implements AlgebraVisitor<CONTE // Comparison Predicates Section /////////////////////////////////////////////////////////////////////////////////////////////////////////// @Override - public RESULT visitEquals(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws PlanningException { + public RESULT visitEquals(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws TajoException { return visitDefaultBinaryExpr(ctx, stack, expr); } @Override - public RESULT visitNotEquals(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws PlanningException { + public RESULT visitNotEquals(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws TajoException { return visitDefaultBinaryExpr(ctx, stack, expr); } @Override - public RESULT visitLessThan(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws PlanningException { + public RESULT visitLessThan(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws TajoException { return visitDefaultBinaryExpr(ctx, stack, expr); } @Override - public RESULT visitLessThanOrEquals(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws PlanningException { + public RESULT visitLessThanOrEquals(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws TajoException { return visitDefaultBinaryExpr(ctx, stack, expr); } @Override - public RESULT visitGreaterThan(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws PlanningException { + public RESULT visitGreaterThan(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws TajoException { return visitDefaultBinaryExpr(ctx, stack, expr); } @Override public RESULT visitGreaterThanOrEquals(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) - throws PlanningException { + throws TajoException { return visitDefaultBinaryExpr(ctx, stack, expr); } @@ -553,7 +553,7 @@ public class BaseAlgebraVisitor<CONTEXT, RESULT> implements AlgebraVisitor<CONTE /////////////////////////////////////////////////////////////////////////////////////////////////////////// @Override - public RESULT visitBetween(CONTEXT ctx, Stack<Expr> stack, BetweenPredicate expr) throws PlanningException { + public RESULT visitBetween(CONTEXT ctx, Stack<Expr> stack, BetweenPredicate expr) throws TajoException { stack.push(expr); RESULT result = visit(ctx, stack, expr.predicand()); visit(ctx, stack, expr.begin()); @@ -563,7 +563,7 @@ public class BaseAlgebraVisitor<CONTEXT, RESULT> implements AlgebraVisitor<CONTE } @Override - public RESULT visitCaseWhen(CONTEXT ctx, Stack<Expr> stack, CaseWhenPredicate expr) throws PlanningException { + public RESULT visitCaseWhen(CONTEXT ctx, Stack<Expr> stack, CaseWhenPredicate expr) throws TajoException { stack.push(expr); RESULT result = null; for (CaseWhenPredicate.WhenExpr when : expr.getWhens()) { @@ -578,17 +578,17 @@ public class BaseAlgebraVisitor<CONTEXT, RESULT> implements AlgebraVisitor<CONTE } @Override - public RESULT visitIsNullPredicate(CONTEXT ctx, Stack<Expr> stack, IsNullPredicate expr) throws PlanningException { + public RESULT visitIsNullPredicate(CONTEXT ctx, Stack<Expr> stack, IsNullPredicate expr) throws TajoException { return visitDefaultUnaryExpr(ctx, stack, expr); } @Override - public RESULT visitInPredicate(CONTEXT ctx, Stack<Expr> stack, InPredicate expr) throws PlanningException { + public RESULT visitInPredicate(CONTEXT ctx, Stack<Expr> stack, InPredicate expr) throws TajoException { return visitDefaultBinaryExpr(ctx, stack, expr); } @Override - public RESULT visitValueListExpr(CONTEXT ctx, Stack<Expr> stack, ValueListExpr expr) throws PlanningException { + public RESULT visitValueListExpr(CONTEXT ctx, Stack<Expr> stack, ValueListExpr expr) throws TajoException { stack.push(expr); RESULT result = null; for (Expr value : expr.getValues()) { @@ -599,7 +599,7 @@ public class BaseAlgebraVisitor<CONTEXT, RESULT> implements AlgebraVisitor<CONTE } @Override - public RESULT visitExistsPredicate(CONTEXT ctx, Stack<Expr> stack, ExistsPredicate expr) throws PlanningException { + public RESULT visitExistsPredicate(CONTEXT ctx, Stack<Expr> stack, ExistsPredicate expr) throws TajoException { return visitDefaultUnaryExpr(ctx, stack, expr); } @@ -608,24 +608,24 @@ public class BaseAlgebraVisitor<CONTEXT, RESULT> implements AlgebraVisitor<CONTE /////////////////////////////////////////////////////////////////////////////////////////////////////////// @Override public RESULT visitLikePredicate(CONTEXT ctx, Stack<Expr> stack, PatternMatchPredicate expr) - throws PlanningException { + throws TajoException { return visitDefaultBinaryExpr(ctx, stack, expr); } @Override public RESULT visitSimilarToPredicate(CONTEXT ctx, Stack<Expr> stack, PatternMatchPredicate expr) - throws PlanningException { + throws TajoException { return visitDefaultBinaryExpr(ctx, stack, expr); } @Override public RESULT visitRegexpPredicate(CONTEXT ctx, Stack<Expr> stack, PatternMatchPredicate expr) - throws PlanningException { + throws TajoException { return visitDefaultBinaryExpr(ctx, stack, expr); } @Override - public RESULT visitConcatenate(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws PlanningException { + public RESULT visitConcatenate(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws TajoException { return visitDefaultBinaryExpr(ctx, stack, expr); } @@ -634,27 +634,27 @@ public class BaseAlgebraVisitor<CONTEXT, RESULT> implements AlgebraVisitor<CONTE /////////////////////////////////////////////////////////////////////////////////////////////////////////// @Override - public RESULT visitPlus(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws PlanningException { + public RESULT visitPlus(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws TajoException { return visitDefaultBinaryExpr(ctx, stack, expr); } @Override - public RESULT visitMinus(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws PlanningException { + public RESULT visitMinus(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws TajoException { return visitDefaultBinaryExpr(ctx, stack, expr); } @Override - public RESULT visitMultiply(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws PlanningException { + public RESULT visitMultiply(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws TajoException { return visitDefaultBinaryExpr(ctx, stack, expr); } @Override - public RESULT visitDivide(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws PlanningException { + public RESULT visitDivide(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws TajoException { return visitDefaultBinaryExpr(ctx, stack, expr); } @Override - public RESULT visitModular(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws PlanningException { + public RESULT visitModular(CONTEXT ctx, Stack<Expr> stack, BinaryOperator expr) throws TajoException { return visitDefaultBinaryExpr(ctx, stack, expr); } @@ -663,23 +663,23 @@ public class BaseAlgebraVisitor<CONTEXT, RESULT> implements AlgebraVisitor<CONTE /////////////////////////////////////////////////////////////////////////////////////////////////////////// @Override - public RESULT visitSign(CONTEXT ctx, Stack<Expr> stack, SignedExpr expr) throws PlanningException { + public RESULT visitSign(CONTEXT ctx, Stack<Expr> stack, SignedExpr expr) throws TajoException { return visitDefaultUnaryExpr(ctx, stack, expr); } @Override public RESULT visitColumnReference(CONTEXT ctx, Stack<Expr> stack, ColumnReferenceExpr expr) - throws PlanningException { + throws TajoException { return null; } @Override - public RESULT visitTargetExpr(CONTEXT ctx, Stack<Expr> stack, NamedExpr expr) throws PlanningException { + public RESULT visitTargetExpr(CONTEXT ctx, Stack<Expr> stack, NamedExpr expr) throws TajoException { return visitDefaultUnaryExpr(ctx, stack, expr); } @Override - public RESULT visitFunction(CONTEXT ctx, Stack<Expr> stack, FunctionExpr expr) throws PlanningException { + public RESULT visitFunction(CONTEXT ctx, Stack<Expr> stack, FunctionExpr expr) throws TajoException { stack.push(expr); RESULT result = null; if (expr.hasParams()) { @@ -692,7 +692,7 @@ public class BaseAlgebraVisitor<CONTEXT, RESULT> implements AlgebraVisitor<CONTE } @Override - public RESULT visitQualifiedAsterisk(CONTEXT ctx, Stack<Expr> stack, QualifiedAsteriskExpr expr) throws PlanningException { + public RESULT visitQualifiedAsterisk(CONTEXT ctx, Stack<Expr> stack, QualifiedAsteriskExpr expr) throws TajoException { return null; } @@ -702,13 +702,13 @@ public class BaseAlgebraVisitor<CONTEXT, RESULT> implements AlgebraVisitor<CONTE @Override public RESULT visitCountRowsFunction(CONTEXT ctx, Stack<Expr> stack, CountRowsFunctionExpr expr) - throws PlanningException { + throws TajoException { return null; } @Override public RESULT visitGeneralSetFunction(CONTEXT ctx, Stack<Expr> stack, GeneralSetFunctionExpr expr) - throws PlanningException { + throws TajoException { stack.push(expr); RESULT result = null; for (Expr param : expr.getParams()) { @@ -719,7 +719,7 @@ public class BaseAlgebraVisitor<CONTEXT, RESULT> implements AlgebraVisitor<CONTE } @Override - public RESULT visitWindowFunction(CONTEXT ctx, Stack<Expr> stack, WindowFunctionExpr expr) throws PlanningException { + public RESULT visitWindowFunction(CONTEXT ctx, Stack<Expr> stack, WindowFunctionExpr expr) throws TajoException { stack.push(expr); RESULT result = null; for (Expr param : expr.getParams()) { @@ -756,12 +756,12 @@ public class BaseAlgebraVisitor<CONTEXT, RESULT> implements AlgebraVisitor<CONTE /////////////////////////////////////////////////////////////////////////////////////////////////////////// @Override - public RESULT visitDataType(CONTEXT ctx, Stack<Expr> stack, DataTypeExpr expr) throws PlanningException { + public RESULT visitDataType(CONTEXT ctx, Stack<Expr> stack, DataTypeExpr expr) throws TajoException { return null; } @Override - public RESULT visitCastExpr(CONTEXT ctx, Stack<Expr> stack, CastExpr expr) throws PlanningException { + public RESULT visitCastExpr(CONTEXT ctx, Stack<Expr> stack, CastExpr expr) throws TajoException { stack.push(expr); RESULT result = visit(ctx, stack, expr.getOperand()); stack.pop(); @@ -769,32 +769,32 @@ public class BaseAlgebraVisitor<CONTEXT, RESULT> implements AlgebraVisitor<CONTE } @Override - public RESULT visitLiteral(CONTEXT ctx, Stack<Expr> stack, LiteralValue expr) throws PlanningException { + public RESULT visitLiteral(CONTEXT ctx, Stack<Expr> stack, LiteralValue expr) throws TajoException { return null; } @Override - public RESULT visitNullLiteral(CONTEXT ctx, Stack<Expr> stack, NullLiteral expr) throws PlanningException { + public RESULT visitNullLiteral(CONTEXT ctx, Stack<Expr> stack, NullLiteral expr) throws TajoException { return null; } @Override - public RESULT visitTimestampLiteral(CONTEXT ctx, Stack<Expr> stack, TimestampLiteral expr) throws PlanningException { + public RESULT visitTimestampLiteral(CONTEXT ctx, Stack<Expr> stack, TimestampLiteral expr) throws TajoException { return null; } @Override - public RESULT visitIntervalLiteral(CONTEXT ctx, Stack<Expr> stack, IntervalLiteral expr) throws PlanningException { + public RESULT visitIntervalLiteral(CONTEXT ctx, Stack<Expr> stack, IntervalLiteral expr) throws TajoException { return null; } @Override - public RESULT visitTimeLiteral(CONTEXT ctx, Stack<Expr> stack, TimeLiteral expr) throws PlanningException { + public RESULT visitTimeLiteral(CONTEXT ctx, Stack<Expr> stack, TimeLiteral expr) throws TajoException { return null; } @Override - public RESULT visitDateLiteral(CONTEXT ctx, Stack<Expr> stack, DateLiteral expr) throws PlanningException { + public RESULT visitDateLiteral(CONTEXT ctx, Stack<Expr> stack, DateLiteral expr) throws TajoException { return null; } }
http://git-wip-us.apache.org/repos/asf/tajo/blob/4841c656/tajo-plan/src/main/java/org/apache/tajo/plan/joinorder/GreedyHeuristicJoinOrderAlgorithm.java ---------------------------------------------------------------------- diff --git a/tajo-plan/src/main/java/org/apache/tajo/plan/joinorder/GreedyHeuristicJoinOrderAlgorithm.java b/tajo-plan/src/main/java/org/apache/tajo/plan/joinorder/GreedyHeuristicJoinOrderAlgorithm.java index 7eb05d7..c1a8e85 100644 --- a/tajo-plan/src/main/java/org/apache/tajo/plan/joinorder/GreedyHeuristicJoinOrderAlgorithm.java +++ b/tajo-plan/src/main/java/org/apache/tajo/plan/joinorder/GreedyHeuristicJoinOrderAlgorithm.java @@ -20,6 +20,8 @@ package org.apache.tajo.plan.joinorder; import org.apache.tajo.algebra.JoinType; import org.apache.tajo.catalog.SchemaUtil; +import org.apache.tajo.exception.TajoException; +import org.apache.tajo.exception.TajoInternalError; import org.apache.tajo.plan.LogicalPlan; import org.apache.tajo.plan.PlanningException; import org.apache.tajo.plan.expr.AlgebraicUtil; @@ -42,7 +44,7 @@ public class GreedyHeuristicJoinOrderAlgorithm implements JoinOrderAlgorithm { @Override public FoundJoinOrder findBestOrder(LogicalPlan plan, LogicalPlan.QueryBlock block, JoinGraphContext graphContext) - throws PlanningException { + throws TajoException { Set<JoinVertex> vertexes = TUtil.newHashSet(); for (RelationNode relationNode : block.getRelations()) { @@ -169,7 +171,7 @@ public class GreedyHeuristicJoinOrderAlgorithm implements JoinOrderAlgorithm { * @throws PlanningException */ private JoinEdge getBestPair(JoinEdgeFinderContext context, JoinGraphContext graphContext, Set<JoinVertex> vertexes) - throws PlanningException { + throws TajoException { double minCost = Double.MAX_VALUE; JoinEdge bestJoin = null; @@ -229,7 +231,7 @@ public class GreedyHeuristicJoinOrderAlgorithm implements JoinOrderAlgorithm { } return swapLeftAndRightIfNecessary(bestJoin); } else { - throw new PlanningException("Cannot find the best join"); + throw new TajoInternalError("Cannot find the best join order"); } } @@ -271,7 +273,7 @@ public class GreedyHeuristicJoinOrderAlgorithm implements JoinOrderAlgorithm { */ private static JoinEdge findJoin(final JoinEdgeFinderContext context, final JoinGraphContext graphContext, JoinVertex begin, final JoinVertex leftTarget, final JoinVertex rightTarget) - throws PlanningException { + throws TajoException { context.visited.add(begin); http://git-wip-us.apache.org/repos/asf/tajo/blob/4841c656/tajo-plan/src/main/java/org/apache/tajo/plan/joinorder/JoinGraph.java ---------------------------------------------------------------------- diff --git a/tajo-plan/src/main/java/org/apache/tajo/plan/joinorder/JoinGraph.java b/tajo-plan/src/main/java/org/apache/tajo/plan/joinorder/JoinGraph.java index 4727b2e..7687474 100644 --- a/tajo-plan/src/main/java/org/apache/tajo/plan/joinorder/JoinGraph.java +++ b/tajo-plan/src/main/java/org/apache/tajo/plan/joinorder/JoinGraph.java @@ -32,7 +32,7 @@ public class JoinGraph extends SimpleUndirectedGraph<JoinVertex, JoinEdge> { private boolean isSymmetricJoinOnly = true; - public JoinEdge addJoin(JoinGraphContext context, JoinSpec joinSpec, JoinVertex left, JoinVertex right) throws PlanningException { + public JoinEdge addJoin(JoinGraphContext context, JoinSpec joinSpec, JoinVertex left, JoinVertex right) { JoinEdge edge = context.getCachedOrNewJoinEdge(joinSpec, left, right); isSymmetricJoinOnly &= PlannerUtil.isCommutativeJoinType(edge.getJoinType()); this.addEdge(left, right, edge); http://git-wip-us.apache.org/repos/asf/tajo/blob/4841c656/tajo-plan/src/main/java/org/apache/tajo/plan/joinorder/JoinOrderAlgorithm.java ---------------------------------------------------------------------- diff --git a/tajo-plan/src/main/java/org/apache/tajo/plan/joinorder/JoinOrderAlgorithm.java b/tajo-plan/src/main/java/org/apache/tajo/plan/joinorder/JoinOrderAlgorithm.java index d9f4c69..5fbbdbf 100644 --- a/tajo-plan/src/main/java/org/apache/tajo/plan/joinorder/JoinOrderAlgorithm.java +++ b/tajo-plan/src/main/java/org/apache/tajo/plan/joinorder/JoinOrderAlgorithm.java @@ -19,6 +19,7 @@ package org.apache.tajo.plan.joinorder; import org.apache.hadoop.classification.InterfaceStability; +import org.apache.tajo.exception.TajoException; import org.apache.tajo.plan.LogicalPlan; import org.apache.tajo.plan.PlanningException; import org.apache.tajo.plan.joinorder.FoundJoinOrder; @@ -44,5 +45,5 @@ public interface JoinOrderAlgorithm { * @throws org.apache.tajo.plan.PlanningException */ FoundJoinOrder findBestOrder(LogicalPlan plan, LogicalPlan.QueryBlock block, JoinGraphContext joinGraphContext) - throws PlanningException; + throws TajoException; } http://git-wip-us.apache.org/repos/asf/tajo/blob/4841c656/tajo-plan/src/main/java/org/apache/tajo/plan/nameresolver/NameResolver.java ---------------------------------------------------------------------- diff --git a/tajo-plan/src/main/java/org/apache/tajo/plan/nameresolver/NameResolver.java b/tajo-plan/src/main/java/org/apache/tajo/plan/nameresolver/NameResolver.java index dfcff9d..392d308 100644 --- a/tajo-plan/src/main/java/org/apache/tajo/plan/nameresolver/NameResolver.java +++ b/tajo-plan/src/main/java/org/apache/tajo/plan/nameresolver/NameResolver.java @@ -25,11 +25,13 @@ import org.apache.tajo.algebra.ColumnReferenceExpr; import org.apache.tajo.catalog.CatalogUtil; import org.apache.tajo.catalog.Column; import org.apache.tajo.catalog.Schema; +import org.apache.tajo.catalog.exception.AmbiguousTableException; import org.apache.tajo.catalog.exception.UndefinedColumnException; -import org.apache.tajo.plan.algebra.AmbiguousFieldException; +import org.apache.tajo.catalog.exception.UndefinedTableException; +import org.apache.tajo.exception.AmbiguousColumnException; +import org.apache.tajo.exception.TajoException; import org.apache.tajo.plan.LogicalPlan; import org.apache.tajo.plan.PlanningException; -import org.apache.tajo.plan.verifier.VerifyException; import org.apache.tajo.plan.logical.RelationNode; import org.apache.tajo.util.Pair; import org.apache.tajo.util.StringUtils; @@ -69,15 +71,15 @@ public abstract class NameResolver { } public static Column resolve(LogicalPlan plan, LogicalPlan.QueryBlock block, ColumnReferenceExpr column, - NameResolvingMode mode) throws PlanningException { + NameResolvingMode mode) throws TajoException { if (!resolverMap.containsKey(mode)) { - throw new PlanningException("Unsupported name resolving level: " + mode.name()); + throw new RuntimeException("Unsupported name resolving level: " + mode.name()); } return resolverMap.get(mode).resolve(plan, block, column); } abstract Column resolve(LogicalPlan plan, LogicalPlan.QueryBlock block, ColumnReferenceExpr columnRef) - throws PlanningException; + throws TajoException; /** * Guess a relation from a table name regardless of whether the given name is qualified or not. @@ -87,7 +89,9 @@ public abstract class NameResolver { * @return A corresponding relation * @throws PlanningException */ - public static RelationNode lookupTable(LogicalPlan.QueryBlock block, String tableName) throws PlanningException { + public static RelationNode lookupTable(LogicalPlan.QueryBlock block, String tableName) + throws AmbiguousTableException { + List<RelationNode> found = TUtil.newList(); for (RelationNode relation : block.getRelations()) { @@ -107,7 +111,7 @@ public abstract class NameResolver { return null; } else if (found.size() > 1) { - throw new PlanningException("Ambiguous table name \"" + tableName + "\""); + throw new AmbiguousTableException(tableName); } return found.get(0); @@ -119,10 +123,8 @@ public abstract class NameResolver { * @param block the current block * @param columnName The column name to find relation * @return relations including a given column - * @throws PlanningException */ - public static Collection<RelationNode> lookupTableByColumns(LogicalPlan.QueryBlock block, String columnName) - throws PlanningException { + public static Collection<RelationNode> lookupTableByColumns(LogicalPlan.QueryBlock block, String columnName) { Set<RelationNode> found = TUtil.newHashSet(); @@ -147,7 +149,7 @@ public abstract class NameResolver { * @throws PlanningException */ static Column resolveFromRelsWithinBlock(LogicalPlan plan, LogicalPlan.QueryBlock block, - ColumnReferenceExpr columnRef) throws PlanningException { + ColumnReferenceExpr columnRef) throws AmbiguousColumnException { String qualifier; String canonicalName; @@ -160,7 +162,7 @@ public abstract class NameResolver { // If we cannot find any relation against a qualified column name if (relationOp == null) { - throw new PlanningException("Cannot find any relation for " + qualifier); + throw new UndefinedTableException(qualifier); } // Please consider a query case: @@ -216,7 +218,7 @@ public abstract class NameResolver { * @return The found column */ static Column lookupColumnFromAllRelsInBlock(LogicalPlan.QueryBlock block, - String columnName) throws VerifyException { + String columnName) throws AmbiguousColumnException { Preconditions.checkArgument(CatalogUtil.isSimpleIdentifier(columnName)); List<Column> candidates = TUtil.newList(); @@ -242,7 +244,8 @@ public abstract class NameResolver { * @param columnRef The column reference to be found * @return The found column */ - static Column resolveFromAllRelsInAllBlocks(LogicalPlan plan, ColumnReferenceExpr columnRef) throws VerifyException { + static Column resolveFromAllRelsInAllBlocks(LogicalPlan plan, ColumnReferenceExpr columnRef) + throws AmbiguousColumnException { List<Column> candidates = Lists.newArrayList(); @@ -271,7 +274,9 @@ public abstract class NameResolver { * @param columnRef The column reference to be found * @return The found column */ - static Column resolveAliasedName(LogicalPlan.QueryBlock block, ColumnReferenceExpr columnRef) throws VerifyException { + static Column resolveAliasedName(LogicalPlan.QueryBlock block, ColumnReferenceExpr columnRef) + throws AmbiguousColumnException { + List<Column> candidates = Lists.newArrayList(); if (block.getSchema() != null) { @@ -301,7 +306,8 @@ public abstract class NameResolver { */ static Pair<String, String> lookupQualifierAndCanonicalName(LogicalPlan.QueryBlock block, ColumnReferenceExpr columnRef) - throws PlanningException { + throws AmbiguousColumnException { + Preconditions.checkArgument(columnRef.hasQualifier(), "ColumnReferenceExpr must be qualified."); String [] qualifierParts = columnRef.getQualifier().split("\\."); @@ -342,7 +348,7 @@ public abstract class NameResolver { Collection<RelationNode> rels = lookupTableByColumns(block, qualifierParts[0]); if (rels.size() > 1) { - throw new AmbiguousFieldException(columnRef.getCanonicalName()); + throw new AmbiguousColumnException(columnRef.getCanonicalName()); } if (rels.size() == 1) { @@ -355,7 +361,7 @@ public abstract class NameResolver { if (guessedRelations.size() == 0) { throw new UndefinedColumnException(columnRef.getQualifier()); } else if (guessedRelations.size() > 1) { - throw new AmbiguousFieldException(columnRef.getCanonicalName()); + throw new AmbiguousColumnException(columnRef.getCanonicalName()); } String qualifier = guessedRelations.iterator().next().getCanonicalName(); @@ -379,7 +385,7 @@ public abstract class NameResolver { return new Pair<String, String>(qualifier, columnName); } - static Column ensureUniqueColumn(List<Column> candidates) throws VerifyException { + static Column ensureUniqueColumn(List<Column> candidates) throws AmbiguousColumnException { if (candidates.size() == 1) { return candidates.get(0); } else if (candidates.size() > 1) { @@ -393,7 +399,7 @@ public abstract class NameResolver { } sb.append(column); } - throw new AmbiguousFieldException("Ambiguous Column Name: " + sb.toString()); + throw new AmbiguousColumnException(sb.toString()); } else { return null; } http://git-wip-us.apache.org/repos/asf/tajo/blob/4841c656/tajo-plan/src/main/java/org/apache/tajo/plan/nameresolver/ResolverByLegacy.java ---------------------------------------------------------------------- diff --git a/tajo-plan/src/main/java/org/apache/tajo/plan/nameresolver/ResolverByLegacy.java b/tajo-plan/src/main/java/org/apache/tajo/plan/nameresolver/ResolverByLegacy.java index a94c296..aa0d7f5 100644 --- a/tajo-plan/src/main/java/org/apache/tajo/plan/nameresolver/ResolverByLegacy.java +++ b/tajo-plan/src/main/java/org/apache/tajo/plan/nameresolver/ResolverByLegacy.java @@ -23,6 +23,8 @@ import org.apache.tajo.catalog.CatalogUtil; import org.apache.tajo.catalog.Column; import org.apache.tajo.catalog.Schema; import org.apache.tajo.catalog.exception.UndefinedColumnException; +import org.apache.tajo.exception.AmbiguousColumnException; +import org.apache.tajo.exception.TajoException; import org.apache.tajo.plan.LogicalPlan; import org.apache.tajo.plan.PlanningException; import org.apache.tajo.plan.logical.LogicalNode; @@ -36,7 +38,7 @@ import java.util.List; public class ResolverByLegacy extends NameResolver { @Override public Column resolve(LogicalPlan plan, LogicalPlan.QueryBlock block, ColumnReferenceExpr columnRef) - throws PlanningException { + throws TajoException { if (columnRef.hasQualifier()) { return resolveColumnWithQualifier(plan, block, columnRef); @@ -46,7 +48,7 @@ public class ResolverByLegacy extends NameResolver { } private static Column resolveColumnWithQualifier(LogicalPlan plan, LogicalPlan.QueryBlock block, - ColumnReferenceExpr columnRef) throws PlanningException { + ColumnReferenceExpr columnRef) throws TajoException { final String qualifier; final String qualifiedName; @@ -97,7 +99,7 @@ public class ResolverByLegacy extends NameResolver { } static Column resolveColumnWithoutQualifier(LogicalPlan plan, LogicalPlan.QueryBlock block, - ColumnReferenceExpr columnRef)throws PlanningException { + ColumnReferenceExpr columnRef) throws AmbiguousColumnException { Column found = lookupColumnFromAllRelsInBlock(block, columnRef.getName()); if (found != null) { http://git-wip-us.apache.org/repos/asf/tajo/blob/4841c656/tajo-plan/src/main/java/org/apache/tajo/plan/nameresolver/ResolverByRels.java ---------------------------------------------------------------------- diff --git a/tajo-plan/src/main/java/org/apache/tajo/plan/nameresolver/ResolverByRels.java b/tajo-plan/src/main/java/org/apache/tajo/plan/nameresolver/ResolverByRels.java index 1045cce..fa9fe84 100644 --- a/tajo-plan/src/main/java/org/apache/tajo/plan/nameresolver/ResolverByRels.java +++ b/tajo-plan/src/main/java/org/apache/tajo/plan/nameresolver/ResolverByRels.java @@ -21,13 +21,14 @@ package org.apache.tajo.plan.nameresolver; import org.apache.tajo.algebra.ColumnReferenceExpr; import org.apache.tajo.catalog.Column; import org.apache.tajo.catalog.exception.UndefinedColumnException; +import org.apache.tajo.exception.AmbiguousColumnException; import org.apache.tajo.plan.LogicalPlan; import org.apache.tajo.plan.PlanningException; public class ResolverByRels extends NameResolver { @Override public Column resolve(LogicalPlan plan, LogicalPlan.QueryBlock block, ColumnReferenceExpr columnRef) - throws PlanningException { + throws AmbiguousColumnException { Column column = resolveFromRelsWithinBlock(plan, block, columnRef); if (column == null) { http://git-wip-us.apache.org/repos/asf/tajo/blob/4841c656/tajo-plan/src/main/java/org/apache/tajo/plan/nameresolver/ResolverByRelsAndSubExprs.java ---------------------------------------------------------------------- diff --git a/tajo-plan/src/main/java/org/apache/tajo/plan/nameresolver/ResolverByRelsAndSubExprs.java b/tajo-plan/src/main/java/org/apache/tajo/plan/nameresolver/ResolverByRelsAndSubExprs.java index 2a8319c..cafba7d 100644 --- a/tajo-plan/src/main/java/org/apache/tajo/plan/nameresolver/ResolverByRelsAndSubExprs.java +++ b/tajo-plan/src/main/java/org/apache/tajo/plan/nameresolver/ResolverByRelsAndSubExprs.java @@ -21,13 +21,14 @@ package org.apache.tajo.plan.nameresolver; import org.apache.tajo.algebra.ColumnReferenceExpr; import org.apache.tajo.catalog.Column; import org.apache.tajo.catalog.exception.UndefinedColumnException; +import org.apache.tajo.exception.AmbiguousColumnException; import org.apache.tajo.plan.LogicalPlan; import org.apache.tajo.plan.PlanningException; public class ResolverByRelsAndSubExprs extends NameResolver { @Override public Column resolve(LogicalPlan plan, LogicalPlan.QueryBlock block, ColumnReferenceExpr columnRef) - throws PlanningException { + throws AmbiguousColumnException { Column column = resolveFromRelsWithinBlock(plan, block, columnRef); if (column == null) { http://git-wip-us.apache.org/repos/asf/tajo/blob/4841c656/tajo-plan/src/main/java/org/apache/tajo/plan/nameresolver/ResolverBySubExprsAndRels.java ---------------------------------------------------------------------- diff --git a/tajo-plan/src/main/java/org/apache/tajo/plan/nameresolver/ResolverBySubExprsAndRels.java b/tajo-plan/src/main/java/org/apache/tajo/plan/nameresolver/ResolverBySubExprsAndRels.java index 5de720e..c16bbe2 100644 --- a/tajo-plan/src/main/java/org/apache/tajo/plan/nameresolver/ResolverBySubExprsAndRels.java +++ b/tajo-plan/src/main/java/org/apache/tajo/plan/nameresolver/ResolverBySubExprsAndRels.java @@ -21,13 +21,14 @@ package org.apache.tajo.plan.nameresolver; import org.apache.tajo.algebra.ColumnReferenceExpr; import org.apache.tajo.catalog.Column; import org.apache.tajo.catalog.exception.UndefinedColumnException; +import org.apache.tajo.exception.AmbiguousColumnException; import org.apache.tajo.plan.LogicalPlan; import org.apache.tajo.plan.PlanningException; public class ResolverBySubExprsAndRels extends NameResolver { @Override public Column resolve(LogicalPlan plan, LogicalPlan.QueryBlock block, ColumnReferenceExpr columnRef) - throws PlanningException { + throws AmbiguousColumnException{ Column column = resolveFromCurrentAndChildNode(block, columnRef); if (column == null) { http://git-wip-us.apache.org/repos/asf/tajo/blob/4841c656/tajo-plan/src/main/java/org/apache/tajo/plan/rewrite/BaseLogicalPlanRewriteEngine.java ---------------------------------------------------------------------- diff --git a/tajo-plan/src/main/java/org/apache/tajo/plan/rewrite/BaseLogicalPlanRewriteEngine.java b/tajo-plan/src/main/java/org/apache/tajo/plan/rewrite/BaseLogicalPlanRewriteEngine.java index 19c254b..f6f1e63 100644 --- a/tajo-plan/src/main/java/org/apache/tajo/plan/rewrite/BaseLogicalPlanRewriteEngine.java +++ b/tajo-plan/src/main/java/org/apache/tajo/plan/rewrite/BaseLogicalPlanRewriteEngine.java @@ -21,8 +21,8 @@ package org.apache.tajo.plan.rewrite; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.apache.tajo.OverridableConf; +import org.apache.tajo.exception.TajoException; import org.apache.tajo.plan.LogicalPlan; -import org.apache.tajo.plan.PlanningException; import java.util.LinkedHashMap; import java.util.Map; @@ -72,7 +72,7 @@ public class BaseLogicalPlanRewriteEngine implements LogicalPlanRewriteEngine { * @param plan The plan to be rewritten with all query rewrite rule. * @return The rewritten plan. */ - public LogicalPlan rewrite(OverridableConf queryContext, LogicalPlan plan) throws PlanningException { + public LogicalPlan rewrite(OverridableConf queryContext, LogicalPlan plan) throws TajoException { LogicalPlanRewriteRule rule; for (Entry<String, LogicalPlanRewriteRule> rewriteRule : rewriteRules.entrySet()) { rule = rewriteRule.getValue(); http://git-wip-us.apache.org/repos/asf/tajo/blob/4841c656/tajo-plan/src/main/java/org/apache/tajo/plan/rewrite/LogicalPlanRewriteEngine.java ---------------------------------------------------------------------- diff --git a/tajo-plan/src/main/java/org/apache/tajo/plan/rewrite/LogicalPlanRewriteEngine.java b/tajo-plan/src/main/java/org/apache/tajo/plan/rewrite/LogicalPlanRewriteEngine.java index 267d651..99d8979 100644 --- a/tajo-plan/src/main/java/org/apache/tajo/plan/rewrite/LogicalPlanRewriteEngine.java +++ b/tajo-plan/src/main/java/org/apache/tajo/plan/rewrite/LogicalPlanRewriteEngine.java @@ -19,8 +19,8 @@ package org.apache.tajo.plan.rewrite; import org.apache.tajo.OverridableConf; +import org.apache.tajo.exception.TajoException; import org.apache.tajo.plan.LogicalPlan; -import org.apache.tajo.plan.PlanningException; public interface LogicalPlanRewriteEngine { /** @@ -29,5 +29,5 @@ public interface LogicalPlanRewriteEngine { * @param plan The plan to be rewritten with all query rewrite rule. * @return The rewritten plan. */ - LogicalPlan rewrite(OverridableConf queryContext, LogicalPlan plan) throws PlanningException; + LogicalPlan rewrite(OverridableConf queryContext, LogicalPlan plan) throws TajoException; } http://git-wip-us.apache.org/repos/asf/tajo/blob/4841c656/tajo-plan/src/main/java/org/apache/tajo/plan/rewrite/LogicalPlanRewriteRule.java ---------------------------------------------------------------------- diff --git a/tajo-plan/src/main/java/org/apache/tajo/plan/rewrite/LogicalPlanRewriteRule.java b/tajo-plan/src/main/java/org/apache/tajo/plan/rewrite/LogicalPlanRewriteRule.java index 2f0652b..d5d02f2 100644 --- a/tajo-plan/src/main/java/org/apache/tajo/plan/rewrite/LogicalPlanRewriteRule.java +++ b/tajo-plan/src/main/java/org/apache/tajo/plan/rewrite/LogicalPlanRewriteRule.java @@ -19,6 +19,7 @@ package org.apache.tajo.plan.rewrite; import org.apache.tajo.OverridableConf; +import org.apache.tajo.exception.TajoException; import org.apache.tajo.plan.LogicalPlan; import org.apache.tajo.plan.PlanningException; @@ -53,5 +54,5 @@ public interface LogicalPlanRewriteRule { * @param plan Input logical plan. It will not be modified. * @return The rewritten logical plan. */ - LogicalPlan rewrite(OverridableConf queryContext, LogicalPlan plan) throws PlanningException; + LogicalPlan rewrite(OverridableConf queryContext, LogicalPlan plan) throws TajoException; } http://git-wip-us.apache.org/repos/asf/tajo/blob/4841c656/tajo-plan/src/main/java/org/apache/tajo/plan/rewrite/rules/FilterPushDownRule.java ---------------------------------------------------------------------- diff --git a/tajo-plan/src/main/java/org/apache/tajo/plan/rewrite/rules/FilterPushDownRule.java b/tajo-plan/src/main/java/org/apache/tajo/plan/rewrite/rules/FilterPushDownRule.java index ee932fd..503f371 100644 --- a/tajo-plan/src/main/java/org/apache/tajo/plan/rewrite/rules/FilterPushDownRule.java +++ b/tajo-plan/src/main/java/org/apache/tajo/plan/rewrite/rules/FilterPushDownRule.java @@ -29,6 +29,8 @@ import org.apache.tajo.catalog.CatalogUtil; import org.apache.tajo.catalog.Column; import org.apache.tajo.catalog.Schema; import org.apache.tajo.catalog.TableDesc; +import org.apache.tajo.exception.TajoException; +import org.apache.tajo.exception.TajoInternalError; import org.apache.tajo.plan.*; import org.apache.tajo.plan.expr.*; import org.apache.tajo.plan.logical.*; @@ -96,7 +98,7 @@ public class FilterPushDownRule extends BasicLogicalPlanVisitor<FilterPushDownCo } @Override - public LogicalPlan rewrite(OverridableConf queryContext, LogicalPlan plan) throws PlanningException { + public LogicalPlan rewrite(OverridableConf queryContext, LogicalPlan plan) throws TajoException { /* FilterPushDown rule: processing when visits each node - If a target which is corresponding on a filter EvalNode's column is not FieldEval, do not PushDown. @@ -123,7 +125,7 @@ public class FilterPushDownRule extends BasicLogicalPlanVisitor<FilterPushDownCo @Override public LogicalNode visitFilter(FilterPushDownContext context, LogicalPlan plan, LogicalPlan.QueryBlock block, - SelectionNode selNode, Stack<LogicalNode> stack) throws PlanningException { + SelectionNode selNode, Stack<LogicalNode> stack) throws TajoException { context.pushingDownFilters.addAll(TUtil.newHashSet(AlgebraicUtil.toConjunctiveNormalFormArray(selNode.getQual()))); stack.push(selNode); @@ -163,7 +165,7 @@ public class FilterPushDownRule extends BasicLogicalPlanVisitor<FilterPushDownCo @Override public LogicalNode visitJoin(FilterPushDownContext context, LogicalPlan plan, LogicalPlan.QueryBlock block, JoinNode joinNode, - Stack<LogicalNode> stack) throws PlanningException { + Stack<LogicalNode> stack) throws TajoException { Set<EvalNode> onPredicates = TUtil.newHashSet(); if (joinNode.hasJoinQual()) { onPredicates.addAll(TUtil.newHashSet(AlgebraicUtil.toConjunctiveNormalFormArray(joinNode.getJoinQual()))); @@ -241,7 +243,7 @@ public class FilterPushDownRule extends BasicLogicalPlanVisitor<FilterPushDownCo final JoinNode joinNode, final Set<EvalNode> onPredicates, final Set<EvalNode> wherePredicates) - throws PlanningException { + throws TajoException { Set<EvalNode> nonPushableQuals = TUtil.newHashSet(); // TODO: non-equi theta join quals must not be pushed until TAJO-742 is resolved. nonPushableQuals.addAll(extractNonEquiThetaJoinQuals(wherePredicates, block, joinNode)); @@ -288,7 +290,7 @@ public class FilterPushDownRule extends BasicLogicalPlanVisitor<FilterPushDownCo private static Set<EvalNode> extractNonPushableOuterJoinQuals(final LogicalPlan plan, final Set<EvalNode> onPredicates, final Set<EvalNode> wherePredicates, - final JoinNode joinNode) throws PlanningException { + final JoinNode joinNode) throws TajoException { Set<String> nullSupplyingTableNameSet = TUtil.newHashSet(); Set<String> preservedTableNameSet = TUtil.newHashSet(); String leftRelation = PlannerUtil.getTopRelationInLineage(plan, joinNode.getLeftChild()); @@ -372,7 +374,7 @@ public class FilterPushDownRule extends BasicLogicalPlanVisitor<FilterPushDownCo private Map<EvalNode, EvalNode> transformEvalsWidthByPassNode( Collection<EvalNode> originEvals, LogicalPlan plan, LogicalPlan.QueryBlock block, - LogicalNode node, LogicalNode childNode) throws PlanningException { + LogicalNode node, LogicalNode childNode) throws TajoException { // transformed -> pushingDownFilters Map<EvalNode, EvalNode> transformedMap = TUtil.newHashMap(); @@ -388,14 +390,14 @@ public class FilterPushDownRule extends BasicLogicalPlanVisitor<FilterPushDownCo try { copy = (EvalNode) eval.clone(); } catch (CloneNotSupportedException e) { - throw new PlanningException(e); + throw new TajoInternalError(e); } Set<Column> columns = EvalTreeUtil.findUniqueColumns(copy); for (Column c : columns) { Column column = childOutSchema.getColumn(c.getSimpleName()); if (column == null) { - throw new PlanningException( + throw new TajoInternalError( "Invalid Filter PushDown on SubQuery: No such a corresponding column '" + c.getQualifiedName() + " for FilterPushDown(" + eval + "), " + "(PID=" + node.getPID() + ", Child=" + childNode.getPID() + ")"); @@ -415,7 +417,7 @@ public class FilterPushDownRule extends BasicLogicalPlanVisitor<FilterPushDownCo try { copy = (EvalNode) eval.clone(); } catch (CloneNotSupportedException e) { - throw new PlanningException(e); + throw new TajoInternalError(e); } Set<Column> columns = EvalTreeUtil.findUniqueColumns(copy); @@ -446,7 +448,7 @@ public class FilterPushDownRule extends BasicLogicalPlanVisitor<FilterPushDownCo try { copy = (EvalNode) matchedEval.clone(); } catch (CloneNotSupportedException e) { - throw new PlanningException(e); + throw new TajoInternalError(e); } Set<Column> columns = EvalTreeUtil.findUniqueColumns(copy); @@ -461,7 +463,7 @@ public class FilterPushDownRule extends BasicLogicalPlanVisitor<FilterPushDownCo break; } } else { - throw new PlanningException( + throw new TajoInternalError( "Invalid Filter PushDown on SubQuery: No such a corresponding column '" + c.getQualifiedName() + " for FilterPushDown(" + matchedEval + "), " + "(PID=" + node.getPID() + ", Child=" + childNode.getPID() + ")" @@ -479,7 +481,7 @@ public class FilterPushDownRule extends BasicLogicalPlanVisitor<FilterPushDownCo @Override public LogicalNode visitTableSubQuery(FilterPushDownContext context, LogicalPlan plan, LogicalPlan.QueryBlock block, - TableSubQueryNode node, Stack<LogicalNode> stack) throws PlanningException { + TableSubQueryNode node, Stack<LogicalNode> stack) throws TajoException { List<EvalNode> matched = TUtil.newList(); for (EvalNode eval : context.pushingDownFilters) { if (LogicalPlanner.checkIfBeEvaluatedAtRelation(block, eval, node)) { @@ -500,7 +502,7 @@ public class FilterPushDownRule extends BasicLogicalPlanVisitor<FilterPushDownCo @Override public LogicalNode visitUnion(FilterPushDownContext context, LogicalPlan plan, LogicalPlan.QueryBlock block, UnionNode unionNode, - Stack<LogicalNode> stack) throws PlanningException { + Stack<LogicalNode> stack) throws TajoException { LogicalNode leftNode = unionNode.getLeftChild(); List<EvalNode> origins = TUtil.newList(context.pushingDownFilters); @@ -533,7 +535,7 @@ public class FilterPushDownRule extends BasicLogicalPlanVisitor<FilterPushDownCo LogicalPlan plan, LogicalPlan.QueryBlock block, ProjectionNode projectionNode, - Stack<LogicalNode> stack) throws PlanningException { + Stack<LogicalNode> stack) throws TajoException { LogicalNode childNode = projectionNode.getChild(); List<EvalNode> notMatched = TUtil.newList(); @@ -598,7 +600,7 @@ public class FilterPushDownRule extends BasicLogicalPlanVisitor<FilterPushDownCo private BiMap<EvalNode, EvalNode> findCanPushdownAndTransform( FilterPushDownContext context, LogicalPlan.QueryBlock block, Projectable node, LogicalNode childNode, List<EvalNode> notMatched, - Set<String> partitionColumns, int columnOffset) throws PlanningException { + Set<String> partitionColumns, int columnOffset) throws TajoException { // canonical name -> target Map<String, Target> nodeTargetMap = TUtil.newHashMap(); for (Target target : node.getTargets()) { @@ -642,19 +644,19 @@ public class FilterPushDownRule extends BasicLogicalPlanVisitor<FilterPushDownCo private EvalNode transformEval(Projectable node, LogicalNode childNode, EvalNode origin, Map<String, Target> targetMap, Set<String> partitionColumns, - int columnOffset) throws PlanningException { + int columnOffset) throws TajoException { Schema outputSchema = childNode != null ? childNode.getOutSchema() : node.getInSchema(); EvalNode copy; try { copy = (EvalNode) origin.clone(); } catch (CloneNotSupportedException e) { - throw new PlanningException(e); + throw new TajoInternalError(e); } Set<Column> columns = EvalTreeUtil.findUniqueColumns(copy); for (Column c: columns) { Target target = targetMap.get(c.getQualifiedName()); if (target == null) { - throw new PlanningException( + throw new TajoInternalError( "Invalid Filter PushDown: No such a corresponding target '" + c.getQualifiedName() + " for FilterPushDown(" + origin + "), " + "(PID=" + node.getPID() + ")" @@ -662,7 +664,7 @@ public class FilterPushDownRule extends BasicLogicalPlanVisitor<FilterPushDownCo } EvalNode targetEvalNode = target.getEvalTree(); if (targetEvalNode.getType() != EvalType.FIELD) { - throw new PlanningException( + throw new TajoInternalError( "Invalid Filter PushDown: '" + c.getQualifiedName() + "' target is not FieldEval " + "(PID=" + node.getPID() + ")" ); @@ -717,13 +719,13 @@ public class FilterPushDownRule extends BasicLogicalPlanVisitor<FilterPushDownCo * @param havingNode If null, projection is parent * @param groupByNode * @return matched origin eval - * @throws PlanningException + * @throws TajoException */ private List<EvalNode> addHavingNode(FilterPushDownContext context, LogicalPlan plan, LogicalPlan.QueryBlock block, UnaryNode parentNode, HavingNode havingNode, - GroupbyNode groupByNode) throws PlanningException { + GroupbyNode groupByNode) throws TajoException { // find aggregation column Set<Column> groupingColumns = TUtil.newHashSet(groupByNode.getGroupingColumns()); Set<String> aggrFunctionOutColumns = TUtil.newHashSet(); @@ -793,7 +795,7 @@ public class FilterPushDownRule extends BasicLogicalPlanVisitor<FilterPushDownCo @Override public LogicalNode visitWindowAgg(FilterPushDownContext context, LogicalPlan plan, LogicalPlan.QueryBlock block, WindowAggNode winAggNode, - Stack<LogicalNode> stack) throws PlanningException { + Stack<LogicalNode> stack) throws TajoException { stack.push(winAggNode); super.visitWindowAgg(context, plan, block, winAggNode, stack); stack.pop(); @@ -804,7 +806,7 @@ public class FilterPushDownRule extends BasicLogicalPlanVisitor<FilterPushDownCo @Override public LogicalNode visitGroupBy(FilterPushDownContext context, LogicalPlan plan, LogicalPlan.QueryBlock block, GroupbyNode groupbyNode, - Stack<LogicalNode> stack) throws PlanningException { + Stack<LogicalNode> stack) throws TajoException { LogicalNode parentNode = stack.peek(); List<EvalNode> aggrEvals; if (parentNode.getType() == NodeType.HAVING) { @@ -835,7 +837,7 @@ public class FilterPushDownRule extends BasicLogicalPlanVisitor<FilterPushDownCo @Override public LogicalNode visitScan(FilterPushDownContext context, LogicalPlan plan, LogicalPlan.QueryBlock block, ScanNode scanNode, - Stack<LogicalNode> stack) throws PlanningException { + Stack<LogicalNode> stack) throws TajoException { List<EvalNode> matched = TUtil.newList(); // find partition column and check matching @@ -870,7 +872,7 @@ public class FilterPushDownRule extends BasicLogicalPlanVisitor<FilterPushDownCo try { copy = (EvalNode) eval.clone(); } catch (CloneNotSupportedException e) { - throw new PlanningException(e); + throw new TajoInternalError(e); } EvalTreeUtil.changeColumnRef(copy, column.getQualifiedName(), scanNode.getCanonicalName() + "." + column.getSimpleName()); @@ -919,7 +921,7 @@ public class FilterPushDownRule extends BasicLogicalPlanVisitor<FilterPushDownCo } private void errorFilterPushDown(LogicalPlan plan, LogicalNode node, - FilterPushDownContext context) throws PlanningException { + FilterPushDownContext context) { String prefix = ""; StringBuilder notMatchedNodeStrBuilder = new StringBuilder(); for (EvalNode notMatchedNode: context.pushingDownFilters) { @@ -928,8 +930,8 @@ public class FilterPushDownRule extends BasicLogicalPlanVisitor<FilterPushDownCo prefix = ", "; } } - throw new PlanningException("FilterPushDown failed cause some filters not matched: " + notMatchedNodeStrBuilder.toString() + "\n" + - "Error node: " + node.getPlanString() + "\n" + - plan.toString()); + throw new TajoInternalError("FilterPushDown failed cause some filters not matched: " + + notMatchedNodeStrBuilder.toString() + "\n" + + "Error node: " + node.getPlanString() + "\n" + plan.toString()); } } http://git-wip-us.apache.org/repos/asf/tajo/blob/4841c656/tajo-plan/src/main/java/org/apache/tajo/plan/rewrite/rules/LogicalPlanEqualityTester.java ---------------------------------------------------------------------- diff --git a/tajo-plan/src/main/java/org/apache/tajo/plan/rewrite/rules/LogicalPlanEqualityTester.java b/tajo-plan/src/main/java/org/apache/tajo/plan/rewrite/rules/LogicalPlanEqualityTester.java index 43a8618..afe0c4d 100644 --- a/tajo-plan/src/main/java/org/apache/tajo/plan/rewrite/rules/LogicalPlanEqualityTester.java +++ b/tajo-plan/src/main/java/org/apache/tajo/plan/rewrite/rules/LogicalPlanEqualityTester.java @@ -19,8 +19,8 @@ package org.apache.tajo.plan.rewrite.rules; import org.apache.tajo.OverridableConf; +import org.apache.tajo.exception.TajoException; import org.apache.tajo.plan.LogicalPlan; -import org.apache.tajo.plan.PlanningException; import org.apache.tajo.plan.logical.LogicalNode; import org.apache.tajo.plan.rewrite.LogicalPlanRewriteRule; import org.apache.tajo.plan.serder.LogicalNodeDeserializer; @@ -45,7 +45,7 @@ public class LogicalPlanEqualityTester implements LogicalPlanRewriteRule { } @Override - public LogicalPlan rewrite(OverridableConf queryContext, LogicalPlan plan) throws PlanningException { + public LogicalPlan rewrite(OverridableConf queryContext, LogicalPlan plan) throws TajoException { LogicalNode root = plan.getRootBlock().getRoot(); PlanProto.LogicalNodeTree serialized = LogicalNodeSerializer.serialize(plan.getRootBlock().getRoot()); LogicalNode deserialized = LogicalNodeDeserializer.deserialize(queryContext, null, serialized); http://git-wip-us.apache.org/repos/asf/tajo/blob/4841c656/tajo-plan/src/main/java/org/apache/tajo/plan/rewrite/rules/PartitionedTableRewriter.java ---------------------------------------------------------------------- diff --git a/tajo-plan/src/main/java/org/apache/tajo/plan/rewrite/rules/PartitionedTableRewriter.java b/tajo-plan/src/main/java/org/apache/tajo/plan/rewrite/rules/PartitionedTableRewriter.java index cd56a51..71b9fd7 100644 --- a/tajo-plan/src/main/java/org/apache/tajo/plan/rewrite/rules/PartitionedTableRewriter.java +++ b/tajo-plan/src/main/java/org/apache/tajo/plan/rewrite/rules/PartitionedTableRewriter.java @@ -30,12 +30,13 @@ import org.apache.tajo.catalog.TableDesc; import org.apache.tajo.catalog.partition.PartitionMethodDesc; import org.apache.tajo.datum.DatumFactory; import org.apache.tajo.datum.NullDatum; +import org.apache.tajo.exception.TajoException; +import org.apache.tajo.exception.TajoInternalError; import org.apache.tajo.plan.LogicalPlan; -import org.apache.tajo.plan.rewrite.LogicalPlanRewriteRule; -import org.apache.tajo.plan.util.PlannerUtil; -import org.apache.tajo.plan.PlanningException; import org.apache.tajo.plan.expr.*; import org.apache.tajo.plan.logical.*; +import org.apache.tajo.plan.rewrite.LogicalPlanRewriteRule; +import org.apache.tajo.plan.util.PlannerUtil; import org.apache.tajo.plan.visitor.BasicLogicalPlanVisitor; import org.apache.tajo.storage.Tuple; import org.apache.tajo.storage.VTuple; @@ -73,7 +74,7 @@ public class PartitionedTableRewriter implements LogicalPlanRewriteRule { } @Override - public LogicalPlan rewrite(OverridableConf queryContext, LogicalPlan plan) throws PlanningException { + public LogicalPlan rewrite(OverridableConf queryContext, LogicalPlan plan) throws TajoException { LogicalPlan.QueryBlock rootBlock = plan.getRootBlock(); rewriter.visit(queryContext, plan, rootBlock, rootBlock.getRoot(), new Stack<LogicalNode>()); return plan; @@ -311,7 +312,7 @@ public class PartitionedTableRewriter implements LogicalPlanRewriteRule { } private void updateTableStat(OverridableConf queryContext, PartitionedTableScanNode scanNode) - throws PlanningException { + throws TajoException { if (scanNode.getInputPaths().length > 0) { try { FileSystem fs = scanNode.getInputPaths()[0].getFileSystem(queryContext.getConf()); @@ -324,7 +325,7 @@ public class PartitionedTableRewriter implements LogicalPlanRewriteRule { } scanNode.getTableDesc().getStats().setNumBytes(totalVolume); } catch (Throwable e) { - throw new PlanningException(e); + throw new TajoInternalError(e); } } } @@ -396,7 +397,7 @@ public class PartitionedTableRewriter implements LogicalPlanRewriteRule { private final class Rewriter extends BasicLogicalPlanVisitor<OverridableConf, Object> { @Override public Object visitScan(OverridableConf queryContext, LogicalPlan plan, LogicalPlan.QueryBlock block, - ScanNode scanNode, Stack<LogicalNode> stack) throws PlanningException { + ScanNode scanNode, Stack<LogicalNode> stack) throws TajoException { TableDesc table = scanNode.getTableDesc(); if (!table.hasPartition()) { @@ -417,7 +418,7 @@ public class PartitionedTableRewriter implements LogicalPlanRewriteRule { PlannerUtil.replaceNode(plan, stack.peek(), scanNode, rewrittenScanNode); } } catch (IOException e) { - throw new PlanningException("Partitioned Table Rewrite Failed: \n" + e.getMessage()); + throw new TajoInternalError("Partitioned Table Rewrite Failed: \n" + e.getMessage()); } return null; } http://git-wip-us.apache.org/repos/asf/tajo/blob/4841c656/tajo-plan/src/main/java/org/apache/tajo/plan/rewrite/rules/ProjectionPushDownRule.java ---------------------------------------------------------------------- diff --git a/tajo-plan/src/main/java/org/apache/tajo/plan/rewrite/rules/ProjectionPushDownRule.java b/tajo-plan/src/main/java/org/apache/tajo/plan/rewrite/rules/ProjectionPushDownRule.java index 9a6e625..650a484 100644 --- a/tajo-plan/src/main/java/org/apache/tajo/plan/rewrite/rules/ProjectionPushDownRule.java +++ b/tajo-plan/src/main/java/org/apache/tajo/plan/rewrite/rules/ProjectionPushDownRule.java @@ -25,14 +25,19 @@ import org.apache.tajo.OverridableConf; import org.apache.tajo.annotation.Nullable; import org.apache.tajo.catalog.Column; import org.apache.tajo.catalog.Schema; +import org.apache.tajo.catalog.SchemaUtil; import org.apache.tajo.catalog.SortSpec; -import org.apache.tajo.plan.*; +import org.apache.tajo.catalog.exception.DuplicateColumnException; +import org.apache.tajo.exception.TajoException; +import org.apache.tajo.exception.TajoInternalError; +import org.apache.tajo.plan.LogicalPlan; import org.apache.tajo.plan.LogicalPlan.QueryBlock; +import org.apache.tajo.plan.LogicalPlanner; +import org.apache.tajo.plan.Target; import org.apache.tajo.plan.expr.*; import org.apache.tajo.plan.logical.*; import org.apache.tajo.plan.rewrite.LogicalPlanRewriteRule; import org.apache.tajo.plan.util.PlannerUtil; -import org.apache.tajo.catalog.SchemaUtil; import org.apache.tajo.plan.visitor.BasicLogicalPlanVisitor; import org.apache.tajo.util.TUtil; @@ -71,7 +76,7 @@ public class ProjectionPushDownRule extends } @Override - public LogicalPlan rewrite(OverridableConf queryContext, LogicalPlan plan) throws PlanningException { + public LogicalPlan rewrite(OverridableConf queryContext, LogicalPlan plan) throws TajoException { LogicalPlan.QueryBlock rootBlock = plan.getRootBlock(); LogicalPlan.QueryBlock topmostBlock = rootBlock; @@ -190,7 +195,7 @@ public class ProjectionPushDownRule extends * Add an expression with a specified name, which is usually an alias. * Later, you can refer this expression by the specified name. */ - private String add(String specifiedName, EvalNode evalNode) throws PlanningException { + private String add(String specifiedName, EvalNode evalNode) { // if a name already exists, it only just keeps an actual // expression instead of a column reference. @@ -205,7 +210,7 @@ public class ProjectionPushDownRule extends // The case where if existing reference name and a given reference name are the same to each other and // existing EvalNode and a given EvalNode is the different if (found.getType() != EvalType.FIELD && evalNode.getType() != EvalType.FIELD) { - throw new PlanningException("Duplicate alias: " + evalNode); + throw new DuplicateColumnException(evalNode.toString()); } if (found.getType() == EvalType.FIELD) { @@ -248,7 +253,7 @@ public class ProjectionPushDownRule extends * Adds an expression without any name. It returns an automatically * generated name. It can be also used for referring this expression. */ - public String add(EvalNode evalNode) throws PlanningException { + public String add(EvalNode evalNode) { String name; if (evalNode.getType() == EvalType.FIELD) { @@ -278,7 +283,7 @@ public class ProjectionPushDownRule extends return nameToIdBiMap.keySet(); } - public String add(Target target) throws PlanningException { + public String add(Target target) { return add(target.getCanonicalName(), target.getEvalTree()); } @@ -414,13 +419,13 @@ public class ProjectionPushDownRule extends targetListMgr = upperContext.targetListMgr; } - public String addExpr(Target target) throws PlanningException { + public String addExpr(Target target) { String reference = targetListMgr.add(target); addNecessaryReferences(target.getEvalTree()); return reference; } - public String addExpr(EvalNode evalNode) throws PlanningException { + public String addExpr(EvalNode evalNode) { String reference = targetListMgr.add(evalNode); addNecessaryReferences(evalNode); return reference; @@ -440,7 +445,7 @@ public class ProjectionPushDownRule extends @Override public LogicalNode visitRoot(Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, LogicalRootNode node, - Stack<LogicalNode> stack) throws PlanningException { + Stack<LogicalNode> stack) throws TajoException { LogicalNode child = super.visitRoot(context, plan, block, node, stack); node.setInSchema(child.getOutSchema()); node.setOutSchema(child.getOutSchema()); @@ -449,7 +454,7 @@ public class ProjectionPushDownRule extends @Override public LogicalNode visitProjection(Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, - ProjectionNode node, Stack<LogicalNode> stack) throws PlanningException { + ProjectionNode node, Stack<LogicalNode> stack) throws TajoException { Context newContext = new Context(context); Target [] targets = node.getTargets(); int targetNum = targets.length; @@ -520,7 +525,7 @@ public class ProjectionPushDownRule extends createTableNode.setInSchema(child.getOutSchema()); break; default: - throw new PlanningException("Unexpected Parent Node: " + parentNode.getType()); + throw new TajoInternalError("unexpected parent node: " + parentNode.getType()); } plan.addHistory("ProjectionNode is eliminated."); } @@ -533,7 +538,7 @@ public class ProjectionPushDownRule extends } public LogicalNode visitLimit(Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, LimitNode node, - Stack<LogicalNode> stack) throws PlanningException { + Stack<LogicalNode> stack) throws TajoException { LogicalNode child = super.visitLimit(context, plan, block, node, stack); node.setInSchema(child.getOutSchema()); @@ -543,7 +548,7 @@ public class ProjectionPushDownRule extends @Override public LogicalNode visitSort(Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, - SortNode node, Stack<LogicalNode> stack) throws PlanningException { + SortNode node, Stack<LogicalNode> stack) throws TajoException { Context newContext = new Context(context); final int sortKeyNum = node.getSortKeys().length; @@ -585,7 +590,7 @@ public class ProjectionPushDownRule extends @Override public LogicalNode visitHaving(Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, HavingNode node, - Stack<LogicalNode> stack) throws PlanningException { + Stack<LogicalNode> stack) throws TajoException { Context newContext = new Context(context); String referenceName = newContext.targetListMgr.add(node.getQual()); newContext.addNecessaryReferences(node.getQual()); @@ -607,7 +612,7 @@ public class ProjectionPushDownRule extends } public LogicalNode visitWindowAgg(Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, WindowAggNode node, - Stack<LogicalNode> stack) throws PlanningException { + Stack<LogicalNode> stack) throws TajoException { Context newContext = new Context(context); if (node.hasPartitionKeys()) { @@ -700,7 +705,7 @@ public class ProjectionPushDownRule extends } public LogicalNode visitGroupBy(Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, GroupbyNode node, - Stack<LogicalNode> stack) throws PlanningException { + Stack<LogicalNode> stack) throws TajoException { Context newContext = new Context(context); // Getting grouping key names @@ -758,7 +763,7 @@ public class ProjectionPushDownRule extends context.targetListMgr.markAsEvaluated(target); } } else { - throw new PlanningException("Cannot evaluate this expression in grouping keys: " + target.getEvalTree()); + throw new TajoInternalError("Cannot evaluate this expression in grouping keys: " + target.getEvalTree()); } } } @@ -821,7 +826,7 @@ public class ProjectionPushDownRule extends } public LogicalNode visitFilter(Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, - SelectionNode node, Stack<LogicalNode> stack) throws PlanningException { + SelectionNode node, Stack<LogicalNode> stack) throws TajoException { Context newContext = new Context(context); String referenceName = newContext.targetListMgr.add(node.getQual()); newContext.addNecessaryReferences(node.getQual()); @@ -843,7 +848,7 @@ public class ProjectionPushDownRule extends } private static void pushDownIfComplexTermInJoinCondition(Context ctx, EvalNode cnf, EvalNode term) - throws PlanningException { + throws TajoException { // If one of both terms in a binary operator is a complex expression, the binary operator will require // multiple phases. In this case, join cannot evaluate a binary operator. @@ -858,7 +863,7 @@ public class ProjectionPushDownRule extends } public LogicalNode visitJoin(Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, JoinNode node, - Stack<LogicalNode> stack) throws PlanningException { + Stack<LogicalNode> stack) throws TajoException { Context newContext = new Context(context); String joinQualReference = null; @@ -900,7 +905,7 @@ public class ProjectionPushDownRule extends if (node.hasJoinQual()) { Target target = context.targetListMgr.getTarget(joinQualReference); if (newContext.targetListMgr.isEvaluated(joinQualReference)) { - throw new PlanningException("Join condition must be evaluated in the proper Join Node: " + joinQualReference); + throw new TajoInternalError("Join condition must be evaluated in the proper Join Node: " + joinQualReference); } else { node.setJoinQual(target.getEvalTree()); newContext.targetListMgr.markAsEvaluated(target); @@ -1022,7 +1027,7 @@ public class ProjectionPushDownRule extends @Override public LogicalNode visitUnion(Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, UnionNode node, - Stack<LogicalNode> stack) throws PlanningException { + Stack<LogicalNode> stack) throws TajoException { LogicalPlan.QueryBlock leftBlock = plan.getBlock(node.getLeftChild()); LogicalPlan.QueryBlock rightBlock = plan.getBlock(node.getRightChild()); @@ -1040,7 +1045,7 @@ public class ProjectionPushDownRule extends } public LogicalNode visitScan(Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, ScanNode node, - Stack<LogicalNode> stack) throws PlanningException { + Stack<LogicalNode> stack) throws TajoException { Context newContext = new Context(context); @@ -1074,7 +1079,7 @@ public class ProjectionPushDownRule extends @Override public LogicalNode visitPartitionedTableScan(Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, PartitionedTableScanNode node, Stack<LogicalNode> stack) - throws PlanningException { + throws TajoException { Context newContext = new Context(context); @@ -1107,7 +1112,7 @@ public class ProjectionPushDownRule extends @Override public LogicalNode visitTableSubQuery(Context upperContext, LogicalPlan plan, LogicalPlan.QueryBlock block, - TableSubQueryNode node, Stack<LogicalNode> stack) throws PlanningException { + TableSubQueryNode node, Stack<LogicalNode> stack) throws TajoException { Context childContext = new Context(plan, upperContext.requiredSet); stack.push(node); LogicalNode child = super.visitTableSubQuery(childContext, plan, block, node, stack); @@ -1143,7 +1148,7 @@ public class ProjectionPushDownRule extends @Override public LogicalNode visitInsert(Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, InsertNode node, - Stack<LogicalNode> stack) throws PlanningException { + Stack<LogicalNode> stack) throws TajoException { stack.push(node); visit(context, plan, block, node.getChild(), stack); stack.pop();
