Return-Path: X-Original-To: apmail-tajo-commits-archive@minotaur.apache.org Delivered-To: apmail-tajo-commits-archive@minotaur.apache.org Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by minotaur.apache.org (Postfix) with SMTP id 3E5B617635 for ; Sun, 26 Oct 2014 19:27:09 +0000 (UTC) Received: (qmail 3415 invoked by uid 500); 26 Oct 2014 19:27:09 -0000 Delivered-To: apmail-tajo-commits-archive@tajo.apache.org Received: (qmail 3342 invoked by uid 500); 26 Oct 2014 19:27:09 -0000 Mailing-List: contact commits-help@tajo.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@tajo.apache.org Delivered-To: mailing list commits@tajo.apache.org Received: (qmail 2579 invoked by uid 99); 26 Oct 2014 19:27:08 -0000 Received: from tyr.zones.apache.org (HELO tyr.zones.apache.org) (140.211.11.114) by apache.org (qpsmtpd/0.29) with ESMTP; Sun, 26 Oct 2014 19:27:08 +0000 Received: by tyr.zones.apache.org (Postfix, from userid 65534) id 7934B902108; Sun, 26 Oct 2014 19:27:08 +0000 (UTC) Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: hjkim@apache.org To: commits@tajo.apache.org Date: Sun, 26 Oct 2014 19:27:34 -0000 Message-Id: In-Reply-To: <5a7be15a9bd44212ba4aa0a95780e9bf@git.apache.org> References: <5a7be15a9bd44212ba4aa0a95780e9bf@git.apache.org> X-Mailer: ASF-Git Admin Mailer Subject: [28/35] TAJO-1125: Separate logical plan and optimizer into a maven module. http://git-wip-us.apache.org/repos/asf/tajo/blob/b143f991/tajo-core/src/main/java/org/apache/tajo/engine/planner/AlterTablespaceNode.java ---------------------------------------------------------------------- diff --git a/tajo-core/src/main/java/org/apache/tajo/engine/planner/AlterTablespaceNode.java b/tajo-core/src/main/java/org/apache/tajo/engine/planner/AlterTablespaceNode.java deleted file mode 100644 index d64a89d..0000000 --- a/tajo-core/src/main/java/org/apache/tajo/engine/planner/AlterTablespaceNode.java +++ /dev/null @@ -1,103 +0,0 @@ -/** - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.apache.tajo.engine.planner; - - -import com.google.common.base.Objects; -import com.google.gson.annotations.Expose; -import org.apache.tajo.algebra.AlterTablespaceSetType; -import org.apache.tajo.engine.planner.logical.LogicalNode; -import org.apache.tajo.engine.planner.logical.LogicalNodeVisitor; -import org.apache.tajo.engine.planner.logical.NodeType; - -public class AlterTablespaceNode extends LogicalNode implements Cloneable { - - @Expose private String tablespaceName; - @Expose private AlterTablespaceSetType setType; - @Expose private String uri; - - - public AlterTablespaceNode(int pid) { - super(pid, NodeType.ALTER_TABLESPACE); - } - - public String getTablespaceName() { - return tablespaceName; - } - - public void setTablespaceName(String tablespaceName) { - this.tablespaceName = tablespaceName; - } - - public AlterTablespaceSetType getSetType() { - return setType; - } - - public String getLocation() { - return uri; - } - - public void setLocation(String uri) { - this.setType = AlterTablespaceSetType.LOCATION; - this.uri = uri; - } - - @Override - public PlanString getPlanString() { - return new PlanString(this); - } - - @Override - public boolean equals(Object obj) { - if (obj instanceof AlterTablespaceNode) { - AlterTablespaceNode other = (AlterTablespaceNode) obj; - return super.equals(other); - } else { - return false; - } - } - - public int hashCode() { - return Objects.hashCode(tablespaceName, setType, uri); - } - - @Override - public Object clone() throws CloneNotSupportedException { - AlterTablespaceNode alter = (AlterTablespaceNode) super.clone(); - alter.tablespaceName = tablespaceName; - alter.setType = setType; - alter.uri = uri; - return alter; - } - - @Override - public String toString() { - return "AlterTablespace (space=" + tablespaceName + ")"; - } - - @Override - public void preOrder(LogicalNodeVisitor visitor) { - visitor.visit(this); - } - - @Override - public void postOrder(LogicalNodeVisitor visitor) { - visitor.visit(this); - } -} http://git-wip-us.apache.org/repos/asf/tajo/blob/b143f991/tajo-core/src/main/java/org/apache/tajo/engine/planner/BaseAlgebraVisitor.java ---------------------------------------------------------------------- diff --git a/tajo-core/src/main/java/org/apache/tajo/engine/planner/BaseAlgebraVisitor.java b/tajo-core/src/main/java/org/apache/tajo/engine/planner/BaseAlgebraVisitor.java deleted file mode 100644 index 24ff2e4..0000000 --- a/tajo-core/src/main/java/org/apache/tajo/engine/planner/BaseAlgebraVisitor.java +++ /dev/null @@ -1,789 +0,0 @@ -/** - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.apache.tajo.engine.planner; - -import org.apache.tajo.algebra.*; - -import java.util.Stack; - -public class BaseAlgebraVisitor implements AlgebraVisitor { - - /** - * The prehook is called before each expression is visited. - */ - public void preHook(CONTEXT ctx, Stack stack, Expr expr) throws PlanningException { - } - - - /** - * The posthook is called before each expression is visited. - */ - public RESULT postHook(CONTEXT ctx, Stack stack, Expr expr, RESULT current) throws PlanningException { - return current; - } - - /** - * visit visits each relational operator expression recursively. - * - * @param stack The stack contains the upper operators' type. - * @param expr The visiting relational operator - */ - public RESULT visit(CONTEXT ctx, Stack stack, Expr expr) throws PlanningException { - preHook(ctx, stack, expr); - - RESULT 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 Having: - current = visitHaving(ctx, stack, (Having) 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 SimpleTableSubQuery: - current = visitSimpleTableSubQuery(ctx, stack, (SimpleTableSubQuery) expr); - break; - case TablePrimaryTableSubQuery: - current = visitTableSubQuery(ctx, stack, (TablePrimarySubQuery) expr); - break; - case RelationList: - current = visitRelationList(ctx, stack, (RelationList) expr); - break; - case Relation: - current = visitRelation(ctx, stack, (Relation) expr); - break; - case ScalarSubQuery: - current = visitScalarSubQuery(ctx, stack, (ScalarSubQuery) expr); - break; - case Explain: - current = visitExplain(ctx, stack, (Explain) expr); - break; - - case CreateDatabase: - current = visitCreateDatabase(ctx, stack, (CreateDatabase) expr); - break; - case DropDatabase: - current = visitDropDatabase(ctx, stack, (DropDatabase) expr); - break; - case CreateTable: - current = visitCreateTable(ctx, stack, (CreateTable) expr); - break; - case DropTable: - current = visitDropTable(ctx, stack, (DropTable) expr); - break; - case AlterTablespace: - current = visitAlterTablespace(ctx, stack, (AlterTablespace) expr); - break; - case AlterTable: - current = visitAlterTable(ctx, stack, (AlterTable) expr); - break; - case TruncateTable: - current = visitTruncateTable(ctx, stack, (TruncateTable)expr); - break; - - case Insert: - current = visitInsert(ctx, stack, (Insert) expr); - break; - - case And: - current = visitAnd(ctx, stack, (BinaryOperator) expr); - break; - case Or: - current = visitOr(ctx, stack, (BinaryOperator) expr); - break; - case Not: - current = visitNot(ctx, stack, (NotExpr) expr); - break; - - case Equals: - current = visitEquals(ctx, stack, (BinaryOperator) expr); - break; - case NotEquals: - current = visitNotEquals(ctx, stack, (BinaryOperator) expr); - break; - case LessThan: - current = visitLessThan(ctx, stack, (BinaryOperator) expr); - break; - case LessThanOrEquals: - current = visitLessThanOrEquals(ctx, stack, (BinaryOperator) expr); - break; - case GreaterThan: - current = visitGreaterThan(ctx, stack, (BinaryOperator) expr); - break; - case GreaterThanOrEquals: - current = visitGreaterThanOrEquals(ctx, stack, (BinaryOperator) expr); - break; - - // Other Predicates - case Between: - current = visitBetween(ctx, stack, (BetweenPredicate) expr); - break; - case CaseWhen: - current = visitCaseWhen(ctx, stack, (CaseWhenPredicate) expr); - break; - case IsNullPredicate: - current = visitIsNullPredicate(ctx, stack, (IsNullPredicate) expr); - break; - case InPredicate: - current = visitInPredicate(ctx, stack, (InPredicate) expr); - break; - case ValueList: - current = visitValueListExpr(ctx, stack, (ValueListExpr) expr); - break; - case ExistsPredicate: - current = visitExistsPredicate(ctx, stack, (ExistsPredicate) expr); - break; - - // String Operator or Pattern Matching Predicates - case LikePredicate: - current = visitLikePredicate(ctx, stack, (PatternMatchPredicate) expr); - break; - case SimilarToPredicate: - current = visitSimilarToPredicate(ctx, stack, (PatternMatchPredicate) expr); - break; - case Regexp: - current = visitRegexpPredicate(ctx, stack, (PatternMatchPredicate) expr); - break; - case Concatenate: - current = visitConcatenate(ctx, stack, (BinaryOperator) expr); - break; - - // Arithmetic Operators - case Plus: - current = visitPlus(ctx, stack, (BinaryOperator) expr); - break; - case Minus: - current = visitMinus(ctx, stack, (BinaryOperator) expr); - break; - case Multiply: - current = visitMultiply(ctx, stack, (BinaryOperator) expr); - break; - case Divide: - current = visitDivide(ctx, stack, (BinaryOperator) expr); - break; - case Modular: - current = visitModular(ctx, stack, (BinaryOperator) expr); - break; - - // Other Expressions - case Sign: - current = visitSign(ctx, stack, (SignedExpr) expr); - break; - case Column: - current = visitColumnReference(ctx, stack, (ColumnReferenceExpr) expr); - break; - case Target: - current = visitTargetExpr(ctx, stack, (NamedExpr) expr); - break; - case Function: - current = visitFunction(ctx, stack, (FunctionExpr) expr); - break; - case Asterisk: - current = visitQualifiedAsterisk(ctx, stack, (QualifiedAsteriskExpr) expr); - break; - - - case CountRowsFunction: - current = visitCountRowsFunction(ctx, stack, (CountRowsFunctionExpr) expr); - break; - case GeneralSetFunction: - current = visitGeneralSetFunction(ctx, stack, (GeneralSetFunctionExpr) expr); - break; - case WindowFunction: - current = visitWindowFunction(ctx, stack, (WindowFunctionExpr) expr); - break; - - - case DataType: - current = visitDataType(ctx, stack, (DataTypeExpr) expr); - break; - case Cast: - current = visitCastExpr(ctx, stack, (CastExpr) expr); - break; - case Literal: - current = visitLiteral(ctx, stack, (LiteralValue) expr); - break; - case NullLiteral: - current = visitNullLiteral(ctx, stack, (NullLiteral) expr); - break; - case DateLiteral: - current = visitDateLiteral(ctx, stack, (DateLiteral) expr); - break; - case TimeLiteral: - current = visitTimeLiteral(ctx, stack, (TimeLiteral) expr); - break; - case TimestampLiteral: - current = visitTimestampLiteral(ctx, stack, (TimestampLiteral) expr); - break; - case IntervalLiteral: - current = visitIntervalLiteral(ctx, stack, (IntervalLiteral) expr); - break; - - - default: - throw new PlanningException("Cannot support this type algebra \"" + expr.getType() + "\""); - } - - // skip postHook against only one relation - if (expr.getType() == OpType.RelationList) { - RelationList relationList = (RelationList)expr; - if (relationList.size() == 1 && relationList.getRelations()[0].getType() == OpType.Relation) { - return current; - } - } - - postHook(ctx, stack, expr, current); - return current; - } - - private RESULT visitDefaultUnaryExpr(CONTEXT ctx, Stack stack, UnaryOperator expr) throws PlanningException { - stack.push(expr); - RESULT child = visit(ctx, stack, expr.getChild()); - stack.pop(); - return child; - } - - private RESULT visitDefaultBinaryExpr(CONTEXT ctx, Stack stack, BinaryOperator expr) - throws PlanningException { - stack.push(expr); - RESULT child = visit(ctx, stack, expr.getLeft()); - visit(ctx, stack, expr.getRight()); - stack.pop(); - return child; - } - - @Override - public RESULT visitProjection(CONTEXT ctx, Stack stack, Projection expr) throws PlanningException { - stack.push(expr); - try { - for (NamedExpr target : expr.getNamedExprs()) { - visit(ctx, stack, target); - } - if (expr.hasChild()) { - return visit(ctx, stack, expr.getChild()); - } - } finally { - stack.pop(); - } - return null; - } - - @Override - public RESULT visitLimit(CONTEXT ctx, Stack stack, Limit expr) throws PlanningException { - stack.push(expr); - visit(ctx, stack, expr.getFetchFirstNum()); - RESULT result = visit(ctx, stack, expr.getChild()); - stack.pop(); - return result; - } - - @Override - public RESULT visitSort(CONTEXT ctx, Stack stack, Sort expr) throws PlanningException { - stack.push(expr); - for (Sort.SortSpec sortSpec : expr.getSortSpecs()) { - visit(ctx, stack, sortSpec.getKey()); - } - RESULT result = visit(ctx, stack, expr.getChild()); - return result; - } - - @Override - public RESULT visitHaving(CONTEXT ctx, Stack stack, Having expr) throws PlanningException { - stack.push(expr); - visit(ctx, stack, expr.getQual()); - RESULT result = visit(ctx, stack, expr.getChild()); - stack.pop(); - return result; - } - - @Override - public RESULT visitGroupBy(CONTEXT ctx, Stack stack, Aggregation expr) throws PlanningException { - stack.push(expr); - - for (org.apache.tajo.algebra.Aggregation.GroupElement groupElement : expr.getGroupSet()) { - for (Expr groupingSet : groupElement.getGroupingSets()) { - visit(ctx, stack, groupingSet); - } - } - - RESULT result = visit(ctx, stack, expr.getChild()); - stack.pop(); - return result; - } - - @Override - public RESULT visitJoin(CONTEXT ctx, Stack stack, Join expr) throws PlanningException { - stack.push(expr); - visit(ctx, stack, expr.getQual()); - visit(ctx, stack, expr.getLeft()); - RESULT result = visit(ctx, stack, expr.getRight()); - stack.pop(); - return result; - } - - @Override - public RESULT visitFilter(CONTEXT ctx, Stack stack, Selection expr) throws PlanningException { - stack.push(expr); - visit(ctx, stack, expr.getQual()); - RESULT result = visit(ctx, stack, expr.getChild()); - stack.pop(); - return result; - } - - @Override - public RESULT visitUnion(CONTEXT ctx, Stack stack, SetOperation expr) throws PlanningException { - return visitDefaultBinaryExpr(ctx, stack, expr); - } - - @Override - public RESULT visitExcept(CONTEXT ctx, Stack stack, SetOperation expr) throws PlanningException { - return visitDefaultBinaryExpr(ctx, stack, expr); - } - - @Override - public RESULT visitIntersect(CONTEXT ctx, Stack stack, SetOperation expr) throws PlanningException { - return visitDefaultBinaryExpr(ctx, stack, expr); - } - - @Override - public RESULT visitSimpleTableSubQuery(CONTEXT ctx, Stack stack, SimpleTableSubQuery expr) - throws PlanningException { - return visitDefaultUnaryExpr(ctx, stack, expr); - } - - @Override - public RESULT visitTableSubQuery(CONTEXT ctx, Stack stack, TablePrimarySubQuery expr) - throws PlanningException { - stack.push(expr); - RESULT child = visit(ctx, stack, expr.getSubQuery()); - stack.pop(); - return child; - } - - @Override - public RESULT visitRelationList(CONTEXT ctx, Stack stack, RelationList expr) throws PlanningException { - stack.push(expr); - RESULT child = null; - for (Expr e : expr.getRelations()) { - child = visit(ctx, stack, e); - } - stack.pop(); - return child; - } - - @Override - public RESULT visitRelation(CONTEXT ctx, Stack stack, Relation expr) throws PlanningException { - return null; - } - - @Override - public RESULT visitScalarSubQuery(CONTEXT ctx, Stack stack, ScalarSubQuery expr) throws PlanningException { - return visitDefaultUnaryExpr(ctx, stack, expr); - } - - @Override - public RESULT visitExplain(CONTEXT ctx, Stack stack, Explain expr) throws PlanningException { - stack.push(expr); - RESULT child = visit(ctx, stack, expr.getChild()); - stack.pop(); - return child; - } - - /////////////////////////////////////////////////////////////////////////////////////////////////////////// - // Data Definition Language Section - /////////////////////////////////////////////////////////////////////////////////////////////////////////// - - @Override - public RESULT visitCreateDatabase(CONTEXT ctx, Stack stack, CreateDatabase expr) throws PlanningException { - return null; - } - - @Override - public RESULT visitDropDatabase(CONTEXT ctx, Stack stack, DropDatabase expr) throws PlanningException { - return null; - } - - @Override - public RESULT visitCreateTable(CONTEXT ctx, Stack stack, CreateTable expr) throws PlanningException { - stack.push(expr); - RESULT child = null; - if (expr.hasSubQuery()) { - child = visit(ctx, stack, expr.getSubQuery()); - } - stack.pop(); - return child; - } - - @Override - public RESULT visitDropTable(CONTEXT ctx, Stack stack, DropTable expr) throws PlanningException { - return null; - } - - @Override - public RESULT visitAlterTablespace(CONTEXT ctx, Stack stack, AlterTablespace expr) throws PlanningException { - return null; - } - - @Override - public RESULT visitAlterTable(CONTEXT ctx, Stack stack, AlterTable expr) throws PlanningException { - return null; - } - - public RESULT visitTruncateTable(CONTEXT ctx, Stack stack, TruncateTable expr) throws PlanningException { - return null; - } - /////////////////////////////////////////////////////////////////////////////////////////////////////////// - // Insert or Update Section - /////////////////////////////////////////////////////////////////////////////////////////////////////////// - - public RESULT visitInsert(CONTEXT ctx, Stack stack, Insert expr) throws PlanningException { - stack.push(expr); - RESULT child = visit(ctx, stack, expr.getSubQuery()); - stack.pop(); - return child; - } - - /////////////////////////////////////////////////////////////////////////////////////////////////////////// - // Logical Operator Section - /////////////////////////////////////////////////////////////////////////////////////////////////////////// - - @Override - public RESULT visitAnd(CONTEXT ctx, Stack stack, BinaryOperator expr) throws PlanningException { - return visitDefaultBinaryExpr(ctx, stack, expr); - } - - @Override - public RESULT visitOr(CONTEXT ctx, Stack stack, BinaryOperator expr) throws PlanningException { - return visitDefaultBinaryExpr(ctx, stack, expr); - } - - @Override - public RESULT visitNot(CONTEXT ctx, Stack stack, NotExpr expr) throws PlanningException { - return visitDefaultUnaryExpr(ctx, stack, expr); - } - - /////////////////////////////////////////////////////////////////////////////////////////////////////////// - // Comparison Predicates Section - /////////////////////////////////////////////////////////////////////////////////////////////////////////// - @Override - public RESULT visitEquals(CONTEXT ctx, Stack stack, BinaryOperator expr) throws PlanningException { - return visitDefaultBinaryExpr(ctx, stack, expr); - } - - @Override - public RESULT visitNotEquals(CONTEXT ctx, Stack stack, BinaryOperator expr) throws PlanningException { - return visitDefaultBinaryExpr(ctx, stack, expr); - } - - @Override - public RESULT visitLessThan(CONTEXT ctx, Stack stack, BinaryOperator expr) throws PlanningException { - return visitDefaultBinaryExpr(ctx, stack, expr); - } - - @Override - public RESULT visitLessThanOrEquals(CONTEXT ctx, Stack stack, BinaryOperator expr) throws PlanningException { - return visitDefaultBinaryExpr(ctx, stack, expr); - } - - @Override - public RESULT visitGreaterThan(CONTEXT ctx, Stack stack, BinaryOperator expr) throws PlanningException { - return visitDefaultBinaryExpr(ctx, stack, expr); - } - - @Override - public RESULT visitGreaterThanOrEquals(CONTEXT ctx, Stack stack, BinaryOperator expr) - throws PlanningException { - return visitDefaultBinaryExpr(ctx, stack, expr); - } - - /////////////////////////////////////////////////////////////////////////////////////////////////////////// - // Other Predicates Section - /////////////////////////////////////////////////////////////////////////////////////////////////////////// - - @Override - public RESULT visitBetween(CONTEXT ctx, Stack stack, BetweenPredicate expr) throws PlanningException { - stack.push(expr); - RESULT result = visit(ctx, stack, expr.predicand()); - visit(ctx, stack, expr.begin()); - visit(ctx, stack, expr.end()); - stack.pop(); - return result; - } - - @Override - public RESULT visitCaseWhen(CONTEXT ctx, Stack stack, CaseWhenPredicate expr) throws PlanningException { - stack.push(expr); - RESULT result = null; - for (CaseWhenPredicate.WhenExpr when : expr.getWhens()) { - result = visit(ctx, stack, when.getCondition()); - visit(ctx, stack, when.getResult()); - } - if (expr.hasElseResult()) { - visit(ctx, stack, expr.getElseResult()); - } - stack.pop(); - return result; - } - - @Override - public RESULT visitIsNullPredicate(CONTEXT ctx, Stack stack, IsNullPredicate expr) throws PlanningException { - return visitDefaultUnaryExpr(ctx, stack, expr); - } - - @Override - public RESULT visitInPredicate(CONTEXT ctx, Stack stack, InPredicate expr) throws PlanningException { - return visitDefaultBinaryExpr(ctx, stack, expr); - } - - @Override - public RESULT visitValueListExpr(CONTEXT ctx, Stack stack, ValueListExpr expr) throws PlanningException { - stack.push(expr); - RESULT result = null; - for (Expr value : expr.getValues()) { - result = visit(ctx, stack, value); - } - stack.pop(); - return result; - } - - @Override - public RESULT visitExistsPredicate(CONTEXT ctx, Stack stack, ExistsPredicate expr) throws PlanningException { - return visitDefaultUnaryExpr(ctx, stack, expr); - } - - /////////////////////////////////////////////////////////////////////////////////////////////////////////// - // String Operator or Pattern Matching Predicates Section - /////////////////////////////////////////////////////////////////////////////////////////////////////////// - @Override - public RESULT visitLikePredicate(CONTEXT ctx, Stack stack, PatternMatchPredicate expr) - throws PlanningException { - return visitDefaultBinaryExpr(ctx, stack, expr); - } - - @Override - public RESULT visitSimilarToPredicate(CONTEXT ctx, Stack stack, PatternMatchPredicate expr) - throws PlanningException { - return visitDefaultBinaryExpr(ctx, stack, expr); - } - - @Override - public RESULT visitRegexpPredicate(CONTEXT ctx, Stack stack, PatternMatchPredicate expr) - throws PlanningException { - return visitDefaultBinaryExpr(ctx, stack, expr); - } - - @Override - public RESULT visitConcatenate(CONTEXT ctx, Stack stack, BinaryOperator expr) throws PlanningException { - return visitDefaultBinaryExpr(ctx, stack, expr); - } - - /////////////////////////////////////////////////////////////////////////////////////////////////////////// - // Arithmetic Operators - /////////////////////////////////////////////////////////////////////////////////////////////////////////// - - @Override - public RESULT visitPlus(CONTEXT ctx, Stack stack, BinaryOperator expr) throws PlanningException { - return visitDefaultBinaryExpr(ctx, stack, expr); - } - - @Override - public RESULT visitMinus(CONTEXT ctx, Stack stack, BinaryOperator expr) throws PlanningException { - return visitDefaultBinaryExpr(ctx, stack, expr); - } - - @Override - public RESULT visitMultiply(CONTEXT ctx, Stack stack, BinaryOperator expr) throws PlanningException { - return visitDefaultBinaryExpr(ctx, stack, expr); - } - - @Override - public RESULT visitDivide(CONTEXT ctx, Stack stack, BinaryOperator expr) throws PlanningException { - return visitDefaultBinaryExpr(ctx, stack, expr); - } - - @Override - public RESULT visitModular(CONTEXT ctx, Stack stack, BinaryOperator expr) throws PlanningException { - return visitDefaultBinaryExpr(ctx, stack, expr); - } - - /////////////////////////////////////////////////////////////////////////////////////////////////////////// - // Other Expressions - /////////////////////////////////////////////////////////////////////////////////////////////////////////// - - @Override - public RESULT visitSign(CONTEXT ctx, Stack stack, SignedExpr expr) throws PlanningException { - return visitDefaultUnaryExpr(ctx, stack, expr); - } - - @Override - public RESULT visitColumnReference(CONTEXT ctx, Stack stack, ColumnReferenceExpr expr) - throws PlanningException { - return null; - } - - @Override - public RESULT visitTargetExpr(CONTEXT ctx, Stack stack, NamedExpr expr) throws PlanningException { - return visitDefaultUnaryExpr(ctx, stack, expr); - } - - @Override - public RESULT visitFunction(CONTEXT ctx, Stack stack, FunctionExpr expr) throws PlanningException { - stack.push(expr); - RESULT result = null; - if (expr.hasParams()) { - for (Expr param : expr.getParams()) { - result = visit(ctx, stack, param); - } - } - stack.pop(); - return result; - } - - @Override - public RESULT visitQualifiedAsterisk(CONTEXT ctx, Stack stack, QualifiedAsteriskExpr expr) throws PlanningException { - return null; - } - - /////////////////////////////////////////////////////////////////////////////////////////////////////////// - // General Set Section - /////////////////////////////////////////////////////////////////////////////////////////////////////////// - - @Override - public RESULT visitCountRowsFunction(CONTEXT ctx, Stack stack, CountRowsFunctionExpr expr) - throws PlanningException { - return null; - } - - @Override - public RESULT visitGeneralSetFunction(CONTEXT ctx, Stack stack, GeneralSetFunctionExpr expr) - throws PlanningException { - stack.push(expr); - RESULT result = null; - for (Expr param : expr.getParams()) { - result = visit(ctx, stack, param); - } - stack.pop(); - return result; - } - - @Override - public RESULT visitWindowFunction(CONTEXT ctx, Stack stack, WindowFunctionExpr expr) throws PlanningException { - stack.push(expr); - RESULT result = null; - for (Expr param : expr.getParams()) { - result = visit(ctx, stack, param); - } - - WindowSpec windowSpec = expr.getWindowSpec(); - - if (windowSpec.hasPartitionBy()) { - for (Expr partitionKey : windowSpec.getPartitionKeys()) { - visit(ctx, stack, partitionKey); - } - } - if (windowSpec.hasOrderBy()) { - for (Sort.SortSpec sortKey : windowSpec.getSortSpecs()) { - visit(ctx, stack, sortKey.getKey()); - } - } - if (windowSpec.hasWindowFrame()) { - if (windowSpec.getWindowFrame().getStartBound().hasNumber()) { - visit(ctx, stack, windowSpec.getWindowFrame().getStartBound().getNumber()); - } - if (windowSpec.getWindowFrame().getEndBound().hasNumber()) { - visit(ctx, stack, windowSpec.getWindowFrame().getEndBound().getNumber()); - } - } - - stack.pop(); - return result; - } - - /////////////////////////////////////////////////////////////////////////////////////////////////////////// - // Literal Section - /////////////////////////////////////////////////////////////////////////////////////////////////////////// - - @Override - public RESULT visitDataType(CONTEXT ctx, Stack stack, DataTypeExpr expr) throws PlanningException { - return null; - } - - @Override - public RESULT visitCastExpr(CONTEXT ctx, Stack stack, CastExpr expr) throws PlanningException { - stack.push(expr); - RESULT result = visit(ctx, stack, expr.getOperand()); - stack.pop(); - return result; - } - - @Override - public RESULT visitLiteral(CONTEXT ctx, Stack stack, LiteralValue expr) throws PlanningException { - return null; - } - - @Override - public RESULT visitNullLiteral(CONTEXT ctx, Stack stack, NullLiteral expr) throws PlanningException { - return null; - } - - @Override - public RESULT visitTimestampLiteral(CONTEXT ctx, Stack stack, TimestampLiteral expr) throws PlanningException { - return null; - } - - @Override - public RESULT visitIntervalLiteral(CONTEXT ctx, Stack stack, IntervalLiteral expr) throws PlanningException { - return null; - } - - @Override - public RESULT visitTimeLiteral(CONTEXT ctx, Stack stack, TimeLiteral expr) throws PlanningException { - return null; - } - - @Override - public RESULT visitDateLiteral(CONTEXT ctx, Stack stack, DateLiteral expr) throws PlanningException { - return null; - } -} http://git-wip-us.apache.org/repos/asf/tajo/blob/b143f991/tajo-core/src/main/java/org/apache/tajo/engine/planner/BasicLogicalPlanVisitor.java ---------------------------------------------------------------------- diff --git a/tajo-core/src/main/java/org/apache/tajo/engine/planner/BasicLogicalPlanVisitor.java b/tajo-core/src/main/java/org/apache/tajo/engine/planner/BasicLogicalPlanVisitor.java deleted file mode 100644 index a4e90b4..0000000 --- a/tajo-core/src/main/java/org/apache/tajo/engine/planner/BasicLogicalPlanVisitor.java +++ /dev/null @@ -1,351 +0,0 @@ -/** - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.apache.tajo.engine.planner; - -import org.apache.tajo.engine.planner.logical.*; - -import java.util.Stack; - -public class BasicLogicalPlanVisitor implements LogicalPlanVisitor { - - /** - * The prehook is called before each node is visited. - */ - @SuppressWarnings("unused") - public void preHook(LogicalPlan plan, LogicalNode node, Stack stack, CONTEXT data) - throws PlanningException { - } - - /** - * The posthook is called after each node is visited. - */ - @SuppressWarnings("unused") - public void postHook(LogicalPlan plan, LogicalNode node, Stack stack, CONTEXT data) - throws PlanningException { - } - - public CONTEXT visit(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block) - throws PlanningException { - visit(context, plan, block, block.getRoot(), new Stack()); - return context; - } - - /** - * visit visits each logicalNode recursively. - */ - public RESULT visit(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, LogicalNode node, - Stack stack) - throws PlanningException { - RESULT current; - switch (node.getType()) { - case ROOT: - current = visitRoot(context, plan, block, (LogicalRootNode) node, stack); - break; - case EXPRS: - return null; - case PROJECTION: - current = visitProjection(context, plan, block, (ProjectionNode) node, stack); - break; - case LIMIT: - current = visitLimit(context, plan, block, (LimitNode) node, stack); - break; - case SORT: - current = visitSort(context, plan, block, (SortNode) node, stack); - break; - case HAVING: - current = visitHaving(context, plan, block, (HavingNode) node, stack); - break; - case GROUP_BY: - current = visitGroupBy(context, plan, block, (GroupbyNode) node, stack); - break; - case WINDOW_AGG: - current = visitWindowAgg(context, plan, block, (WindowAggNode) node, stack); - break; - case DISTINCT_GROUP_BY: - current = visitDistinct(context, plan, block, (DistinctGroupbyNode) node, stack); - break; - case SELECTION: - current = visitFilter(context, plan, block, (SelectionNode) node, stack); - break; - case JOIN: - current = visitJoin(context, plan, block, (JoinNode) node, stack); - break; - case UNION: - current = visitUnion(context, plan, block, (UnionNode) node, stack); - break; - case EXCEPT: - current = visitExcept(context, plan, block, (ExceptNode) node, stack); - break; - case INTERSECT: - current = visitIntersect(context, plan, block, (IntersectNode) node, stack); - break; - case TABLE_SUBQUERY: - current = visitTableSubQuery(context, plan, block, (TableSubQueryNode) node, stack); - break; - case SCAN: - current = visitScan(context, plan, block, (ScanNode) node, stack); - break; - case PARTITIONS_SCAN: - current = visitPartitionedTableScan(context, plan, block, (PartitionedTableScanNode) node, stack); - break; - case STORE: - current = visitStoreTable(context, plan, block, (StoreTableNode) node, stack); - break; - case INSERT: - current = visitInsert(context, plan, block, (InsertNode) node, stack); - break; - case CREATE_DATABASE: - current = visitCreateDatabase(context, plan, block, (CreateDatabaseNode) node, stack); - break; - case DROP_DATABASE: - current = visitDropDatabase(context, plan, block, (DropDatabaseNode) node, stack); - break; - case CREATE_TABLE: - current = visitCreateTable(context, plan, block, (CreateTableNode) node, stack); - break; - case DROP_TABLE: - current = visitDropTable(context, plan, block, (DropTableNode) node, stack); - break; - case ALTER_TABLESPACE: - current = visitAlterTablespace(context, plan, block, (AlterTablespaceNode) node, stack); - break; - case ALTER_TABLE: - current = visitAlterTable(context, plan, block, (AlterTableNode) node, stack); - break; - case TRUNCATE_TABLE: - current = visitTruncateTable(context, plan, block, (TruncateTableNode) node, stack); - break; - default: - throw new PlanningException("Unknown logical node type: " + node.getType()); - } - - return current; - } - - @Override - public RESULT visitRoot(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, LogicalRootNode node, - Stack stack) throws PlanningException { - stack.push(node); - RESULT result = visit(context, plan, block, node.getChild(), stack); - stack.pop(); - return result; - } - - @Override - public RESULT visitProjection(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, ProjectionNode node, - Stack stack) - throws PlanningException { - stack.push(node); - RESULT result = visit(context, plan, block, node.getChild(), stack); - stack.pop(); - return result; - } - - @Override - public RESULT visitLimit(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, LimitNode node, - Stack stack) throws PlanningException { - stack.push(node); - RESULT result = visit(context, plan, block, node.getChild(), stack); - stack.pop(); - return result; - } - - @Override - public RESULT visitSort(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, SortNode node, - Stack stack) throws PlanningException { - stack.push(node); - RESULT result = visit(context, plan, block, node.getChild(), stack); - stack.pop(); - return result; - } - - @Override - public RESULT visitHaving(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, HavingNode node, - Stack stack) throws PlanningException { - stack.push(node); - RESULT result = visit(context, plan, block, node.getChild(), stack); - stack.pop(); - return result; - } - - @Override - public RESULT visitGroupBy(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, GroupbyNode node, - Stack stack) throws PlanningException { - stack.push(node); - RESULT result = visit(context, plan, block, node.getChild(), stack); - stack.pop(); - return result; - } - - @Override - public RESULT visitWindowAgg(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, WindowAggNode node, - Stack stack) throws PlanningException { - stack.push(node); - RESULT result = visit(context, plan, block, node.getChild(), stack); - stack.pop(); - return result; - } - - public RESULT visitDistinct(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, DistinctGroupbyNode node, - Stack stack) throws PlanningException { - stack.push(node); - RESULT result = visit(context, plan, block, node.getChild(), stack); - stack.pop(); - return result; - } - - @Override - public RESULT visitFilter(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, SelectionNode node, - Stack stack) throws PlanningException { - stack.push(node); - RESULT result = visit(context, plan, block, node.getChild(), stack); - stack.pop(); - return result; - } - - @Override - public RESULT visitJoin(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, JoinNode node, - Stack stack) throws PlanningException { - stack.push(node); - RESULT result = visit(context, plan, block, node.getLeftChild(), stack); - visit(context, plan, block, node.getRightChild(), stack); - stack.pop(); - return result; - } - - @Override - public RESULT visitUnion(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, UnionNode node, - Stack stack) throws PlanningException { - stack.push(node); - LogicalPlan.QueryBlock leftBlock = plan.getBlock(node.getLeftChild()); - RESULT result = visit(context, plan, leftBlock, leftBlock.getRoot(), stack); - LogicalPlan.QueryBlock rightBlock = plan.getBlock(node.getRightChild()); - visit(context, plan, rightBlock, rightBlock.getRoot(), stack); - stack.pop(); - return result; - } - - @Override - public RESULT visitExcept(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, ExceptNode node, - Stack stack) throws PlanningException { - stack.push(node); - RESULT result = visit(context, plan, block, node.getLeftChild(), stack); - visit(context, plan, block, node.getRightChild(), stack); - stack.pop(); - return result; - } - - @Override - public RESULT visitIntersect(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, IntersectNode node, - Stack stack) throws PlanningException { - stack.push(node); - RESULT result = visit(context, plan, block, node.getLeftChild(), stack); - visit(context, plan, block, node.getRightChild(), stack); - stack.pop(); - return result; - } - - @Override - public RESULT visitTableSubQuery(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, - TableSubQueryNode node, Stack stack) throws PlanningException { - stack.push(node); - LogicalPlan.QueryBlock childBlock = plan.getBlock(node.getSubQuery()); - RESULT result = visit(context, plan, childBlock, childBlock.getRoot(), stack); - stack.pop(); - return result; - } - - @Override - public RESULT visitScan(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, ScanNode node, - Stack stack) throws PlanningException { - return null; - } - - @Override - public RESULT visitPartitionedTableScan(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, - PartitionedTableScanNode node, Stack stack) - throws PlanningException { - return null; - } - - @Override - public RESULT visitStoreTable(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, StoreTableNode node, - Stack stack) throws PlanningException { - stack.push(node); - RESULT result = visit(context, plan, block, node.getChild(), stack); - stack.pop(); - return result; - } - - @Override - public RESULT visitInsert(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, InsertNode node, - Stack stack) throws PlanningException { - stack.push(node); - RESULT result = visit(context, plan, block, node.getChild(), stack); - stack.pop(); - return result; - } - - @Override - public RESULT visitCreateDatabase(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, - CreateDatabaseNode node, Stack stack) throws PlanningException { - return null; - } - - @Override - public RESULT visitDropDatabase(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, DropDatabaseNode node, Stack stack) throws PlanningException { - return null; - } - - @Override - public RESULT visitCreateTable(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, CreateTableNode node, - Stack stack) throws PlanningException { - RESULT result = null; - stack.push(node); - if (node.hasSubQuery()) { - result = visit(context, plan, block, node.getChild(), stack); - } - stack.pop(); - return result; - } - - @Override - public RESULT visitDropTable(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, DropTableNode node, - Stack stack) { - return null; - } - - @Override - public RESULT visitAlterTablespace(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, - AlterTablespaceNode node, Stack stack) throws PlanningException { - return null; - } - - @Override - public RESULT visitAlterTable(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, AlterTableNode node, - Stack stack) { - return null; - } - - @Override - public RESULT visitTruncateTable(CONTEXT context, LogicalPlan plan, LogicalPlan.QueryBlock block, - TruncateTableNode node, Stack stack) throws PlanningException { - return null; - } -} http://git-wip-us.apache.org/repos/asf/tajo/blob/b143f991/tajo-core/src/main/java/org/apache/tajo/engine/planner/BroadcastJoinMarkCandidateVisitor.java ---------------------------------------------------------------------- diff --git a/tajo-core/src/main/java/org/apache/tajo/engine/planner/BroadcastJoinMarkCandidateVisitor.java b/tajo-core/src/main/java/org/apache/tajo/engine/planner/BroadcastJoinMarkCandidateVisitor.java index 28ef000..6b3dc48 100644 --- a/tajo-core/src/main/java/org/apache/tajo/engine/planner/BroadcastJoinMarkCandidateVisitor.java +++ b/tajo-core/src/main/java/org/apache/tajo/engine/planner/BroadcastJoinMarkCandidateVisitor.java @@ -19,10 +19,13 @@ package org.apache.tajo.engine.planner; import org.apache.tajo.engine.planner.global.GlobalPlanner; -import org.apache.tajo.engine.planner.logical.JoinNode; -import org.apache.tajo.engine.planner.logical.LogicalNode; -import org.apache.tajo.engine.planner.logical.NodeType; -import org.apache.tajo.engine.planner.logical.ScanNode; +import org.apache.tajo.plan.visitor.BasicLogicalPlanVisitor; +import org.apache.tajo.plan.LogicalPlan; +import org.apache.tajo.plan.PlanningException; +import org.apache.tajo.plan.logical.JoinNode; +import org.apache.tajo.plan.logical.LogicalNode; +import org.apache.tajo.plan.logical.NodeType; +import org.apache.tajo.plan.logical.ScanNode; import java.util.Stack; http://git-wip-us.apache.org/repos/asf/tajo/blob/b143f991/tajo-core/src/main/java/org/apache/tajo/engine/planner/BroadcastJoinPlanVisitor.java ---------------------------------------------------------------------- diff --git a/tajo-core/src/main/java/org/apache/tajo/engine/planner/BroadcastJoinPlanVisitor.java b/tajo-core/src/main/java/org/apache/tajo/engine/planner/BroadcastJoinPlanVisitor.java index 0fb8f36..bd8efbe 100644 --- a/tajo-core/src/main/java/org/apache/tajo/engine/planner/BroadcastJoinPlanVisitor.java +++ b/tajo-core/src/main/java/org/apache/tajo/engine/planner/BroadcastJoinPlanVisitor.java @@ -19,10 +19,13 @@ package org.apache.tajo.engine.planner; import org.apache.tajo.engine.planner.global.GlobalPlanner; -import org.apache.tajo.engine.planner.logical.JoinNode; -import org.apache.tajo.engine.planner.logical.LogicalNode; -import org.apache.tajo.engine.planner.logical.NodeType; -import org.apache.tajo.engine.planner.logical.ScanNode; +import org.apache.tajo.plan.visitor.BasicLogicalPlanVisitor; +import org.apache.tajo.plan.LogicalPlan; +import org.apache.tajo.plan.PlanningException; +import org.apache.tajo.plan.logical.JoinNode; +import org.apache.tajo.plan.logical.LogicalNode; +import org.apache.tajo.plan.logical.NodeType; +import org.apache.tajo.plan.logical.ScanNode; import java.util.Stack; http://git-wip-us.apache.org/repos/asf/tajo/blob/b143f991/tajo-core/src/main/java/org/apache/tajo/engine/planner/ExplainLogicalPlanVisitor.java ---------------------------------------------------------------------- diff --git a/tajo-core/src/main/java/org/apache/tajo/engine/planner/ExplainLogicalPlanVisitor.java b/tajo-core/src/main/java/org/apache/tajo/engine/planner/ExplainLogicalPlanVisitor.java deleted file mode 100644 index a7e5375..0000000 --- a/tajo-core/src/main/java/org/apache/tajo/engine/planner/ExplainLogicalPlanVisitor.java +++ /dev/null @@ -1,247 +0,0 @@ -/** - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.apache.tajo.engine.planner; - -import org.apache.tajo.annotation.Nullable; -import org.apache.tajo.engine.planner.logical.*; - -import java.util.Stack; - -/** - * It returns a list of node plan strings. - */ -public class ExplainLogicalPlanVisitor extends BasicLogicalPlanVisitor { - - public static class Context { - public int maxDepth = -1; - public int depth = 0; - public Stack explains = new Stack(); - - public void add(int depth, PlanString planString) { - maxDepth = Math.max(maxDepth, depth); - explains.push(new DepthString(depth, planString)); - } - - public int getMaxDepth() { - return this.maxDepth; - } - - public Stack getExplains() { - return explains; - } - } - - public static class DepthString { - private int depth; - private PlanString planStr; - - DepthString(int depth, PlanString planStr) { - this.depth = depth; - this.planStr = planStr; - } - - public int getDepth() { - return depth; - } - - public PlanString getPlanString() { - return planStr; - } - } - - public Context getBlockPlanStrings(@Nullable LogicalPlan plan, LogicalNode node) throws PlanningException { - Stack stack = new Stack(); - Context explainContext = new Context(); - visit(explainContext, plan, null, node, stack); - return explainContext; - } - - @Override - public LogicalNode visitRoot(Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, LogicalRootNode node, Stack stack) - throws PlanningException { - return visit(context, plan, block, node.getChild(), stack); - } - - @Override - public LogicalNode visitProjection(Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, - ProjectionNode node, Stack stack) - throws PlanningException { - return visitUnaryNode(context, plan, block, node, stack); - } - - @Override - public LogicalNode visitLimit(Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, - LimitNode node, Stack stack) throws PlanningException { - return visitUnaryNode(context, plan, block, node, stack); - } - - @Override - public LogicalNode visitSort(Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, SortNode node, - Stack stack) throws PlanningException { - return visitUnaryNode(context, plan, block, node, stack); - } - - public LogicalNode visitHaving(Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, HavingNode node, - Stack stack) throws PlanningException { - return visitUnaryNode(context, plan, block, node, stack); - } - - @Override - public LogicalNode visitGroupBy(Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, GroupbyNode node, - Stack stack) throws PlanningException { - return visitUnaryNode(context, plan, block, node, stack); - } - - @Override - public LogicalNode visitWindowAgg(Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, WindowAggNode node, - Stack stack) throws PlanningException { - return visitUnaryNode(context, plan, block, node, stack); - } - - public LogicalNode visitDistinct(Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, DistinctGroupbyNode node, - Stack stack) throws PlanningException { - return visitUnaryNode(context, plan, block, node, stack); - } - - private LogicalNode visitUnaryNode(Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, - UnaryNode node, Stack stack) throws PlanningException { - context.depth++; - stack.push(node); - visit(context, plan, block, node.getChild(), stack); - context.depth--; - context.add(context.depth, node.getPlanString()); - return node; - } - - private LogicalNode visitBinaryNode(Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, BinaryNode node, - Stack stack) - throws PlanningException { - context.depth++; - stack.push(node); - visit(context, plan, block, node.getLeftChild(), stack); - visit(context, plan, block, node.getRightChild(), stack); - stack.pop(); - context.depth--; - context.add(context.depth, node.getPlanString()); - return node; - } - - @Override - public LogicalNode visitFilter(Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, SelectionNode node, - Stack stack) throws PlanningException { - return visitUnaryNode(context, plan, block, node, stack); - } - - @Override - public LogicalNode visitJoin(Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, JoinNode node, - Stack stack) throws PlanningException { - return visitBinaryNode(context, plan, block, node, stack); - } - - @Override - public LogicalNode visitUnion(Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, UnionNode node, - Stack stack) throws PlanningException { - return visitBinaryNode(context, plan, block, node, stack); - } - - @Override - public LogicalNode visitExcept(Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, ExceptNode node, - Stack stack) throws PlanningException { - return visitBinaryNode(context, plan, block, node, stack); - } - - @Override - public LogicalNode visitIntersect(Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, IntersectNode node, - Stack stack) throws PlanningException { - return visitBinaryNode(context, plan, block, node, stack); - } - - @Override - public LogicalNode visitTableSubQuery(Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, - TableSubQueryNode node, Stack stack) throws PlanningException { - context.depth++; - stack.push(node); - visit(context, plan, block, node.getSubQuery(), new Stack()); - stack.pop(); - context.depth--; - context.add(context.depth, node.getPlanString()); - - return node; - } - - @Override - public LogicalNode visitScan(Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, ScanNode node, - Stack stack) throws PlanningException { - context.add(context.depth, node.getPlanString()); - return node; - } - - @Override - public LogicalNode visitPartitionedTableScan(Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, - PartitionedTableScanNode node, Stack stack) - throws PlanningException { - context.add(context.depth, node.getPlanString()); - return node; - } - - @Override - public LogicalNode visitStoreTable(Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, - StoreTableNode node, Stack stack) throws PlanningException { - return visitUnaryNode(context, plan, block, node, stack); - } - - public LogicalNode visitCreateDatabase(Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, - CreateDatabaseNode node, Stack stack) throws PlanningException { - context.add(context.depth, node.getPlanString()); - return node; - } - - public LogicalNode visitDropDatabase(Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, - DropDatabaseNode node, Stack stack) throws PlanningException { - context.add(context.depth, node.getPlanString()); - return node; - } - - @Override - public LogicalNode visitInsert(Context context, LogicalPlan plan, LogicalPlan.QueryBlock block, InsertNode node, - Stack stack) throws PlanningException { - context.depth++; - stack.push(node); - super.visitInsert(context, plan, block, node, stack); - stack.pop(); - context.depth--; - context.add(context.depth, node.getPlanString()); - return node; - } - - public static String printDepthString(int maxDepth, DepthString planStr) { - StringBuilder output = new StringBuilder(); - String pad = new String(new char[planStr.getDepth() * 3]).replace('\0', ' '); - output.append(pad + planStr.getPlanString().getTitle()).append("\n"); - - for (String str : planStr.getPlanString().getExplanations()) { - output.append(pad).append(" => ").append(str).append("\n"); - } - - for (String str : planStr.getPlanString().getDetails()) { - output.append(pad).append(" => ").append(str).append("\n"); - } - return output.toString(); - } -}