tajo-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From hyun...@apache.org
Subject git commit: TAJO-102: Add AlgebraVisitor and Refactor LogicalPlanner to use the visitor. (hyunsik)
Date Wed, 07 Aug 2013 00:52:09 GMT
Updated Branches:
  refs/heads/master 36dd87a32 -> 87420eb3a


TAJO-102: Add AlgebraVisitor and Refactor LogicalPlanner to use the visitor. (hyunsik)


Project: http://git-wip-us.apache.org/repos/asf/incubator-tajo/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-tajo/commit/87420eb3
Tree: http://git-wip-us.apache.org/repos/asf/incubator-tajo/tree/87420eb3
Diff: http://git-wip-us.apache.org/repos/asf/incubator-tajo/diff/87420eb3

Branch: refs/heads/master
Commit: 87420eb3a2a6e91ada5d05520c347f747ce20683
Parents: 36dd87a
Author: Hyunsik Choi <hyunsik@apache.org>
Authored: Wed Aug 7 09:48:29 2013 +0900
Committer: Hyunsik Choi <hyunsik@apache.org>
Committed: Wed Aug 7 09:49:43 2013 +0900

----------------------------------------------------------------------
 CHANGES.txt                                     |   2 +
 .../tajo/engine/planner/AlgebraVisitor.java     |  39 +++
 .../tajo/engine/planner/BaseAlgebraVisitor.java | 207 ++++++++++++
 .../tajo/engine/planner/LogicalOptimizer.java   |  26 +-
 .../apache/tajo/engine/planner/LogicalPlan.java |  18 +-
 .../tajo/engine/planner/LogicalPlanner.java     | 323 +++++++++----------
 .../tajo/engine/planner/TargetListManager.java  |  20 +-
 .../org/apache/tajo/master/GlobalEngine.java    |   2 +-
 .../org/apache/tajo/BackendTestingUtil.java     |   2 +-
 .../plan/global/TestGlobalQueryPlanner.java     |  17 +-
 .../engine/planner/TestLogicalOptimizer.java    |  10 +-
 .../global/TestGlobalQueryOptimizer.java        |   3 +-
 .../planner/physical/TestPhysicalPlanner.java   |  33 +-
 .../engine/planner/physical/TestSortExec.java   |   2 +-
 14 files changed, 472 insertions(+), 232 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/incubator-tajo/blob/87420eb3/CHANGES.txt
----------------------------------------------------------------------
diff --git a/CHANGES.txt b/CHANGES.txt
index 6f71a00..97eaa6b 100644
--- a/CHANGES.txt
+++ b/CHANGES.txt
@@ -15,6 +15,8 @@ Release 0.2.0 - unreleased
 
   IMPROVEMENTS
 
+    TAJO-102: Add AlgebraVisitor and Refactor LogicalPlanner to use the visitor.    (hyunsik)
+
     TAJO-87: Integration of tajo algebra module and SQL parser. (hyunsik)
 
     TAJO-70: Refactor GlobalEngine to handle DDL statements. (hyunsik)

http://git-wip-us.apache.org/repos/asf/incubator-tajo/blob/87420eb3/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/engine/planner/AlgebraVisitor.java
----------------------------------------------------------------------
diff --git a/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/engine/planner/AlgebraVisitor.java b/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/engine/planner/AlgebraVisitor.java
new file mode 100644
index 0000000..9dba5e1
--- /dev/null
+++ b/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/engine/planner/AlgebraVisitor.java
@@ -0,0 +1,39 @@
+/**
+ * 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.engine.planner;
+
+import org.apache.tajo.algebra.*;
+
+import java.util.Stack;
+
+public interface AlgebraVisitor<T1, T2> {
+  T2 visitProjection(T1 ctx, Stack<OpType> stack, Projection expr) throws PlanningException;
+  T2 visitLimit(T1 ctx, Stack<OpType> stack, Limit expr) throws PlanningException;
+  T2 visitSort(T1 ctx, Stack<OpType> stack, Sort expr) throws PlanningException;
+  T2 visitGroupBy(T1 ctx, Stack<OpType> stack, Aggregation expr) throws PlanningException;
+  T2 visitJoin(T1 ctx, Stack<OpType> stack, Join expr) throws PlanningException;
+  T2 visitFilter(T1 ctx, Stack<OpType> stack, Selection expr) throws PlanningException;
+  T2 visitUnion(T1 ctx, Stack<OpType> stack, SetOperation expr) throws PlanningException;
+  T2 visitExcept(T1 ctx, Stack<OpType> stack, SetOperation expr) throws PlanningException;
+  T2 visitIntersect(T1 ctx, Stack<OpType> stack, SetOperation expr) throws PlanningException;
+  T2 visitRelationList(T1 ctx, Stack<OpType> stack, RelationList expr) throws PlanningException;
+  T2 visitRelation(T1 ctx, Stack<OpType> stack, Relation expr) throws PlanningException;
+  T2 visitCreateTable(T1 ctx, Stack<OpType> stack, CreateTable expr) throws PlanningException;
+  T2 visitDropTable(T1 ctx, Stack<OpType> stack, DropTable expr) throws PlanningException;
+}

http://git-wip-us.apache.org/repos/asf/incubator-tajo/blob/87420eb3/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/engine/planner/BaseAlgebraVisitor.java
----------------------------------------------------------------------
diff --git a/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/engine/planner/BaseAlgebraVisitor.java b/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/engine/planner/BaseAlgebraVisitor.java
new file mode 100644
index 0000000..03eca32
--- /dev/null
+++ b/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/engine/planner/BaseAlgebraVisitor.java
@@ -0,0 +1,207 @@
+/**
+ * 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.engine.planner;
+
+import org.apache.tajo.algebra.*;
+
+import java.util.Stack;
+
+public abstract class BaseAlgebraVisitor<T1, T2> implements AlgebraVisitor<T1, T2> {
+
+  /**
+   * The prehook is called before each expression is visited.
+   */
+  public void preHook(T1 ctx, Stack<OpType> stack, Expr expr) throws PlanningException {
+  }
+
+
+  /**
+   * The posthook is called before each expression is visited.
+   */
+  public T2 postHook(T1 ctx, Stack<OpType> stack, Expr expr, T2 current) throws PlanningException {
+    return current;
+  }
+
+  /**
+   * visitChild visits each relational operator expression recursively.
+   *
+   * @param stack The stack contains the upper operators' type.
+   * @param expr The visiting relational operator
+   */
+  public T2 visitChild(T1 ctx, Stack<OpType> stack, Expr expr) throws PlanningException {
+    preHook(ctx, stack, expr);
+
+    T2 current;
+    switch (expr.getType()) {
+      case Projection:
+        current = visitProjection(ctx, stack, (Projection) expr);
+        break;
+      case Limit:
+        current = visitLimit(ctx, stack, (Limit) expr);
+        break;
+      case Sort:
+        current = visitSort(ctx, stack, (Sort) expr);
+        break;
+      case Aggregation:
+        current = visitGroupBy(ctx, stack, (Aggregation) expr);
+        break;
+      case Join:
+        current = visitJoin(ctx, stack, (Join) expr);
+        break;
+      case Filter:
+        current = visitFilter(ctx, stack, (Selection) expr);
+        break;
+      case Union:
+        current = visitUnion(ctx, stack, (SetOperation) expr);
+        break;
+      case Except:
+        current = visitExcept(ctx, stack, (SetOperation) expr);
+        break;
+      case Intersect:
+        current = visitIntersect(ctx, stack, (SetOperation) expr);
+        break;
+      case RelationList:
+        current = visitRelationList(ctx, stack, (RelationList) expr);
+        break;
+      case Relation:
+        current = visitRelation(ctx, stack, (Relation) expr);
+        break;
+      case CreateTable:
+        current = visitCreateTable(ctx, stack, (CreateTable) expr);
+        break;
+      case DropTable:
+        current = visitDropTable(ctx, stack, (DropTable) expr);
+        break;
+      default:
+        throw new PlanningException("Cannot support this type algebra \"" + expr.getType() + "\"");
+    }
+
+    postHook(ctx, stack, expr, current);
+
+    return current;
+  }
+
+  @Override
+  public T2 visitProjection(T1 ctx, Stack<OpType> stack, Projection expr) throws PlanningException {
+    stack.push(expr.getType());
+    T2 child = visitChild(ctx, stack, expr.getChild());
+    stack.pop();
+    return child;
+  }
+
+  @Override
+  public T2 visitLimit(T1 ctx, Stack<OpType> stack, Limit expr) throws PlanningException {
+    stack.push(expr.getType());
+    T2 child = visitChild(ctx, stack, expr.getChild());
+    stack.pop();
+    return child;
+  }
+
+  @Override
+  public T2 visitSort(T1 ctx, Stack<OpType> stack, Sort expr) throws PlanningException {
+    stack.push(expr.getType());
+    T2 child = visitChild(ctx, stack, expr.getChild());
+    stack.pop();
+    return child;
+  }
+
+  @Override
+  public T2 visitGroupBy(T1 ctx, Stack<OpType> stack, Aggregation expr) throws PlanningException {
+    stack.push(expr.getType());
+    T2 child = visitChild(ctx, stack, expr.getChild());
+    stack.pop();
+    return child;
+  }
+
+  @Override
+  public T2 visitJoin(T1 ctx, Stack<OpType> stack, Join expr) throws PlanningException {
+    stack.push(expr.getType());
+    T2 child = visitChild(ctx, stack, expr.getLeft());
+    visitChild(ctx, stack, expr.getRight());
+    stack.pop();
+    return child;
+  }
+
+  @Override
+  public T2 visitFilter(T1 ctx, Stack<OpType> stack, Selection expr) throws PlanningException {
+    stack.push(expr.getType());
+    T2 child = visitChild(ctx, stack, expr.getChild());
+    stack.pop();
+    return child;
+  }
+
+  @Override
+  public T2 visitUnion(T1 ctx, Stack<OpType> stack, SetOperation expr) throws PlanningException {
+    stack.push(expr.getType());
+    T2 child = visitChild(ctx, stack, expr.getLeft());
+    visitChild(ctx, stack, expr.getRight());
+    stack.pop();
+    return child;
+  }
+
+  @Override
+  public T2 visitExcept(T1 ctx, Stack<OpType> stack, SetOperation expr) throws PlanningException {
+    stack.push(expr.getType());
+    T2 child = visitChild(ctx, stack, expr.getLeft());
+    visitChild(ctx, stack, expr.getRight());
+    stack.pop();
+    return child;
+  }
+
+  @Override
+  public T2 visitIntersect(T1 ctx, Stack<OpType> stack, SetOperation expr) throws PlanningException {
+    stack.push(expr.getType());
+    T2 child = visitChild(ctx, stack, expr.getLeft());
+    visitChild(ctx, stack, expr.getRight());
+    stack.pop();
+    return child;
+  }
+
+  @Override
+  public T2 visitRelationList(T1 ctx, Stack<OpType> stack, RelationList expr) throws PlanningException {
+    stack.push(expr.getType());
+    T2 child = null;
+    for (Expr e : expr.getRelations()) {
+      child = visitChild(ctx, stack, e);
+    }
+    stack.pop();
+    return child;
+  }
+
+  @Override
+  public T2 visitRelation(T1 ctx, Stack<OpType> stack, Relation expr) throws PlanningException {
+    return null;
+  }
+
+  @Override
+  public T2 visitCreateTable(T1 ctx, Stack<OpType> stack, CreateTable expr) throws PlanningException {
+    stack.push(expr.getType());
+    T2 child = null;
+    if (expr.hasSubQuery()) {
+       child = visitChild(ctx, stack, expr.getSubQuery());
+    }
+    stack.pop();
+    return child;
+  }
+
+  @Override
+  public T2 visitDropTable(T1 ctx, Stack<OpType> stack, DropTable expr) throws PlanningException {
+    return null;
+  }
+}

http://git-wip-us.apache.org/repos/asf/incubator-tajo/blob/87420eb3/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/engine/planner/LogicalOptimizer.java
----------------------------------------------------------------------
diff --git a/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/engine/planner/LogicalOptimizer.java b/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/engine/planner/LogicalOptimizer.java
index 3cb83ad..ad245c0 100644
--- a/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/engine/planner/LogicalOptimizer.java
+++ b/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/engine/planner/LogicalOptimizer.java
@@ -60,7 +60,7 @@ public class LogicalOptimizer {
     }
   }
 
-  public static LogicalNode optimize(LogicalPlan plan) throws CloneNotSupportedException {
+  public static LogicalNode optimize(LogicalPlan plan) throws PlanningException {
     LogicalNode toBeOptimized;
 
     toBeOptimized = plan.getRootBlock().getRoot();
@@ -224,7 +224,7 @@ public class LogicalOptimizer {
    * @param plan
    */
   private static void pushProjection(LogicalPlan plan)
-      throws CloneNotSupportedException {
+      throws PlanningException {
     Stack<LogicalNode> stack = new Stack<LogicalNode>();
 
     OptimizationContext optCtx;
@@ -260,7 +260,7 @@ public class LogicalOptimizer {
   private static LogicalNode pushProjectionRecursive(
       final LogicalPlan plan, final OptimizationContext optContext,
       final LogicalNode node, final Stack<LogicalNode> stack,
-      final Set<Column> upperRequired) throws CloneNotSupportedException {
+      final Set<Column> upperRequired) throws PlanningException {
 
     LogicalNode currentNode = null;
 
@@ -307,7 +307,7 @@ public class LogicalOptimizer {
   }
 
   private static LogicalNode pushDownCommonPost(LogicalPlan plan, OptimizationContext context, UnaryNode node,
-                                                Set<Column> upperRequired, Stack<LogicalNode> stack) throws CloneNotSupportedException {
+                                                Set<Column> upperRequired, Stack<LogicalNode> stack) throws PlanningException {
     stack.push(node);
     LogicalNode child = pushProjectionRecursive(plan, context,
         node.getSubNode(), stack, upperRequired);
@@ -323,7 +323,7 @@ public class LogicalOptimizer {
 
   private static LogicalNode pushDownProjection(LogicalPlan plan, OptimizationContext context,
                                                    ProjectionNode projNode, Set<Column> upperRequired,
-                                                   Stack<LogicalNode> path) throws CloneNotSupportedException {
+                                                   Stack<LogicalNode> path) throws PlanningException {
 
     for (Target target : projNode.getTargets()) {
       upperRequired.add(target.getColumnSchema());
@@ -352,7 +352,7 @@ public class LogicalOptimizer {
 
   private static LogicalNode pushDownSelection(LogicalPlan plan, OptimizationContext context,
                                                  SelectionNode selectionNode, Set<Column> upperRequired,
-                                                 Stack<LogicalNode> path) throws CloneNotSupportedException {
+                                                 Stack<LogicalNode> path) throws PlanningException {
     if (selectionNode.getQual() != null) {
       upperRequired.addAll(EvalTreeUtil.findDistinctRefColumns(selectionNode.getQual()));
     }
@@ -362,7 +362,7 @@ public class LogicalOptimizer {
 
   private static GroupbyNode pushDownGroupBy(LogicalPlan plan, OptimizationContext context, GroupbyNode groupbyNode,
                                              Set<Column> upperRequired, Stack<LogicalNode> stack)
-      throws CloneNotSupportedException {
+      throws PlanningException {
 
     Set<Column> currentRequired = new HashSet<Column>(upperRequired);
 
@@ -379,8 +379,7 @@ public class LogicalOptimizer {
   }
 
   private static SortNode pushDownSort(LogicalPlan plan, OptimizationContext context, SortNode sortNode,
-                                       Set<Column> upperRequired, Stack<LogicalNode> stack)
-      throws CloneNotSupportedException {
+                                       Set<Column> upperRequired, Stack<LogicalNode> stack) throws PlanningException {
 
     for (SortSpec spec : sortNode.getSortKeys()) {
       upperRequired.add(spec.getSortKey());
@@ -393,7 +392,7 @@ public class LogicalOptimizer {
 
   private static JoinNode pushDownJoin(LogicalPlan plan, OptimizationContext context, JoinNode joinNode,
                                        Set<Column> upperRequired, Stack<LogicalNode> path)
-      throws CloneNotSupportedException {
+      throws PlanningException {
     Set<Column> currentRequired = Sets.newHashSet(upperRequired);
 
     if (joinNode.hasTargets()) {
@@ -425,8 +424,7 @@ public class LogicalOptimizer {
   }
 
   private static BinaryNode pushDownSetNode(LogicalPlan plan, OptimizationContext context, UnionNode node,
-                                            Set<Column> upperRequired, Stack<LogicalNode> stack)
-      throws CloneNotSupportedException {
+                                            Set<Column> upperRequired, Stack<LogicalNode> stack) throws PlanningException {
     BinaryNode setNode = node;
 
     LogicalPlan.QueryBlock leftBlock = plan.getBlock(setNode.getOuterNode());
@@ -452,7 +450,7 @@ public class LogicalOptimizer {
 
   private static ScanNode pushdownScanNode(OptimizationContext optContext, ScanNode scanNode,
                                            Set<Column> upperRequired, Stack<LogicalNode> stack)
-      throws CloneNotSupportedException {
+      throws PlanningException {
     return (ScanNode) pushDownProjectablePost(optContext, scanNode, upperRequired, isTopmostProjectable(stack));
   }
 
@@ -468,7 +466,7 @@ public class LogicalOptimizer {
 
   private static LogicalNode pushDownProjectablePost(OptimizationContext context, LogicalNode node,
                                                      Set<Column> upperRequired, boolean last)
-      throws CloneNotSupportedException {
+      throws PlanningException {
     TargetListManager targetListManager = context.getTargetListManager();
     EvalNode expr;
 

http://git-wip-us.apache.org/repos/asf/incubator-tajo/blob/87420eb3/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/engine/planner/LogicalPlan.java
----------------------------------------------------------------------
diff --git a/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/engine/planner/LogicalPlan.java b/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/engine/planner/LogicalPlan.java
index 5a9f101..8c39d00 100644
--- a/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/engine/planner/LogicalPlan.java
+++ b/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/engine/planner/LogicalPlan.java
@@ -19,6 +19,7 @@
 package org.apache.tajo.engine.planner;
 
 import org.apache.tajo.algebra.ColumnReferenceExpr;
+import org.apache.tajo.algebra.OpType;
 import org.apache.tajo.algebra.Projection;
 import org.apache.tajo.annotation.NotThreadSafe;
 import org.apache.tajo.catalog.Column;
@@ -101,7 +102,7 @@ public class LogicalPlan {
     return queryBlocks.values();
   }
 
-  public boolean postVisit(String blockName, LogicalNode node, Stack<ExprType> path) {
+  public boolean postVisit(String blockName, LogicalNode node, Stack<OpType> path) {
     if (visited.contains(node)) {
       return false;
     }
@@ -179,7 +180,7 @@ public class LogicalPlan {
    */
   public Column findColumnFromChildNode(ColumnReferenceExpr columnRef, String blockName,
                                         LogicalNode node)
-      throws VerifyException{
+      throws VerifyException {
     List<Column> candidates = new ArrayList<Column>();
 
     Column candidate;
@@ -445,7 +446,7 @@ public class LogicalPlan {
      * It requires node's default output schemas.
      * @param node
      */
-    public void checkAndSetEvaluatedTargets(LogicalNode node) {
+    public void checkAndSetEvaluatedTargets(LogicalNode node) throws PlanningException {
       if (!(node instanceof Projectable)) {
         return;
       }
@@ -518,7 +519,7 @@ public class LogicalPlan {
 
           if (newEvaluatedTargetIds.size() > 0) {
             // fill addedTargets with output columns and new expression columns (e.g., aliased column or expressions)
-            Target [] addedTargets = new Target[baseSchema.getColumnNum() + newEvaluatedTargetIds.size()];
+            Target[] addedTargets = new Target[baseSchema.getColumnNum() + newEvaluatedTargetIds.size()];
             PlannerUtil.schemaToTargets(baseSchema, addedTargets);
             int baseIdx = baseSchema.getColumnNum();
             for (int i = 0; i < newEvaluatedTargetIds.size(); i++) {
@@ -542,11 +543,8 @@ public class LogicalPlan {
       }
 
       // replace the evaluated targets for upper operators
-      try {
-        targetListManager.getUpdatedTarget();
-      } catch (CloneNotSupportedException e) {
-        throw new InternalError(e.getMessage());
-      }
+      targetListManager.getUpdatedTarget();
+
 
       if (targetListManager.isAllEvaluated()) {
         schema = targetListManager.getUpdatedSchema();
@@ -557,7 +555,7 @@ public class LogicalPlan {
       return targetListManager;
     }
 
-    public Target [] getCurrentTargets() {
+    public Target[] getCurrentTargets() {
       return targetListManager.getTargets();
     }
   }

http://git-wip-us.apache.org/repos/asf/incubator-tajo/blob/87420eb3/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/engine/planner/LogicalPlanner.java
----------------------------------------------------------------------
diff --git a/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/engine/planner/LogicalPlanner.java b/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/engine/planner/LogicalPlanner.java
index d8bb157..dab58b9 100644
--- a/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/engine/planner/LogicalPlanner.java
+++ b/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/engine/planner/LogicalPlanner.java
@@ -36,7 +36,6 @@ import org.apache.tajo.engine.eval.EvalNode.Type;
 import org.apache.tajo.engine.planner.LogicalPlan.QueryBlock;
 import org.apache.tajo.engine.planner.logical.*;
 import org.apache.tajo.engine.query.exception.InvalidQueryException;
-import org.apache.tajo.engine.query.exception.NotSupportQueryException;
 import org.apache.tajo.engine.query.exception.UndefinedFunctionException;
 import org.apache.tajo.engine.utils.SchemaUtil;
 import org.apache.tajo.exception.InternalException;
@@ -50,9 +49,16 @@ import static org.apache.tajo.algebra.Aggregation.GroupType;
  * This class creates a logical plan from a parse tree ({@link org.apache.tajo.engine.parser.SQLAnalyzer})
  * generated by {@link org.apache.tajo.engine.parser.SQLAnalyzer}.
  *
- * @see org.apache.tajo.engine.parser
+ * Relational operators can be divided into two categories as follows:
+ * <oi>
+ *  <li>General operator: this type operators do not affect the tuple schema.
+ *  Selection, Sort, and Limit belong to this type.</li>
+ *  <li>Projectable operator: this type operators affects the tuple schema.
+ *  Scan, Groupby, and Join belong to this type.
+ *  </li>
+ * </oi>
  */
-public class LogicalPlanner {
+public class LogicalPlanner extends BaseAlgebraVisitor<LogicalPlanner.PlanContext, LogicalNode> {
   private static Log LOG = LogFactory.getLog(LogicalPlanner.class);
   private final CatalogService catalog;
 
@@ -60,6 +66,16 @@ public class LogicalPlanner {
     this.catalog = catalog;
   }
 
+  public static class PlanContext {
+    LogicalPlan plan;
+    QueryBlock block;
+
+    public PlanContext(LogicalPlan plan, QueryBlock block) {
+      this.plan = plan;
+      this.block = block;
+    }
+  }
+
   /**
    * This generates a logical plan.
    *
@@ -71,15 +87,13 @@ public class LogicalPlanner {
     LogicalPlan plan = new LogicalPlan(this);
     LogicalNode subroot = null;
 
-    Stack<ExprType> stack =
-        new Stack<ExprType>();
+    Stack<OpType> stack =new Stack<OpType>();
 
     QueryBlock rootBlock = plan.newAndGetBlock(LogicalPlan.ROOT_BLOCK);
+    PlanContext context = new PlanContext(plan, rootBlock);
     try {
-      subroot = createPlanInternal(plan, rootBlock, expr, stack);
-    } catch (CloneNotSupportedException e) {
-      throw new InvalidQueryException(e);
-    } catch (VerifyException e) {
+      subroot = visitChild(context, stack, expr);
+    } catch (PlanningException e) {
       e.printStackTrace();
     }
 
@@ -92,90 +106,23 @@ public class LogicalPlanner {
     return plan;
   }
 
-  /**
-   * Relational operators can be divided into two categories as follows:
-   * <oi>
-   *  <li>General operator: this type operators do not affect tuple schema and do not evaluate
-   *  expressions. Selection, Sort, and Limit belong to this operator.</li>
-   *  <li>Projectable operator: this type operators affects tuple schema and evaluate expressions.
-   *  Scan, Groupby, and Join belong to this operators.
-   *  </li>
-   * </oi>
-   */
-  private LogicalNode createPlanInternal(LogicalPlan plan, QueryBlock block, Expr expr, Stack<ExprType> stack)
-      throws CloneNotSupportedException, VerifyException {
-    LogicalNode currentNode;
-    QueryBlock currentBlock = checkNewBlockAndGet(plan, block.getName());
-
-    switch(expr.getType()) {
-      case Projection:
-        Projection projection = (Projection) expr;
-        currentNode = buildProjectionNode(plan, currentBlock, projection, stack);
-        break;
-
-      case Filter:
-        Selection selection = (Selection) expr;
-        currentNode = buildSelectionNode(plan, currentBlock, selection, stack);
-        break;
-
-      case Aggregation:
-        Aggregation aggregation = (Aggregation) expr;
-        currentNode = buildGroupingPlan(plan, currentBlock, aggregation, stack);
-        break;
-
-      case Join:
-        Join join = (Join) expr;
-        currentNode = buildExplicitJoinPlan(plan, currentBlock, join, stack);
-        break;
-
-      case Sort:
-        Sort sort = (Sort) expr;
-        currentNode = buildSortPlan(plan, currentBlock, sort, stack);
-        break;
-
-      case Limit:
-        Limit limit = (Limit) expr;
-        currentNode = buildLimitPlan(plan, currentBlock, limit, stack);
-        break;
-
-      case Union:
-      case Except:
-      case Intersect:
-        SetOperation setOp = (SetOperation) expr;
-        currentNode = buildSetPlan(plan, currentBlock, setOp, stack);
-        break;
-
-
-      case RelationList:
-        currentNode = buildRelationListPlan(plan, currentBlock, (RelationList) expr, stack);
-        if (((RelationList) expr).size() == 1) { // skip visitPost because it is already visited
-          return currentNode;
-        }
-        break;
-
-      case Relation:
-        currentNode = buildScanPlan(currentBlock, expr);
-        break;
-
-      case CreateTable:
-        CreateTable createTable = (CreateTable) expr;
-        currentNode = buildCreateTable(plan, currentBlock, createTable, stack);
-        break;
-
-      case DropTable:
-        DropTable dropTable = (DropTable) expr;
-        currentNode = buildDropTable(dropTable);
-        break;
+  public void preHook(PlanContext context, Stack<OpType> stack, Expr expr) {
+    context.block = checkNewBlockAndGet(context.plan, context.block.getName());
+  }
 
-      default:
-        throw new NotSupportQueryException(expr.getType().name());
+  public LogicalNode postHook(PlanContext context, Stack<OpType> stack, Expr expr, LogicalNode current)
+      throws PlanningException {
+    // == Post work ==
+    if (expr.getType() == OpType.RelationList && ((RelationList) expr).size() == 1) {
+      return current;
     }
 
     // mark the node as the visited node and do post work for each operator
-    plan.postVisit(block.getName(), currentNode, stack);
+    context.plan.postVisit(context.block.getName(), current, stack);
     // check and set evaluated targets and update in/out schemas
-    currentBlock.checkAndSetEvaluatedTargets(currentNode);
-    return currentNode;
+    context.block.checkAndSetEvaluatedTargets(current);
+
+    return current;
   }
 
   /**
@@ -191,7 +138,8 @@ public class LogicalPlanner {
     }
   }
 
-  private ScanNode buildScanPlan(QueryBlock block, Expr expr)
+  @Override
+  public ScanNode visitRelation(PlanContext context, Stack<OpType> stack, Relation expr)
       throws VerifyException {
     // 1. init phase
 
@@ -213,11 +161,11 @@ public class LogicalPlanner {
   /*===============================================================================================
     JOIN SECTION
    ===============================================================================================*/
-  private LogicalNode buildRelationListPlan(LogicalPlan plan, QueryBlock block,
-                                            RelationList relations, Stack<ExprType> stack)
-      throws VerifyException, CloneNotSupportedException {
+  @Override
+  public LogicalNode visitRelationList(PlanContext context, Stack<OpType> stack, RelationList relations)
+      throws PlanningException {
 
-    LogicalNode current = createPlanInternal(plan, block, relations.getRelations()[0], stack);
+    LogicalNode current = visitChild(context, stack, relations.getRelations()[0]);
 
     LogicalNode left;
     LogicalNode right;
@@ -225,7 +173,7 @@ public class LogicalPlanner {
 
       for (int i = 1; i < relations.size(); i++) {
         left = current;
-        right = createPlanInternal(plan, block, relations.getRelations()[i], stack);
+        right = visitChild(context, stack, relations.getRelations()[i]);
         current = createCatasianProduct(left, right);
       }
     }
@@ -233,13 +181,17 @@ public class LogicalPlanner {
     return current;
   }
 
-  private LogicalNode buildExplicitJoinPlan(LogicalPlan plan, QueryBlock block, Join join, Stack<ExprType> stack)
-      throws VerifyException, CloneNotSupportedException {
+  @Override
+  public LogicalNode visitJoin(PlanContext context, Stack<OpType> stack, Join join)
+      throws PlanningException {
     // Phase 1: Init
+    LogicalPlan plan = context.plan;
+    QueryBlock block = context.block;
+
     // Phase 2: build child plans
-    stack.push(ExprType.JOIN);
-    LogicalNode left = createPlanInternal(plan, block, join.getLeft(), stack);
-    LogicalNode right = createPlanInternal(plan, block, join.getRight(), stack);
+    stack.push(OpType.Join);
+    LogicalNode left = visitChild(context, stack, join.getLeft());
+    LogicalNode right = visitChild(context, stack, join.getRight());
     stack.pop();
 
     // Phase 3: build this plan
@@ -328,19 +280,42 @@ public class LogicalPlanner {
   /*===============================================================================================
     SET OPERATION SECTION
    ===============================================================================================*/
-  private LogicalNode buildSetPlan(LogicalPlan plan, QueryBlock block, SetOperation setOperation,
-                                   Stack<ExprType> stack) throws VerifyException, CloneNotSupportedException {
-    LogicalNode left;
-    LogicalNode right;
 
-    QueryBlock leftBlock = plan.newAnonymousBlock();
-    Stack<ExprType> leftStack = new Stack<ExprType>();
-    left = createPlanInternal(plan, leftBlock, setOperation.getLeft(), leftStack);
-    Stack<ExprType> rightStack = new Stack<ExprType>();
-    QueryBlock rightBlock = plan.newAnonymousBlock();
-    right = createPlanInternal(plan, rightBlock, setOperation.getRight(), rightStack);
+  @Override
+  public LogicalNode visitUnion(PlanContext context, Stack<OpType> stack, SetOperation setOperation)
+      throws PlanningException {
+    return buildSetPlan(context, stack, setOperation);
+  }
+
+  @Override
+  public LogicalNode visitExcept(PlanContext context, Stack<OpType> stack, SetOperation setOperation)
+      throws PlanningException {
+    return buildSetPlan(context, stack, setOperation);
+  }
+
+  @Override
+  public LogicalNode visitIntersect(PlanContext context, Stack<OpType> stack, SetOperation setOperation)
+      throws PlanningException {
+    return buildSetPlan(context, stack, setOperation);
+  }
+
+  private LogicalNode buildSetPlan(PlanContext context, Stack<OpType> stack, SetOperation setOperation)
+      throws PlanningException {
+
+    // 1. Init Phase
+    LogicalPlan plan = context.plan;
+    QueryBlock block = context.block;
+
+    // 2. Build Child Plans
+    PlanContext leftContext = new PlanContext(plan, plan.newAnonymousBlock());
+    Stack<OpType> leftStack = new Stack<OpType>();
+    LogicalNode left = visitChild(leftContext, leftStack, setOperation.getLeft());
+
+    PlanContext rightContext = new PlanContext(plan, plan.newAnonymousBlock());
+    Stack<OpType> rightStack = new Stack<OpType>();
+    LogicalNode right = visitChild(rightContext, rightStack, setOperation.getRight());
 
-    verifySetStatement(setOperation.getType(), leftBlock, rightBlock);
+    verifySetStatement(setOperation.getType(), leftContext.block, rightContext.block);
 
     BinaryNode setOp;
     if (setOperation.getType() == OpType.Union) {
@@ -355,7 +330,7 @@ public class LogicalPlanner {
 
     // Strip the table names from the targets of the both blocks
     // in order to check the equivalence the schemas of both blocks.
-    Target [] leftStrippedTargets = PlannerUtil.stripTarget(leftBlock.getCurrentTargets());
+    Target[] leftStrippedTargets = PlannerUtil.stripTarget(leftContext.block.getCurrentTargets());
 
     Schema outSchema = PlannerUtil.targetToSchema(leftStrippedTargets);
     setOp.setInSchema(left.getOutSchema());
@@ -364,10 +339,6 @@ public class LogicalPlanner {
     setOp.setInner(right);
 
     if (isNoUpperProjection(stack)) {
-//      ProjectionNode projectionNode = new ProjectionNode(leftStrippedTargets);
-//      projectionNode.setSubNode(setOp);
-
-//      localBlock.setProjectionNode(projectionNode);
       block.targetListManager = new TargetListManager(plan, leftStrippedTargets);
       block.targetListManager.setEvaluatedAll();
       block.targetListManager.getUpdatedTarget();
@@ -384,8 +355,8 @@ public class LogicalPlanner {
       throw new VerifyException("ERROR: each " + type.name() + " query must have the same number of columns");
     }
 
-    Target [] targets1 = left.getCurrentTargets();
-    Target [] targets2 = right.getCurrentTargets();
+    Target[] targets1 = left.getCurrentTargets();
+    Target[] targets2 = right.getCurrentTargets();
 
     for (int i = 0; i < targets1.length; i++) {
       if (!targets1[i].getDataType().equals(targets2[i].getDataType())) {
@@ -397,14 +368,16 @@ public class LogicalPlanner {
     return true;
   }
 
-  private SelectionNode buildSelectionNode(LogicalPlan plan, QueryBlock block, Selection selection,
-                                           Stack<ExprType> stack)
-      throws VerifyException, CloneNotSupportedException {
+  @Override
+  public SelectionNode visitFilter(PlanContext context, Stack<OpType> stack, Selection selection)
+      throws PlanningException {
     // 1. init phase:
+    LogicalPlan plan = context.plan;
+    QueryBlock block = context.block;
 
     // 2. build child plans:
-    stack.push(ExprType.SELECTION);
-    LogicalNode child = createPlanInternal(plan, block, selection.getChild(), stack);
+    stack.push(OpType.Filter);
+    LogicalNode child = visitChild(context, stack, selection.getChild());
     stack.pop();
 
     // 3. build this plan:
@@ -426,15 +399,17 @@ public class LogicalPlanner {
     GROUP BY SECTION
    ===============================================================================================*/
 
-  private LogicalNode buildGroupingPlan(LogicalPlan plan, QueryBlock block, Aggregation aggregation,
-                                        Stack<ExprType> stack)
-      throws VerifyException, CloneNotSupportedException {
+  @Override
+  public LogicalNode visitGroupBy(PlanContext context, Stack<OpType> stack, Aggregation aggregation)
+      throws PlanningException {
 
     // 1. Initialization Phase:
+    LogicalPlan plan = context.plan;
+    QueryBlock block = context.block;
 
     // 2. Build Child Plan Phase:
-    stack.push(ExprType.GROUP_BY);
-    LogicalNode child = createPlanInternal(plan, block, aggregation.getChild(), stack);
+    stack.push(OpType.Aggregation);
+    LogicalNode child = visitChild(context, stack, aggregation.getChild());
     stack.pop();
 
     // 3. Build This Plan:
@@ -463,7 +438,7 @@ public class LogicalPlanner {
       return groupingNode;
 
     } else if (groupElements[0].getType() == GroupType.Cube) { // for cube by
-      List<Column []> cuboids  = generateCuboids(annotateGroupingColumn(plan, block.getName(),
+      List<Column[]> cuboids  = generateCuboids(annotateGroupingColumn(plan, block.getName(),
           groupElements[0].getColumns(), child));
       UnionNode topUnion = createGroupByUnion(plan, block, child, cuboids, 0);
       block.resolveGrouping();
@@ -478,13 +453,13 @@ public class LogicalPlanner {
   private UnionNode createGroupByUnion(final LogicalPlan plan,
                                        final QueryBlock block,
                                        final LogicalNode subNode,
-                                       final List<Column []> cuboids,
+                                       final List<Column[]> cuboids,
                                        final int idx) {
     UnionNode union;
     try {
       if ((cuboids.size() - idx) > 2) {
         GroupbyNode g1 = new GroupbyNode(cuboids.get(idx));
-        Target [] clone = cloneTargets(block.getCurrentTargets());
+        Target[] clone = cloneTargets(block.getCurrentTargets());
 
         g1.setTargets(clone);
         g1.setSubNode((LogicalNode) subNode.clone());
@@ -500,7 +475,7 @@ public class LogicalPlanner {
         return union;
       } else {
         GroupbyNode g1 = new GroupbyNode(cuboids.get(idx));
-        Target [] clone = cloneTargets(block.getCurrentTargets());
+        Target[] clone = cloneTargets(block.getCurrentTargets());
         g1.setTargets(clone);
         g1.setSubNode((LogicalNode) subNode.clone());
         g1.setInSchema(g1.getSubNode().getOutSchema());
@@ -529,10 +504,10 @@ public class LogicalPlanner {
   /**
    * It transforms a list of column references into a list of annotated columns with considering aliased expressions.
    */
-  private Column [] annotateGroupingColumn(LogicalPlan plan, String blockName,
+  private Column[] annotateGroupingColumn(LogicalPlan plan, String blockName,
                                            ColumnReferenceExpr[] columnRefs, LogicalNode child)
       throws VerifyException {
-    Column [] columns = new Column[columnRefs.length];
+    Column[] columns = new Column[columnRefs.length];
     for (int i = 0; i < columnRefs.length; i++) {
       columns[i] = plan.findColumnFromChildNode(columnRefs[i], blockName, child);
     }
@@ -540,9 +515,9 @@ public class LogicalPlanner {
     return columns;
   }
 
-  private static Target [] cloneTargets(Target [] sourceTargets)
+  private static Target[] cloneTargets(Target[] sourceTargets)
       throws CloneNotSupportedException {
-    Target [] clone = new Target[sourceTargets.length];
+    Target[] clone = new Target[sourceTargets.length];
     for (int i = 0; i < sourceTargets.length; i++) {
       clone[i] = (Target) sourceTargets[i].clone();
     }
@@ -550,13 +525,13 @@ public class LogicalPlanner {
     return clone;
   }
 
-  public static final Column [] ALL= Lists.newArrayList().toArray(new Column[0]);
+  public static final Column[] ALL= Lists.newArrayList().toArray(new Column[0]);
 
-  public static List<Column []> generateCuboids(Column [] columns) {
+  public static List<Column[]> generateCuboids(Column[] columns) {
     int numCuboids = (int) Math.pow(2, columns.length);
     int maxBits = columns.length;
 
-    List<Column []> cube = Lists.newArrayList();
+    List<Column[]> cube = Lists.newArrayList();
     List<Column> cuboidCols;
 
     cube.add(ALL);
@@ -577,18 +552,21 @@ public class LogicalPlanner {
     SORT SECTION
    ===============================================================================================*/
 
-  private SortNode buildSortPlan(LogicalPlan plan, QueryBlock block, Sort sort, Stack<ExprType> stack)
-      throws VerifyException, CloneNotSupportedException {
+  @Override
+  public SortNode visitSort(PlanContext context, Stack<OpType> stack, Sort sort) throws PlanningException {
 
     // 1. Initialization Phase:
+    LogicalPlan plan = context.plan;
+    QueryBlock block = context.block;
+
     // 2. Build Child Plans:
-    stack.push(ExprType.SORT);
-    LogicalNode child = createPlanInternal(plan, block, sort.getChild(), stack);
+    stack.push(OpType.Sort);
+    LogicalNode child = visitChild(context, stack, sort.getChild());
     child = insertGroupingIfUnresolved(plan, block.getName(), child, stack);
     stack.pop();
 
     // 3. Build this plan:
-    SortSpec [] annotatedSortSpecs = new SortSpec[sort.getSortSpecs().length];
+    SortSpec[] annotatedSortSpecs = new SortSpec[sort.getSortSpecs().length];
     Column column;
     Sort.SortSpec[] sortSpecs = sort.getSortSpecs();
     for (int i = 0; i < sort.getSortSpecs().length; i++) {
@@ -606,11 +584,15 @@ public class LogicalPlanner {
     return sortNode;
   }
 
-  private LimitNode buildLimitPlan(LogicalPlan plan, QueryBlock block, Limit limit, Stack<ExprType> stack)
-      throws VerifyException, CloneNotSupportedException {
+  @Override
+  public LimitNode visitLimit(PlanContext context, Stack<OpType> stack, Limit limit) throws PlanningException {
+    // 1. Init Phase:
+    LogicalPlan plan = context.plan;
+    QueryBlock block = context.block;
+
     // build child plans
-    stack.push(ExprType.LIMIT);
-    LogicalNode child = createPlanInternal(plan, block, limit.getChild(), stack);
+    stack.push(OpType.Limit);
+    LogicalNode child = visitChild(context, stack, limit.getChild());
     stack.pop();
 
     // build limit plan
@@ -629,11 +611,14 @@ public class LogicalPlanner {
     PROJECTION SECTION
    ===============================================================================================*/
 
-  private LogicalNode buildProjectionNode(LogicalPlan plan, QueryBlock block,
-                                          Projection projection, Stack<ExprType> stack)
-      throws VerifyException, CloneNotSupportedException {
+  @Override
+  public LogicalNode visitProjection(PlanContext context, Stack<OpType> stack, Projection projection)
+      throws PlanningException {
 
     //1: init Phase
+    LogicalPlan plan = context.plan;
+    QueryBlock block = context.block;
+
     block.setProjection(projection);
     if (!projection.isAllProjected()) {
       block.targetListManager = new TargetListManager(plan, projection.size());
@@ -651,8 +636,8 @@ public class LogicalPlanner {
     }
 
     // 2: Build Child Plans
-    stack.push(ExprType.PROJECTION);
-    LogicalNode child = createPlanInternal(plan, block, projection.getChild(), stack);
+    stack.push(OpType.Projection);
+    LogicalNode child = visitChild(context, stack, projection.getChild());
     child = insertGroupingIfUnresolved(plan, block.getName(), child, stack);
     stack.pop();
 
@@ -694,7 +679,7 @@ public class LogicalPlanner {
    * It is used only when a group-by clause is not given.
    */
   private LogicalNode insertGroupingIfUnresolved(LogicalPlan plan, String blockName,
-                                                 LogicalNode child, Stack<ExprType> stack) {
+                                                 LogicalNode child, Stack<OpType> stack) throws PlanningException {
     QueryBlock block = plan.getBlock(blockName);
     if (!block.isGroupingResolved()) {
       GroupbyNode groupbyNode = new GroupbyNode(new Column[] {});
@@ -710,9 +695,9 @@ public class LogicalPlanner {
     }
   }
 
-  private boolean isNoUpperProjection(Stack<ExprType> stack) {
-    for (ExprType node : stack) {
-      if (!( (node == ExprType.PROJECTION) || (node == ExprType.GROUP_BY) || (node == ExprType.JOIN) )) {
+  private boolean isNoUpperProjection(Stack<OpType> stack) {
+    for (OpType node : stack) {
+      if (!( (node == OpType.Projection) || (node == OpType.Aggregation) || (node == OpType.Join) )) {
         return false;
       }
     }
@@ -724,14 +709,15 @@ public class LogicalPlanner {
     Data Definition Language (DDL) SECTION
    ===============================================================================================*/
 
-  private LogicalNode buildCreateTable(LogicalPlan plan, QueryBlock block, CreateTable expr, Stack<ExprType> stack)
-      throws VerifyException, CloneNotSupportedException {
+  @Override
+  public LogicalNode visitCreateTable(PlanContext context, Stack<OpType> stack, CreateTable expr)
+      throws PlanningException {
 
      String tableName = expr.getTableName();
 
     if (expr.hasSubQuery()) {
-      stack.add(ExprType.CREATE_TABLE);
-      LogicalNode subQuery = createPlanInternal(plan, block, expr.getSubQuery(), stack);
+      stack.add(OpType.CreateTable);
+      LogicalNode subQuery = visitChild(context, stack, expr.getSubQuery());
       stack.pop();
       StoreTableNode storeNode = new StoreTableNode(tableName);
       storeNode.setSubNode(subQuery);
@@ -788,6 +774,8 @@ public class LogicalPlanner {
     }
   }
 
+
+
   /**
    * It transforms table definition elements to schema.
    *
@@ -807,7 +795,8 @@ public class LogicalPlanner {
     return schema;
   }
 
-  private LogicalNode buildDropTable(DropTable dropTable) {
+  @Override
+  public LogicalNode visitDropTable(PlanContext context, Stack<OpType> stack, DropTable dropTable) {
     DropTableNode dropTableNode = new DropTableNode(dropTable.getTableName());
     return dropTableNode;
   }
@@ -880,18 +869,18 @@ public class LogicalPlanner {
           plan.getBlock(blockName).setHasGrouping();
 
           return new AggFuncCallEval(countRows, (AggFunction) countRows.newInstance(),
-              new EvalNode [] {});
+              new EvalNode[] {});
         } catch (InternalException e) {
           throw new UndefinedFunctionException(CatalogUtil.
-              getCanonicalName(countRows.getSignature(), new DataType[] {}));
+              getCanonicalName(countRows.getSignature(), new DataType[]{}));
         }
 
       case CountValueFunction:
       case Function:
         FunctionExpr function = (FunctionExpr) expr;
         // Given parameters
-        Expr [] params = function.getParams();
-        EvalNode [] givenArgs = new EvalNode[params.length];
+        Expr[] params = function.getParams();
+        EvalNode[] givenArgs = new EvalNode[params.length];
         DataType[] paramTypes = new DataType[params.length];
 
         if (expr.getType() == OpType.CountValueFunction) {
@@ -990,7 +979,7 @@ public class LogicalPlanner {
     return caseEval;
   }
 
-  Target [] annotateTargets(LogicalPlan plan, String blockName,
+  Target[] annotateTargets(LogicalPlan plan, String blockName,
                                        org.apache.tajo.algebra.Target [] targets)
       throws VerifyException {
     Target annotatedTargets [] = new Target[targets.length];
@@ -1014,7 +1003,7 @@ public class LogicalPlanner {
   /**
    * It transforms a list of targets to schema. If it contains anonymous targets, it names them.
    */
-  static Schema getProjectedSchema(LogicalPlan plan, Target [] targets) {
+  static Schema getProjectedSchema(LogicalPlan plan, Target[] targets) {
     Schema projected = new Schema();
     for(Target t : targets) {
       DataType type = t.getEvalTree().getValueType()[0];

http://git-wip-us.apache.org/repos/asf/incubator-tajo/blob/87420eb3/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/engine/planner/TargetListManager.java
----------------------------------------------------------------------
diff --git a/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/engine/planner/TargetListManager.java b/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/engine/planner/TargetListManager.java
index 739a23d..d30c047 100644
--- a/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/engine/planner/TargetListManager.java
+++ b/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/engine/planner/TargetListManager.java
@@ -31,8 +31,8 @@ import java.util.Collection;
 public class TargetListManager {
   private LogicalPlan plan;
   private boolean [] evaluatedFlags;
-  private Target [] targets;
-  private Target [] unevaluatedTargets;
+  private Target[] targets;
+  private Target[] unevaluatedTargets;
 
   public TargetListManager(LogicalPlan plan, int targetNum) {
     this.plan = plan;
@@ -45,7 +45,7 @@ public class TargetListManager {
     this.unevaluatedTargets = new Target[targetNum];
   }
 
-  public TargetListManager(LogicalPlan plan, Target [] original) {
+  public TargetListManager(LogicalPlan plan, Target[] original) {
     this.plan = plan;
 
     targets = new Target[original.length];
@@ -69,11 +69,11 @@ public class TargetListManager {
     return targets[id];
   }
 
-  public Target [] getTargets() {
+  public Target[] getTargets() {
     return this.targets;
   }
 
-  public Target [] getUnEvaluatedTargets() {
+  public Target[] getUnEvaluatedTargets() {
     return this.unevaluatedTargets;
   }
 
@@ -100,8 +100,8 @@ public class TargetListManager {
     return evaluatedFlags[id];
   }
 
-  public Target [] getUpdatedTarget() throws CloneNotSupportedException {
-    Target [] updated = new Target[targets.length];
+  public Target[] getUpdatedTarget() throws PlanningException {
+    Target[] updated = new Target[targets.length];
     for (int i = 0; i < targets.length; i++) {
       if (targets[i] == null) { // if it is not created
         continue;
@@ -111,7 +111,11 @@ public class TargetListManager {
         Column col = getEvaluatedColumn(i);
         updated[i] = new Target(new FieldEval(col));
       } else {
-        updated[i] = (Target) targets[i].clone();
+        try {
+          updated[i] = (Target) targets[i].clone();
+        } catch (CloneNotSupportedException e) {
+          throw new PlanningException(e);
+        }
       }
     }
     targets = updated;

http://git-wip-us.apache.org/repos/asf/incubator-tajo/blob/87420eb3/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/master/GlobalEngine.java
----------------------------------------------------------------------
diff --git a/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/master/GlobalEngine.java b/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/master/GlobalEngine.java
index 3710f02..a0bd27f 100644
--- a/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/master/GlobalEngine.java
+++ b/tajo-core/tajo-core-backend/src/main/java/org/apache/tajo/master/GlobalEngine.java
@@ -229,7 +229,7 @@ public class GlobalEngine extends AbstractService {
     LogicalNode optimizedPlan = null;
     try {
       optimizedPlan = LogicalOptimizer.optimize(plan);
-    } catch (CloneNotSupportedException e) {
+    } catch (PlanningException e) {
       e.printStackTrace();
     }
     LOG.info("LogicalPlan:\n" + plan.getRootBlock().getRoot());

http://git-wip-us.apache.org/repos/asf/incubator-tajo/blob/87420eb3/tajo-core/tajo-core-backend/src/test/java/org/apache/tajo/BackendTestingUtil.java
----------------------------------------------------------------------
diff --git a/tajo-core/tajo-core-backend/src/test/java/org/apache/tajo/BackendTestingUtil.java b/tajo-core/tajo-core-backend/src/test/java/org/apache/tajo/BackendTestingUtil.java
index 361a560..77f665f 100644
--- a/tajo-core/tajo-core-backend/src/test/java/org/apache/tajo/BackendTestingUtil.java
+++ b/tajo-core/tajo-core-backend/src/test/java/org/apache/tajo/BackendTestingUtil.java
@@ -106,7 +106,7 @@ public class BackendTestingUtil {
   }
 
   public ResultSet run(String [] tableNames, File [] tables, Schema [] schemas, String query)
-      throws IOException, CloneNotSupportedException {
+      throws IOException, PlanningException {
     Path workDir = createTmpTestDir();
     StorageManager sm = StorageManager.get(new TajoConf(), workDir);
     List<Fragment> frags = Lists.newArrayList();

http://git-wip-us.apache.org/repos/asf/incubator-tajo/blob/87420eb3/tajo-core/tajo-core-backend/src/test/java/org/apache/tajo/engine/plan/global/TestGlobalQueryPlanner.java
----------------------------------------------------------------------
diff --git a/tajo-core/tajo-core-backend/src/test/java/org/apache/tajo/engine/plan/global/TestGlobalQueryPlanner.java b/tajo-core/tajo-core-backend/src/test/java/org/apache/tajo/engine/plan/global/TestGlobalQueryPlanner.java
index c3c9e04..def2506 100644
--- a/tajo-core/tajo-core-backend/src/test/java/org/apache/tajo/engine/plan/global/TestGlobalQueryPlanner.java
+++ b/tajo-core/tajo-core-backend/src/test/java/org/apache/tajo/engine/plan/global/TestGlobalQueryPlanner.java
@@ -34,7 +34,10 @@ import org.apache.tajo.datum.Datum;
 import org.apache.tajo.datum.DatumFactory;
 import org.apache.tajo.engine.eval.TestEvalTree.TestSum;
 import org.apache.tajo.engine.parser.SQLAnalyzer;
-import org.apache.tajo.engine.planner.*;
+import org.apache.tajo.engine.planner.LogicalOptimizer;
+import org.apache.tajo.engine.planner.LogicalPlan;
+import org.apache.tajo.engine.planner.LogicalPlanner;
+import org.apache.tajo.engine.planner.PlanningException;
 import org.apache.tajo.engine.planner.global.MasterPlan;
 import org.apache.tajo.engine.planner.logical.*;
 import org.apache.tajo.master.ExecutionBlock;
@@ -142,7 +145,7 @@ public class TestGlobalQueryPlanner {
   }
   
   @Test
-  public void testScan() throws IOException, CloneNotSupportedException {
+  public void testScan() throws IOException, PlanningException {
     Expr context = analyzer.parse(
         "select age, sumtest(salary) from table0");
 
@@ -164,7 +167,7 @@ public class TestGlobalQueryPlanner {
 
   @Test
   public void testGroupby() throws IOException, KeeperException,
-      InterruptedException, CloneNotSupportedException {
+      InterruptedException, PlanningException {
     Expr context = analyzer.parse(
         "create table store1 as select age, sumtest(salary) from table0 group by age");
     LogicalPlan plan = logicalPlanner.createPlan(context);
@@ -202,7 +205,7 @@ public class TestGlobalQueryPlanner {
   }
   
   @Test
-  public void testSort() throws IOException, CloneNotSupportedException {
+  public void testSort() throws IOException, PlanningException {
     Expr context = analyzer.parse(
         "create table store1 as select age from table0 order by age");
     LogicalPlan plan = logicalPlanner.createPlan(context);
@@ -244,7 +247,7 @@ public class TestGlobalQueryPlanner {
   }
   
   @Test
-  public void testJoin() throws IOException, CloneNotSupportedException {
+  public void testJoin() throws IOException, PlanningException {
     Expr expr = analyzer.parse(
         "select table0.age,table0.salary,table1.salary from table0,table1 " +
             "where table0.salary = table1.salary order by table0.age");
@@ -312,7 +315,7 @@ public class TestGlobalQueryPlanner {
   }
   
   @Test
-  public void testSelectAfterJoin() throws IOException, CloneNotSupportedException {
+  public void testSelectAfterJoin() throws IOException, PlanningException {
     String query = "select table0.name, table1.salary from table0,table1 where table0.name = table1.name and table1.salary > 10";
     Expr context = analyzer.parse(query);
     LogicalPlan plan = logicalPlanner.createPlan(context);
@@ -335,7 +338,7 @@ public class TestGlobalQueryPlanner {
   }
   
   //@Test
-  public void testCubeby() throws IOException, CloneNotSupportedException {
+  public void testCubeby() throws IOException, PlanningException {
     Expr expr = analyzer.parse(
         "select age, sum(salary) from table0 group by cube (age, id)");
     LogicalPlan plan = logicalPlanner.createPlan(expr);

http://git-wip-us.apache.org/repos/asf/incubator-tajo/blob/87420eb3/tajo-core/tajo-core-backend/src/test/java/org/apache/tajo/engine/planner/TestLogicalOptimizer.java
----------------------------------------------------------------------
diff --git a/tajo-core/tajo-core-backend/src/test/java/org/apache/tajo/engine/planner/TestLogicalOptimizer.java b/tajo-core/tajo-core-backend/src/test/java/org/apache/tajo/engine/planner/TestLogicalOptimizer.java
index fe2b114..d55b9e4 100644
--- a/tajo-core/tajo-core-backend/src/test/java/org/apache/tajo/engine/planner/TestLogicalOptimizer.java
+++ b/tajo-core/tajo-core-backend/src/test/java/org/apache/tajo/engine/planner/TestLogicalOptimizer.java
@@ -104,7 +104,7 @@ public class TestLogicalOptimizer {
   };
   
   @Test
-  public final void testProjectionPushWithNaturalJoin() throws CloneNotSupportedException {
+  public final void testProjectionPushWithNaturalJoin() throws PlanningException, CloneNotSupportedException {
     // two relations
     Expr expr = sqlAnalyzer.parse(QUERIES[4]);
     LogicalPlan newPlan = planner.createPlan(expr);
@@ -131,7 +131,7 @@ public class TestLogicalOptimizer {
   }
   
   @Test
-  public final void testProjectionPushWithInnerJoin() throws CloneNotSupportedException {
+  public final void testProjectionPushWithInnerJoin() throws PlanningException {
     // two relations
     Expr expr = sqlAnalyzer.parse(QUERIES[5]);
     LogicalPlan newPlan = planner.createPlan(expr);
@@ -139,7 +139,7 @@ public class TestLogicalOptimizer {
   }
   
   @Test
-  public final void testProjectionPush() throws CloneNotSupportedException {
+  public final void testProjectionPush() throws CloneNotSupportedException, PlanningException {
     // two relations
     Expr expr = sqlAnalyzer.parse(QUERIES[2]);
     LogicalPlan newPlan = planner.createPlan(expr);
@@ -162,7 +162,7 @@ public class TestLogicalOptimizer {
   }
   
   @Test
-  public final void testOptimizeWithGroupBy() throws CloneNotSupportedException {
+  public final void testOptimizeWithGroupBy() throws CloneNotSupportedException, PlanningException {
     Expr expr = sqlAnalyzer.parse(QUERIES[3]);
     LogicalPlan newPlan = planner.createPlan(expr);
     LogicalNode plan = newPlan.getRootBlock().getRoot();
@@ -188,7 +188,7 @@ public class TestLogicalOptimizer {
   }
 
   @Test
-  public final void testPushable() throws CloneNotSupportedException {
+  public final void testPushable() throws CloneNotSupportedException, PlanningException {
     // two relations
     Expr expr = sqlAnalyzer.parse(QUERIES[0]);
     LogicalPlan newPlan = planner.createPlan(expr);

http://git-wip-us.apache.org/repos/asf/incubator-tajo/blob/87420eb3/tajo-core/tajo-core-backend/src/test/java/org/apache/tajo/engine/planner/global/TestGlobalQueryOptimizer.java
----------------------------------------------------------------------
diff --git a/tajo-core/tajo-core-backend/src/test/java/org/apache/tajo/engine/planner/global/TestGlobalQueryOptimizer.java b/tajo-core/tajo-core-backend/src/test/java/org/apache/tajo/engine/planner/global/TestGlobalQueryOptimizer.java
index 0c6b1e7..1d2b0c1 100644
--- a/tajo-core/tajo-core-backend/src/test/java/org/apache/tajo/engine/planner/global/TestGlobalQueryOptimizer.java
+++ b/tajo-core/tajo-core-backend/src/test/java/org/apache/tajo/engine/planner/global/TestGlobalQueryOptimizer.java
@@ -40,6 +40,7 @@ import org.apache.tajo.engine.parser.SQLAnalyzer;
 import org.apache.tajo.engine.planner.LogicalOptimizer;
 import org.apache.tajo.engine.planner.LogicalPlan;
 import org.apache.tajo.engine.planner.LogicalPlanner;
+import org.apache.tajo.engine.planner.PlanningException;
 import org.apache.tajo.engine.planner.logical.*;
 import org.apache.tajo.master.ExecutionBlock;
 import org.apache.tajo.master.GlobalPlanner;
@@ -136,7 +137,7 @@ public class TestGlobalQueryOptimizer {
   }
 
   @Test
-  public void testReduceLogicalQueryUnitSteps() throws IOException, CloneNotSupportedException {
+  public void testReduceLogicalQueryUnitSteps() throws IOException, PlanningException {
     Expr expr = analyzer.parse(
         "select table0.age,table0.salary,table1.salary from table0,table1 where table0.salary = table1.salary order by table0.age");
     LogicalPlan plan = logicalPlanner.createPlan(expr);

http://git-wip-us.apache.org/repos/asf/incubator-tajo/blob/87420eb3/tajo-core/tajo-core-backend/src/test/java/org/apache/tajo/engine/planner/physical/TestPhysicalPlanner.java
----------------------------------------------------------------------
diff --git a/tajo-core/tajo-core-backend/src/test/java/org/apache/tajo/engine/planner/physical/TestPhysicalPlanner.java b/tajo-core/tajo-core-backend/src/test/java/org/apache/tajo/engine/planner/physical/TestPhysicalPlanner.java
index 77b43f1..e329fad 100644
--- a/tajo-core/tajo-core-backend/src/test/java/org/apache/tajo/engine/planner/physical/TestPhysicalPlanner.java
+++ b/tajo-core/tajo-core-backend/src/test/java/org/apache/tajo/engine/planner/physical/TestPhysicalPlanner.java
@@ -177,7 +177,7 @@ public class TestPhysicalPlanner {
   };
 
   @Test
-  public final void testCreateScanPlan() throws IOException, CloneNotSupportedException {
+  public final void testCreateScanPlan() throws IOException, PlanningException {
     Fragment[] frags = StorageManager.splitNG(conf, "employee", employee.getMeta(),
         employee.getPath(), Integer.MAX_VALUE);
     Path workDir = CommonTestingUtil.getTestDir("target/test-data/testCreateScanPlan");
@@ -207,7 +207,7 @@ public class TestPhysicalPlanner {
   }
 
   @Test
-  public final void testGroupByPlan() throws IOException, CloneNotSupportedException {
+  public final void testGroupByPlan() throws IOException, PlanningException {
     Fragment[] frags = StorageManager.splitNG(conf, "score", score.getMeta(), score.getPath(),
         Integer.MAX_VALUE);
     Path workDir = CommonTestingUtil.getTestDir("target/test-data/testGroupByPlan");
@@ -238,8 +238,7 @@ public class TestPhysicalPlanner {
   }
 
   @Test
-  public final void testHashGroupByPlanWithALLField() throws IOException,
-      CloneNotSupportedException {
+  public final void testHashGroupByPlanWithALLField() throws IOException, PlanningException {
     // TODO - currently, this query does not use hash-based group operator.
     Fragment[] frags = StorageManager.splitNG(conf, "score", score.getMeta(), score.getPath(),
         Integer.MAX_VALUE);
@@ -269,7 +268,7 @@ public class TestPhysicalPlanner {
   }
 
   @Test
-  public final void testSortGroupByPlan() throws IOException, CloneNotSupportedException {
+  public final void testSortGroupByPlan() throws IOException, PlanningException {
     Fragment[] frags = StorageManager.splitNG(conf, "score", score.getMeta(), score.getPath(),
         Integer.MAX_VALUE);
     Path workDir = CommonTestingUtil.getTestDir("target/test-data/testSortGroupByPlan");
@@ -326,7 +325,7 @@ public class TestPhysicalPlanner {
   };
 
   @Test
-  public final void testStorePlan() throws IOException, CloneNotSupportedException {
+  public final void testStorePlan() throws IOException, PlanningException {
     Fragment[] frags = StorageManager.splitNG(conf, "score", score.getMeta(), score.getPath(),
         Integer.MAX_VALUE);
     Path workDir = CommonTestingUtil.getTestDir("target/test-data/testStorePlan");
@@ -367,7 +366,7 @@ public class TestPhysicalPlanner {
   }
 
   @Test
-  public final void testStorePlanWithRCFile() throws IOException, CloneNotSupportedException {
+  public final void testStorePlanWithRCFile() throws IOException, PlanningException {
     Fragment[] frags = StorageManager.splitNG(conf, "score", score.getMeta(), score.getPath(),
         Integer.MAX_VALUE);
     Path workDir = CommonTestingUtil.getTestDir("target/test-data/testStorePlanWithRCFile");
@@ -407,7 +406,7 @@ public class TestPhysicalPlanner {
   }
 
   @Test
-  public final void testPartitionedStorePlan() throws IOException, CloneNotSupportedException {
+  public final void testPartitionedStorePlan() throws IOException, PlanningException {
     Fragment[] frags = StorageManager.splitNG(conf, "score", score.getMeta(), score.getPath(),
         Integer.MAX_VALUE);
     QueryUnitAttemptId id = TUtil.newQueryUnitAttemptId();
@@ -466,7 +465,7 @@ public class TestPhysicalPlanner {
 
   @Test
   public final void testPartitionedStorePlanWithEmptyGroupingSet()
-      throws IOException, CloneNotSupportedException {
+      throws IOException, PlanningException {
     Fragment[] frags = StorageManager.splitNG(conf, "score", score.getMeta(), score.getPath(),
         Integer.MAX_VALUE);
     QueryUnitAttemptId id = TUtil.newQueryUnitAttemptId();
@@ -522,7 +521,7 @@ public class TestPhysicalPlanner {
   }
 
   @Test
-  public final void testAggregationFunction() throws IOException, CloneNotSupportedException {
+  public final void testAggregationFunction() throws IOException, PlanningException {
     Fragment[] frags = StorageManager.splitNG(conf, "score", score.getMeta(), score.getPath(),
         Integer.MAX_VALUE);
     Path workDir = CommonTestingUtil.getTestDir("target/test-data/testAggregationFunction");
@@ -555,7 +554,7 @@ public class TestPhysicalPlanner {
   }
 
   @Test
-  public final void testCountFunction() throws IOException, CloneNotSupportedException {
+  public final void testCountFunction() throws IOException, PlanningException {
     Fragment[] frags = StorageManager.splitNG(conf, "score", score.getMeta(), score.getPath(),
         Integer.MAX_VALUE);
     Path workDir = CommonTestingUtil.getTestDir("target/test-data/testCountFunction");
@@ -586,7 +585,7 @@ public class TestPhysicalPlanner {
   }
 
   @Test
-  public final void testGroupByWithNullValue() throws IOException, CloneNotSupportedException {
+  public final void testGroupByWithNullValue() throws IOException, PlanningException {
     Fragment[] frags = StorageManager.splitNG(conf, "score", score.getMeta(), score.getPath(),
         Integer.MAX_VALUE);
     Path workDir = CommonTestingUtil.getTestDir("target/test-data/testGroupByWithNullValue");
@@ -609,7 +608,7 @@ public class TestPhysicalPlanner {
   }
 
   @Test
-  public final void testUnionPlan() throws IOException, CloneNotSupportedException {
+  public final void testUnionPlan() throws IOException, PlanningException {
     Fragment[] frags = StorageManager.splitNG(conf, "employee", employee.getMeta(), employee.getPath(),
         Integer.MAX_VALUE);
     Path workDir = CommonTestingUtil.getTestDir("target/test-data/testUnionPlan");
@@ -635,7 +634,7 @@ public class TestPhysicalPlanner {
   }
 
   @Test
-  public final void testEvalExpr() throws IOException, CloneNotSupportedException {
+  public final void testEvalExpr() throws IOException, PlanningException {
     Path workDir = CommonTestingUtil.getTestDir("target/test-data/testEvalExpr");
     TaskAttemptContext ctx = new TaskAttemptContext(conf, TUtil.newQueryUnitAttemptId(),
         new Fragment[] { }, workDir);
@@ -669,7 +668,7 @@ public class TestPhysicalPlanner {
   };
 
   //@Test
-  public final void testCreateIndex() throws IOException, CloneNotSupportedException {
+  public final void testCreateIndex() throws IOException, PlanningException {
     Fragment[] frags = StorageManager.splitNG(conf, "employee", employee.getMeta(), employee.getPath(),
         Integer.MAX_VALUE);
     Path workDir = CommonTestingUtil.getTestDir("target/test-data/testCreateIndex");
@@ -695,7 +694,7 @@ public class TestPhysicalPlanner {
   };
 
   @Test
-  public final void testDuplicateEliminate() throws IOException, CloneNotSupportedException {
+  public final void testDuplicateEliminate() throws IOException, PlanningException {
     Fragment[] frags = StorageManager.splitNG(conf, "score", score.getMeta(), score.getPath(),
         Integer.MAX_VALUE);
 
@@ -727,7 +726,7 @@ public class TestPhysicalPlanner {
   };
 
   @Test
-  public final void testIndexedStoreExec() throws IOException, CloneNotSupportedException {
+  public final void testIndexedStoreExec() throws IOException, PlanningException {
     Fragment[] frags = StorageManager.splitNG(conf, "employee", employee.getMeta(),
         employee.getPath(), Integer.MAX_VALUE);
 

http://git-wip-us.apache.org/repos/asf/incubator-tajo/blob/87420eb3/tajo-core/tajo-core-backend/src/test/java/org/apache/tajo/engine/planner/physical/TestSortExec.java
----------------------------------------------------------------------
diff --git a/tajo-core/tajo-core-backend/src/test/java/org/apache/tajo/engine/planner/physical/TestSortExec.java b/tajo-core/tajo-core-backend/src/test/java/org/apache/tajo/engine/planner/physical/TestSortExec.java
index 472a371..be389a3 100644
--- a/tajo-core/tajo-core-backend/src/test/java/org/apache/tajo/engine/planner/physical/TestSortExec.java
+++ b/tajo-core/tajo-core-backend/src/test/java/org/apache/tajo/engine/planner/physical/TestSortExec.java
@@ -104,7 +104,7 @@ public class TestSortExec {
       "select managerId, empId, deptName from employee order by managerId, empId desc" };
 
   @Test
-  public final void testNext() throws IOException, CloneNotSupportedException {
+  public final void testNext() throws IOException, PlanningException {
     Fragment [] frags = sm.splitNG(conf, "employee", employeeMeta, tablePath, Integer.MAX_VALUE);
     Path workDir = CommonTestingUtil.getTestDir("target/test-data/TestSortExec");
     TaskAttemptContext ctx = new TaskAttemptContext(conf, TUtil


Mime
View raw message