Return-Path: X-Original-To: apmail-asterixdb-commits-archive@minotaur.apache.org Delivered-To: apmail-asterixdb-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 134E718DFB for ; Tue, 25 Aug 2015 17:08:09 +0000 (UTC) Received: (qmail 48670 invoked by uid 500); 25 Aug 2015 17:08:09 -0000 Delivered-To: apmail-asterixdb-commits-archive@asterixdb.apache.org Received: (qmail 48639 invoked by uid 500); 25 Aug 2015 17:08:08 -0000 Mailing-List: contact commits-help@asterixdb.incubator.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@asterixdb.incubator.apache.org Delivered-To: mailing list commits@asterixdb.incubator.apache.org Received: (qmail 48630 invoked by uid 99); 25 Aug 2015 17:08:08 -0000 Received: from Unknown (HELO spamd4-us-west.apache.org) (209.188.14.142) by apache.org (qpsmtpd/0.29) with ESMTP; Tue, 25 Aug 2015 17:08:08 +0000 Received: from localhost (localhost [127.0.0.1]) by spamd4-us-west.apache.org (ASF Mail Server at spamd4-us-west.apache.org) with ESMTP id 0A272C12B8 for ; Tue, 25 Aug 2015 17:08:08 +0000 (UTC) X-Virus-Scanned: Debian amavisd-new at spamd4-us-west.apache.org X-Spam-Flag: NO X-Spam-Score: 1.774 X-Spam-Level: * X-Spam-Status: No, score=1.774 tagged_above=-999 required=6.31 tests=[KAM_ASCII_DIVIDERS=0.8, KAM_LAZY_DOMAIN_SECURITY=1, RCVD_IN_MSPIKE_H3=-0.01, RCVD_IN_MSPIKE_WL=-0.01, RP_MATCHES_RCVD=-0.006] autolearn=disabled Received: from mx1-us-west.apache.org ([10.40.0.8]) by localhost (spamd4-us-west.apache.org [10.40.0.11]) (amavisd-new, port 10024) with ESMTP id SuCnP2lLXFAJ for ; Tue, 25 Aug 2015 17:07:55 +0000 (UTC) Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by mx1-us-west.apache.org (ASF Mail Server at mx1-us-west.apache.org) with SMTP id 3862B261B7 for ; Tue, 25 Aug 2015 17:07:55 +0000 (UTC) Received: (qmail 69529 invoked by uid 99); 25 Aug 2015 16:41:15 -0000 Received: from git1-us-west.apache.org (HELO git1-us-west.apache.org) (140.211.11.23) by apache.org (qpsmtpd/0.29) with ESMTP; Tue, 25 Aug 2015 16:41:15 +0000 Received: by git1-us-west.apache.org (ASF Mail Server at git1-us-west.apache.org, from userid 33) id DC826E3621; Tue, 25 Aug 2015 16:41:14 +0000 (UTC) Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: imaxon@apache.org To: commits@asterixdb.incubator.apache.org Date: Tue, 25 Aug 2015 16:41:42 -0000 Message-Id: In-Reply-To: <339f74e1fc5c4aabb18d5e46ecf6ba11@git.apache.org> References: <339f74e1fc5c4aabb18d5e46ecf6ba11@git.apache.org> X-Mailer: ASF-Git Admin Mailer Subject: [29/51] [partial] incubator-asterixdb-hyracks git commit: Change folder structure for Java repackage http://git-wip-us.apache.org/repos/asf/incubator-asterixdb-hyracks/blob/9939b48e/algebricks/algebricks-core/src/main/java/org/apache/hyracks/algebricks/core/algebra/operators/logical/visitors/IsomorphismVariableMappingVisitor.java ---------------------------------------------------------------------- diff --git a/algebricks/algebricks-core/src/main/java/org/apache/hyracks/algebricks/core/algebra/operators/logical/visitors/IsomorphismVariableMappingVisitor.java b/algebricks/algebricks-core/src/main/java/org/apache/hyracks/algebricks/core/algebra/operators/logical/visitors/IsomorphismVariableMappingVisitor.java new file mode 100644 index 0000000..99df45c --- /dev/null +++ b/algebricks/algebricks-core/src/main/java/org/apache/hyracks/algebricks/core/algebra/operators/logical/visitors/IsomorphismVariableMappingVisitor.java @@ -0,0 +1,447 @@ +/* + * Copyright 2009-2013 by The Regents of the University of California + * Licensed 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 from + * + * 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 edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.visitors; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; + +import org.apache.commons.lang3.mutable.Mutable; +import org.apache.commons.lang3.mutable.MutableObject; + +import edu.uci.ics.hyracks.algebricks.common.exceptions.AlgebricksException; +import edu.uci.ics.hyracks.algebricks.common.utils.Pair; +import edu.uci.ics.hyracks.algebricks.common.utils.Triple; +import edu.uci.ics.hyracks.algebricks.core.algebra.base.ILogicalExpression; +import edu.uci.ics.hyracks.algebricks.core.algebra.base.ILogicalOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.base.ILogicalPlan; +import edu.uci.ics.hyracks.algebricks.core.algebra.base.LogicalVariable; +import edu.uci.ics.hyracks.algebricks.core.algebra.expressions.AbstractLogicalExpression; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.AbstractAssignOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.AbstractOperatorWithNestedPlans; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.AggregateOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.AssignOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.DataSourceScanOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.DistinctOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.DistributeResultOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.EmptyTupleSourceOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.ExchangeOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.ExtensionOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.ExternalDataLookupOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.GroupByOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.IndexInsertDeleteOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.InnerJoinOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.InsertDeleteOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.LeftOuterJoinOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.LimitOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.MaterializeOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.NestedTupleSourceOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.OrderOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.PartitioningSplitOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.ProjectOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.ReplicateOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.RunningAggregateOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.ScriptOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.SelectOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.SinkOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.SubplanOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.TokenizeOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.UnionAllOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.UnnestMapOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.UnnestOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.WriteOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.WriteResultOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.visitors.ILogicalOperatorVisitor; + +public class IsomorphismVariableMappingVisitor implements ILogicalOperatorVisitor { + + private Map variableMapping; + + public IsomorphismVariableMappingVisitor(Map variableMapping) { + this.variableMapping = variableMapping; + } + + @Override + public Void visitAggregateOperator(AggregateOperator op, ILogicalOperator arg) throws AlgebricksException { + mapChildren(op, arg); + mapVariablesForAbstractAssign(op, arg); + return null; + } + + @Override + public Void visitRunningAggregateOperator(RunningAggregateOperator op, ILogicalOperator arg) + throws AlgebricksException { + mapChildren(op, arg); + mapVariablesForAbstractAssign(op, arg); + return null; + } + + @Override + public Void visitEmptyTupleSourceOperator(EmptyTupleSourceOperator op, ILogicalOperator arg) + throws AlgebricksException { + mapVariablesStandard(op, arg); + return null; + } + + @Override + public Void visitGroupByOperator(GroupByOperator op, ILogicalOperator arg) throws AlgebricksException { + mapChildren(op, arg); + mapVariablesForGroupBy(op, arg); + mapVariablesInNestedPlans(op, arg); + return null; + } + + @Override + public Void visitLimitOperator(LimitOperator op, ILogicalOperator arg) throws AlgebricksException { + mapVariablesStandard(op, arg); + return null; + } + + @Override + public Void visitInnerJoinOperator(InnerJoinOperator op, ILogicalOperator arg) throws AlgebricksException { + mapVariablesStandard(op, arg); + return null; + } + + @Override + public Void visitLeftOuterJoinOperator(LeftOuterJoinOperator op, ILogicalOperator arg) throws AlgebricksException { + mapVariablesStandard(op, arg); + return null; + } + + @Override + public Void visitNestedTupleSourceOperator(NestedTupleSourceOperator op, ILogicalOperator arg) + throws AlgebricksException { + ILogicalOperator inputToCreator1 = op.getSourceOperator(); + NestedTupleSourceOperator nts = (NestedTupleSourceOperator) arg; + ILogicalOperator inputToCreator2 = nts.getSourceOperator(); + inputToCreator1.accept(this, inputToCreator2); + return null; + } + + @Override + public Void visitOrderOperator(OrderOperator op, ILogicalOperator arg) throws AlgebricksException { + mapVariablesStandard(op, arg); + return null; + } + + @Override + public Void visitAssignOperator(AssignOperator op, ILogicalOperator arg) throws AlgebricksException { + mapChildren(op, arg); + mapVariablesForAbstractAssign(op, arg); + return null; + } + + @Override + public Void visitSelectOperator(SelectOperator op, ILogicalOperator arg) throws AlgebricksException { + mapVariablesStandard(op, arg); + return null; + } + + @Override + public Void visitProjectOperator(ProjectOperator op, ILogicalOperator arg) throws AlgebricksException { + mapVariablesStandard(op, arg); + return null; + } + + @Override + public Void visitPartitioningSplitOperator(PartitioningSplitOperator op, ILogicalOperator arg) + throws AlgebricksException { + mapVariablesStandard(op, arg); + return null; + } + + @Override + public Void visitReplicateOperator(ReplicateOperator op, ILogicalOperator arg) throws AlgebricksException { + mapVariablesStandard(op, arg); + return null; + } + + @Override + public Void visitMaterializeOperator(MaterializeOperator op, ILogicalOperator arg) throws AlgebricksException { + mapVariablesStandard(op, arg); + return null; + } + + @Override + public Void visitScriptOperator(ScriptOperator op, ILogicalOperator arg) throws AlgebricksException { + mapVariablesStandard(op, arg); + return null; + } + + @Override + public Void visitSubplanOperator(SubplanOperator op, ILogicalOperator arg) throws AlgebricksException { + mapChildren(op, arg); + mapVariablesInNestedPlans(op, arg); + return null; + } + + @Override + public Void visitUnionOperator(UnionAllOperator op, ILogicalOperator arg) throws AlgebricksException { + mapChildren(op, arg); + mapVariablesForUnion(op, arg); + return null; + } + + @Override + public Void visitUnnestOperator(UnnestOperator op, ILogicalOperator arg) throws AlgebricksException { + mapVariablesStandard(op, arg); + return null; + } + + @Override + public Void visitUnnestMapOperator(UnnestMapOperator op, ILogicalOperator arg) throws AlgebricksException { + mapVariablesStandard(op, arg); + return null; + } + + @Override + public Void visitDataScanOperator(DataSourceScanOperator op, ILogicalOperator arg) throws AlgebricksException { + mapVariablesStandard(op, arg); + return null; + } + + @Override + public Void visitDistinctOperator(DistinctOperator op, ILogicalOperator arg) throws AlgebricksException { + mapVariablesStandard(op, arg); + return null; + } + + @Override + public Void visitExchangeOperator(ExchangeOperator op, ILogicalOperator arg) throws AlgebricksException { + mapVariablesStandard(op, arg); + return null; + } + + @Override + public Void visitWriteOperator(WriteOperator op, ILogicalOperator arg) throws AlgebricksException { + mapVariablesStandard(op, arg); + return null; + } + + @Override + public Void visitDistributeResultOperator(DistributeResultOperator op, ILogicalOperator arg) + throws AlgebricksException { + mapVariablesStandard(op, arg); + return null; + } + + @Override + public Void visitWriteResultOperator(WriteResultOperator op, ILogicalOperator arg) throws AlgebricksException { + mapVariablesStandard(op, arg); + return null; + } + + @Override + public Void visitInsertDeleteOperator(InsertDeleteOperator op, ILogicalOperator arg) throws AlgebricksException { + mapVariablesStandard(op, arg); + return null; + } + + @Override + public Void visitIndexInsertDeleteOperator(IndexInsertDeleteOperator op, ILogicalOperator arg) + throws AlgebricksException { + mapVariablesStandard(op, arg); + return null; + } + + @Override + public Void visitTokenizeOperator(TokenizeOperator op, ILogicalOperator arg) + throws AlgebricksException { + mapVariablesStandard(op, arg); + return null; + } + + @Override + public Void visitSinkOperator(SinkOperator op, ILogicalOperator arg) throws AlgebricksException { + mapVariablesStandard(op, arg); + return null; + } + + private void mapChildren(ILogicalOperator op, ILogicalOperator opArg) throws AlgebricksException { + List> inputs = op.getInputs(); + List> inputsArg = opArg.getInputs(); + if (inputs.size() != inputsArg.size()) + throw new AlgebricksException("children are not isomoprhic"); + for (int i = 0; i < inputs.size(); i++) { + ILogicalOperator input = inputs.get(i).getValue(); + ILogicalOperator inputArg = inputsArg.get(i).getValue(); + input.accept(this, inputArg); + } + } + + private void mapVariables(ILogicalOperator left, ILogicalOperator right) throws AlgebricksException { + List producedVarLeft = new ArrayList(); + List producedVarRight = new ArrayList(); + VariableUtilities.getProducedVariables(left, producedVarLeft); + VariableUtilities.getProducedVariables(right, producedVarRight); + mapVariables(producedVarLeft, producedVarRight); + } + + private void mapVariables(List variablesLeft, List variablesRight) { + if (variablesLeft.size() != variablesRight.size()) + return; + int size = variablesLeft.size(); + for (int i = 0; i < size; i++) { + LogicalVariable left = variablesLeft.get(i); + LogicalVariable right = variablesRight.get(i); + variableMapping.put(right, left); + } + } + + private void mapVariablesForAbstractAssign(ILogicalOperator left, ILogicalOperator right) + throws AlgebricksException { + AbstractAssignOperator leftOp = (AbstractAssignOperator) left; + AbstractAssignOperator rightOp = (AbstractAssignOperator) right; + List producedVarLeft = new ArrayList(); + List producedVarRight = new ArrayList(); + VariableUtilities.getProducedVariables(left, producedVarLeft); + VariableUtilities.getProducedVariables(right, producedVarRight); + mapVariablesForAbstractAssign(producedVarLeft, leftOp.getExpressions(), producedVarRight, + rightOp.getExpressions()); + } + + private void mapVariablesForGroupBy(ILogicalOperator left, ILogicalOperator right) throws AlgebricksException { + GroupByOperator leftOp = (GroupByOperator) left; + GroupByOperator rightOp = (GroupByOperator) right; + List>> leftPairs = leftOp.getGroupByList(); + List>> rightPairs = rightOp.getGroupByList(); + mapVarExprPairList(leftPairs, rightPairs); + leftPairs = leftOp.getDecorList(); + rightPairs = rightOp.getDecorList(); + mapVarExprPairList(leftPairs, rightPairs); + } + + private void mapVarExprPairList(List>> leftPairs, + List>> rightPairs) { + if (leftPairs.size() != rightPairs.size()) + return; + for (int i = 0; i < leftPairs.size(); i++) { + ILogicalExpression exprLeft = leftPairs.get(i).second.getValue(); + LogicalVariable leftVar = leftPairs.get(i).first; + for (int j = 0; j < leftPairs.size(); j++) { + ILogicalExpression exprRight = copyExpressionAndSubtituteVars(rightPairs.get(j).second).getValue(); + if (exprLeft.equals(exprRight)) { + LogicalVariable rightVar = rightPairs.get(j).first; + if (rightVar != null && leftVar != null) { + variableMapping.put(rightVar, leftVar); + } + break; + } + } + } + } + + private void mapVariablesForAbstractAssign(List variablesLeft, + List> exprsLeft, List variablesRight, + List> exprsRight) { + if (variablesLeft.size() != variablesRight.size()) + return; + int size = variablesLeft.size(); + for (int i = 0; i < size; i++) { + ILogicalExpression exprLeft = exprsLeft.get(i).getValue(); + LogicalVariable left = variablesLeft.get(i); + for (int j = 0; j < size; j++) { + ILogicalExpression exprRight = copyExpressionAndSubtituteVars(exprsRight.get(j)).getValue(); + if (exprLeft.equals(exprRight)) { + LogicalVariable right = variablesRight.get(j); + variableMapping.put(right, left); + break; + } + } + } + } + + private void mapVariablesInNestedPlans(ILogicalOperator opOrigin, ILogicalOperator arg) throws AlgebricksException { + AbstractOperatorWithNestedPlans op = (AbstractOperatorWithNestedPlans) opOrigin; + AbstractOperatorWithNestedPlans argOp = (AbstractOperatorWithNestedPlans) arg; + List plans = op.getNestedPlans(); + List plansArg = argOp.getNestedPlans(); + if (plans.size() != plansArg.size()) + return; + for (int i = 0; i < plans.size(); i++) { + List> roots = plans.get(i).getRoots(); + List> rootsArg = plansArg.get(i).getRoots(); + if (roots.size() != rootsArg.size()) + return; + for (int j = 0; j < roots.size(); j++) { + ILogicalOperator topOp1 = roots.get(j).getValue(); + ILogicalOperator topOp2 = rootsArg.get(j).getValue(); + topOp1.accept(this, topOp2); + } + } + } + + private void mapVariablesStandard(ILogicalOperator op, ILogicalOperator arg) throws AlgebricksException { + mapChildren(op, arg); + mapVariables(op, arg); + } + + private Mutable copyExpressionAndSubtituteVars(Mutable expr) { + ILogicalExpression copy = ((AbstractLogicalExpression) expr.getValue()).cloneExpression(); + for (Entry entry : variableMapping.entrySet()) + copy.substituteVar(entry.getKey(), entry.getValue()); + return new MutableObject(copy); + } + + private void mapVariablesForUnion(ILogicalOperator op, ILogicalOperator arg) { + UnionAllOperator union = (UnionAllOperator) op; + UnionAllOperator unionArg = (UnionAllOperator) arg; + mapVarTripleList(union.getVariableMappings(), unionArg.getVariableMappings()); + } + + private void mapVarTripleList(List> leftTriples, + List> rightTriples) { + if (leftTriples.size() != rightTriples.size()) + return; + for (int i = 0; i < leftTriples.size(); i++) { + LogicalVariable leftFirstVar = leftTriples.get(i).first; + LogicalVariable leftSecondVar = leftTriples.get(i).second; + LogicalVariable leftThirdVar = leftTriples.get(i).third; + for (int j = 0; j < rightTriples.size(); j++) { + LogicalVariable rightFirstVar = rightTriples.get(j).first; + LogicalVariable rightSecondVar = rightTriples.get(j).second; + LogicalVariable rightThirdVar = rightTriples.get(j).third; + if (varEquivalent(leftFirstVar, rightFirstVar) && varEquivalent(leftSecondVar, rightSecondVar)) { + variableMapping.put(rightThirdVar, leftThirdVar); + break; + } + } + } + } + + private boolean varEquivalent(LogicalVariable left, LogicalVariable right) { + if (variableMapping.get(right) == null) + return false; + if (variableMapping.get(right).equals(left)) + return true; + else + return false; + } + + @Override + public Void visitExtensionOperator(ExtensionOperator op, ILogicalOperator arg) throws AlgebricksException { + mapVariablesStandard(op, arg); + return null; + } + + @Override + public Void visitExternalDataLookupOperator(ExternalDataLookupOperator op, ILogicalOperator arg) + throws AlgebricksException { + return null; + } + +} http://git-wip-us.apache.org/repos/asf/incubator-asterixdb-hyracks/blob/9939b48e/algebricks/algebricks-core/src/main/java/org/apache/hyracks/algebricks/core/algebra/operators/logical/visitors/LogicalPropertiesVisitor.java ---------------------------------------------------------------------- diff --git a/algebricks/algebricks-core/src/main/java/org/apache/hyracks/algebricks/core/algebra/operators/logical/visitors/LogicalPropertiesVisitor.java b/algebricks/algebricks-core/src/main/java/org/apache/hyracks/algebricks/core/algebra/operators/logical/visitors/LogicalPropertiesVisitor.java new file mode 100644 index 0000000..19fcf65 --- /dev/null +++ b/algebricks/algebricks-core/src/main/java/org/apache/hyracks/algebricks/core/algebra/operators/logical/visitors/LogicalPropertiesVisitor.java @@ -0,0 +1,350 @@ +/* + * Copyright 2009-2013 by The Regents of the University of California + * Licensed 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 from + * + * 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 edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.visitors; + +import org.apache.commons.lang3.mutable.Mutable; + +import edu.uci.ics.hyracks.algebricks.common.exceptions.AlgebricksException; +import edu.uci.ics.hyracks.algebricks.core.algebra.base.ILogicalExpression; +import edu.uci.ics.hyracks.algebricks.core.algebra.base.ILogicalOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.base.IOptimizationContext; +import edu.uci.ics.hyracks.algebricks.core.algebra.base.OperatorAnnotations; +import edu.uci.ics.hyracks.algebricks.core.algebra.expressions.IExpressionEvalSizeComputer; +import edu.uci.ics.hyracks.algebricks.core.algebra.expressions.IVariableEvalSizeEnvironment; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.AbstractAssignOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.AggregateOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.AssignOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.DataSourceScanOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.DistinctOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.DistributeResultOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.EmptyTupleSourceOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.ExchangeOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.ExtensionOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.ExternalDataLookupOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.GroupByOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.IndexInsertDeleteOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.InnerJoinOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.InsertDeleteOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.LeftOuterJoinOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.LimitOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.MaterializeOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.NestedTupleSourceOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.OrderOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.PartitioningSplitOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.ProjectOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.ReplicateOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.RunningAggregateOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.ScriptOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.SelectOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.SinkOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.SubplanOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.TokenizeOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.UnionAllOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.UnnestMapOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.UnnestOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.WriteOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.WriteResultOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.properties.ILogicalPropertiesVector; +import edu.uci.ics.hyracks.algebricks.core.algebra.properties.LogicalPropertiesVectorImpl; +import edu.uci.ics.hyracks.algebricks.core.algebra.visitors.ILogicalOperatorVisitor; +import edu.uci.ics.hyracks.algebricks.core.config.AlgebricksConfig; + +public class LogicalPropertiesVisitor implements ILogicalOperatorVisitor { + + public static void computeLogicalPropertiesDFS(ILogicalOperator op, IOptimizationContext context) + throws AlgebricksException { + LogicalPropertiesVisitor visitor = new LogicalPropertiesVisitor(); + computeLogicalPropertiesRec(op, visitor, context); + } + + private static void computeLogicalPropertiesRec(ILogicalOperator op, LogicalPropertiesVisitor visitor, + IOptimizationContext context) throws AlgebricksException { + for (Mutable ref : op.getInputs()) { + computeLogicalPropertiesRec(ref.getValue(), visitor, context); + } + op.accept(visitor, context); + if (AlgebricksConfig.DEBUG) { + AlgebricksConfig.ALGEBRICKS_LOGGER.finest("Logical properties visitor for " + op + ": " + + context.getLogicalPropertiesVector(op) + "\n"); + } + } + + @Override + public Void visitAggregateOperator(AggregateOperator op, IOptimizationContext arg) throws AlgebricksException { + // TODO Auto-generated method stub + return null; + } + + @Override + public Void visitAssignOperator(AssignOperator op, IOptimizationContext context) throws AlgebricksException { + visitAssignment(op, context); + return null; + } + + @Override + public Void visitDataScanOperator(DataSourceScanOperator op, IOptimizationContext arg) throws AlgebricksException { + // TODO Auto-generated method stub + return null; + } + + @Override + public Void visitDistinctOperator(DistinctOperator op, IOptimizationContext arg) throws AlgebricksException { + // TODO Auto-generated method stub + return null; + } + + @Override + public Void visitEmptyTupleSourceOperator(EmptyTupleSourceOperator op, IOptimizationContext arg) + throws AlgebricksException { + // TODO Auto-generated method stub + return null; + } + + @Override + public Void visitExchangeOperator(ExchangeOperator op, IOptimizationContext arg) throws AlgebricksException { + propagateCardinalityAndFrameNumber(op, arg); + return null; + } + + @Override + public Void visitGroupByOperator(GroupByOperator op, IOptimizationContext arg) throws AlgebricksException { + // TODO Auto-generated method stub + return null; + } + + @Override + public Void visitInnerJoinOperator(InnerJoinOperator op, IOptimizationContext arg) throws AlgebricksException { + // TODO Auto-generated method stub + return null; + } + + @Override + public Void visitLeftOuterJoinOperator(LeftOuterJoinOperator op, IOptimizationContext arg) + throws AlgebricksException { + // TODO Auto-generated method stub + return null; + } + + @Override + public Void visitLimitOperator(LimitOperator op, IOptimizationContext arg) throws AlgebricksException { + // TODO Auto-generated method stub + return null; + } + + @Override + public Void visitNestedTupleSourceOperator(NestedTupleSourceOperator op, IOptimizationContext arg) + throws AlgebricksException { + // TODO Auto-generated method stub + return null; + } + + @Override + public Void visitOrderOperator(OrderOperator op, IOptimizationContext arg) throws AlgebricksException { + Object annot1 = op.getAnnotations().get(OperatorAnnotations.CARDINALITY); + if (annot1 == null) { + return null; + } + Integer m = (Integer) annot1; + LogicalPropertiesVectorImpl v = new LogicalPropertiesVectorImpl(); + v.setNumberOfTuples(m); + Object annot2 = op.getAnnotations().get(OperatorAnnotations.MAX_NUMBER_FRAMES); + if (annot2 != null) { + Integer f = (Integer) annot2; + v.setMaxOutputFrames(f); + } + arg.putLogicalPropertiesVector(op, v); + return null; + } + + @Override + public Void visitPartitioningSplitOperator(PartitioningSplitOperator op, IOptimizationContext arg) + throws AlgebricksException { + // TODO Auto-generated method stub + return null; + } + + @Override + public Void visitProjectOperator(ProjectOperator op, IOptimizationContext context) throws AlgebricksException { + propagateCardinalityAndFrameNumber(op, context); + return null; + } + + @Override + public Void visitReplicateOperator(ReplicateOperator op, IOptimizationContext arg) throws AlgebricksException { + // TODO Auto-generated method stub + return null; + } + + @Override + public Void visitMaterializeOperator(MaterializeOperator op, IOptimizationContext arg) throws AlgebricksException { + // TODO Auto-generated method stub + return null; + } + + @Override + public Void visitRunningAggregateOperator(RunningAggregateOperator op, IOptimizationContext context) + throws AlgebricksException { + visitAssignment(op, context); + return null; + } + + @Override + public Void visitScriptOperator(ScriptOperator op, IOptimizationContext arg) throws AlgebricksException { + // TODO Auto-generated method stub + return null; + } + + @Override + public Void visitSelectOperator(SelectOperator op, IOptimizationContext arg) throws AlgebricksException { + // TODO Auto-generated method stub + return null; + } + + @Override + public Void visitSubplanOperator(SubplanOperator op, IOptimizationContext arg) throws AlgebricksException { + // TODO Auto-generated method stub + return null; + } + + @Override + public Void visitUnionOperator(UnionAllOperator op, IOptimizationContext arg) throws AlgebricksException { + // TODO Auto-generated method stub + return null; + } + + @Override + public Void visitUnnestMapOperator(UnnestMapOperator op, IOptimizationContext arg) throws AlgebricksException { + // TODO Auto-generated method stub + return null; + } + + @Override + public Void visitUnnestOperator(UnnestOperator op, IOptimizationContext arg) throws AlgebricksException { + // TODO Auto-generated method stub + return null; + } + + @Override + public Void visitWriteOperator(WriteOperator op, IOptimizationContext arg) throws AlgebricksException { + // TODO Auto-generated method stub + return null; + } + + @Override + public Void visitDistributeResultOperator(DistributeResultOperator op, IOptimizationContext arg) + throws AlgebricksException { + return null; + } + + @Override + public Void visitWriteResultOperator(WriteResultOperator op, IOptimizationContext arg) throws AlgebricksException { + // TODO Auto-generated method stub + return null; + } + + @Override + public Void visitInsertDeleteOperator(InsertDeleteOperator op, IOptimizationContext arg) throws AlgebricksException { + // TODO Auto-generated method stub + return null; + } + + @Override + public Void visitIndexInsertDeleteOperator(IndexInsertDeleteOperator op, IOptimizationContext arg) + throws AlgebricksException { + // TODO Auto-generated method stub + return null; + } + + @Override + public Void visitTokenizeOperator(TokenizeOperator op, IOptimizationContext arg) + throws AlgebricksException { + // TODO Auto-generated method stub + return null; + } + + @Override + public Void visitSinkOperator(SinkOperator op, IOptimizationContext arg) throws AlgebricksException { + // TODO Auto-generated method stub + return null; + } + + private LogicalPropertiesVectorImpl propagateCardinality(ILogicalOperator op, IOptimizationContext context) { + ILogicalOperator op0 = op.getInputs().get(0).getValue(); + ILogicalPropertiesVector v0 = context.getLogicalPropertiesVector(op0); + if (v0 == null) { + return null; + } + LogicalPropertiesVectorImpl v = new LogicalPropertiesVectorImpl(); + v.setNumberOfTuples(v0.getNumberOfTuples()); + context.putLogicalPropertiesVector(op, v); + return v; + } + + private void visitAssignment(AbstractAssignOperator op, IOptimizationContext context) throws AlgebricksException { + LogicalPropertiesVectorImpl v = propagateCardinality(op, context); + if (v != null && v.getNumberOfTuples() != null) { + IVariableEvalSizeEnvironment varSizeEnv = context.getVariableEvalSizeEnvironment(); + IExpressionEvalSizeComputer evalSize = context.getExpressionEvalSizeComputer(); + if (evalSize != null) { + ILogicalOperator op0 = op.getInputs().get(0).getValue(); + ILogicalPropertiesVector v0 = context.getLogicalPropertiesVector(op0); + if (v0 != null) { + long frames0 = v0.getMaxOutputFrames(); + long overhead = 0; // added per tuple + for (Mutable exprRef : op.getExpressions()) { + int sz = evalSize.getEvalSize(exprRef.getValue(), varSizeEnv); + if (sz == -1) { + return; + } + overhead += sz; + } + int frameSize = context.getPhysicalOptimizationConfig().getFrameSize(); + if (frameSize > 0) { + long sz = frames0 * frameSize + overhead * v.getNumberOfTuples(); + int frames1 = (int) (sz / frameSize); + if (sz % frameSize > 0) { + frames1++; + } + v.setMaxOutputFrames(frames1); + } + } + } + } + } + + public void propagateCardinalityAndFrameNumber(ILogicalOperator op, IOptimizationContext context) + throws AlgebricksException { + LogicalPropertiesVectorImpl v = propagateCardinality(op, context); + // propagate also max number of frames (conservatively) + ILogicalOperator op0 = op.getInputs().get(0).getValue(); + ILogicalPropertiesVector v0 = context.getLogicalPropertiesVector(op0); + if (v0 != null) { + v.setMaxOutputFrames(v0.getMaxOutputFrames()); + } + } + + @Override + public Void visitExtensionOperator(ExtensionOperator op, IOptimizationContext arg) throws AlgebricksException { + // TODO Auto-generated method stub + return null; + } + + @Override + public Void visitExternalDataLookupOperator(ExternalDataLookupOperator op, IOptimizationContext arg) + throws AlgebricksException { + return null; + } + +} http://git-wip-us.apache.org/repos/asf/incubator-asterixdb-hyracks/blob/9939b48e/algebricks/algebricks-core/src/main/java/org/apache/hyracks/algebricks/core/algebra/operators/logical/visitors/OperatorDeepCopyVisitor.java ---------------------------------------------------------------------- diff --git a/algebricks/algebricks-core/src/main/java/org/apache/hyracks/algebricks/core/algebra/operators/logical/visitors/OperatorDeepCopyVisitor.java b/algebricks/algebricks-core/src/main/java/org/apache/hyracks/algebricks/core/algebra/operators/logical/visitors/OperatorDeepCopyVisitor.java new file mode 100644 index 0000000..e62dbf8 --- /dev/null +++ b/algebricks/algebricks-core/src/main/java/org/apache/hyracks/algebricks/core/algebra/operators/logical/visitors/OperatorDeepCopyVisitor.java @@ -0,0 +1,368 @@ +/* + * Copyright 2009-2013 by The Regents of the University of California + * Licensed 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 from + * + * 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 edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.visitors; + +import java.util.ArrayList; +import java.util.List; + +import org.apache.commons.lang3.mutable.Mutable; +import org.apache.commons.lang3.mutable.MutableObject; + +import edu.uci.ics.hyracks.algebricks.common.exceptions.AlgebricksException; +import edu.uci.ics.hyracks.algebricks.common.utils.Pair; +import edu.uci.ics.hyracks.algebricks.common.utils.Triple; +import edu.uci.ics.hyracks.algebricks.core.algebra.base.ILogicalExpression; +import edu.uci.ics.hyracks.algebricks.core.algebra.base.ILogicalOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.base.ILogicalPlan; +import edu.uci.ics.hyracks.algebricks.core.algebra.base.LogicalVariable; +import edu.uci.ics.hyracks.algebricks.core.algebra.expressions.AbstractLogicalExpression; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.AggregateOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.AssignOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.DataSourceScanOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.DistinctOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.DistributeResultOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.EmptyTupleSourceOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.ExchangeOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.ExtensionOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.ExternalDataLookupOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.GroupByOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.IndexInsertDeleteOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.InnerJoinOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.InsertDeleteOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.LeftOuterJoinOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.LimitOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.MaterializeOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.NestedTupleSourceOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.OrderOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.OrderOperator.IOrder; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.PartitioningSplitOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.ProjectOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.ReplicateOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.RunningAggregateOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.ScriptOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.SelectOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.SinkOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.SubplanOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.TokenizeOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.UnionAllOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.UnnestMapOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.UnnestOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.WriteOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.WriteResultOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.util.OperatorManipulationUtil; +import edu.uci.ics.hyracks.algebricks.core.algebra.visitors.ILogicalOperatorVisitor; + +public class OperatorDeepCopyVisitor implements ILogicalOperatorVisitor { + + @Override + public ILogicalOperator visitAggregateOperator(AggregateOperator op, Void arg) throws AlgebricksException { + ArrayList newList = new ArrayList(); + ArrayList> newExpressions = new ArrayList>(); + newList.addAll(op.getVariables()); + deepCopyExpressionRefs(newExpressions, op.getExpressions()); + return new AggregateOperator(newList, newExpressions); + } + + @Override + public ILogicalOperator visitRunningAggregateOperator(RunningAggregateOperator op, Void arg) + throws AlgebricksException { + ArrayList newList = new ArrayList(); + ArrayList> newExpressions = new ArrayList>(); + newList.addAll(op.getVariables()); + deepCopyExpressionRefs(newExpressions, op.getExpressions()); + return new RunningAggregateOperator(newList, newExpressions); + } + + @Override + public ILogicalOperator visitEmptyTupleSourceOperator(EmptyTupleSourceOperator op, Void arg) + throws AlgebricksException { + return new EmptyTupleSourceOperator(); + } + + @Override + public ILogicalOperator visitGroupByOperator(GroupByOperator op, Void arg) throws AlgebricksException { + List>> groupByList = new ArrayList>>(); + List>> decoList = new ArrayList>>(); + ArrayList newSubplans = new ArrayList(); + for (Pair> pair : op.getGroupByList()) + groupByList.add(new Pair>(pair.first, + deepCopyExpressionRef(pair.second))); + for (Pair> pair : op.getDecorList()) + decoList.add(new Pair>(pair.first, + deepCopyExpressionRef(pair.second))); + for (ILogicalPlan plan : op.getNestedPlans()) { + newSubplans.add(OperatorManipulationUtil.deepCopy(plan)); + } + return new GroupByOperator(groupByList, decoList, newSubplans); + } + + @Override + public ILogicalOperator visitLimitOperator(LimitOperator op, Void arg) throws AlgebricksException { + return new LimitOperator(deepCopyExpressionRef(op.getMaxObjects()).getValue(), deepCopyExpressionRef( + op.getOffset()).getValue(), op.isTopmostLimitOp()); + } + + @Override + public ILogicalOperator visitInnerJoinOperator(InnerJoinOperator op, Void arg) throws AlgebricksException { + return new InnerJoinOperator(deepCopyExpressionRef(op.getCondition()), op.getInputs().get(0), op.getInputs() + .get(1)); + } + + @Override + public ILogicalOperator visitLeftOuterJoinOperator(LeftOuterJoinOperator op, Void arg) throws AlgebricksException { + return new LeftOuterJoinOperator(deepCopyExpressionRef(op.getCondition()), op.getInputs().get(0), op + .getInputs().get(1)); + } + + @Override + public ILogicalOperator visitNestedTupleSourceOperator(NestedTupleSourceOperator op, Void arg) + throws AlgebricksException { + return new NestedTupleSourceOperator(null); + } + + @Override + public ILogicalOperator visitOrderOperator(OrderOperator op, Void arg) throws AlgebricksException { + return new OrderOperator(this.deepCopyOrderAndExpression(op.getOrderExpressions())); + } + + @Override + public ILogicalOperator visitAssignOperator(AssignOperator op, Void arg) throws AlgebricksException { + ArrayList newList = new ArrayList(); + ArrayList> newExpressions = new ArrayList>(); + newList.addAll(op.getVariables()); + deepCopyExpressionRefs(newExpressions, op.getExpressions()); + return new AssignOperator(newList, newExpressions); + } + + @Override + public ILogicalOperator visitSelectOperator(SelectOperator op, Void arg) throws AlgebricksException { + return new SelectOperator(deepCopyExpressionRef(op.getCondition()), op.getRetainNull(), + op.getNullPlaceholderVariable()); + } + + @Override + public ILogicalOperator visitProjectOperator(ProjectOperator op, Void arg) throws AlgebricksException { + ArrayList newList = new ArrayList(); + newList.addAll(op.getVariables()); + return new ProjectOperator(newList); + } + + @Override + public ILogicalOperator visitPartitioningSplitOperator(PartitioningSplitOperator op, Void arg) + throws AlgebricksException { + ArrayList> newExpressions = new ArrayList>(); + deepCopyExpressionRefs(newExpressions, op.getExpressions()); + return new PartitioningSplitOperator(newExpressions, op.getDefaultBranchIndex()); + } + + @Override + public ILogicalOperator visitReplicateOperator(ReplicateOperator op, Void arg) throws AlgebricksException { + return new ReplicateOperator(op.getOutputArity()); + } + + @Override + public ILogicalOperator visitScriptOperator(ScriptOperator op, Void arg) throws AlgebricksException { + ArrayList newInputList = new ArrayList(); + ArrayList newOutputList = new ArrayList(); + newInputList.addAll(op.getInputVariables()); + newOutputList.addAll(op.getOutputVariables()); + return new ScriptOperator(op.getScriptDescription(), newInputList, newOutputList); + } + + @Override + public ILogicalOperator visitSubplanOperator(SubplanOperator op, Void arg) throws AlgebricksException { + ArrayList newSubplans = new ArrayList(); + for (ILogicalPlan plan : op.getNestedPlans()) { + newSubplans.add(OperatorManipulationUtil.deepCopy(plan)); + } + return new SubplanOperator(newSubplans); + } + + @Override + public ILogicalOperator visitUnionOperator(UnionAllOperator op, Void arg) throws AlgebricksException { + List> newVarMap = new ArrayList>(); + List> varMap = op.getVariableMappings(); + for (Triple triple : varMap) + newVarMap.add(new Triple(triple.first, triple.second, + triple.third)); + return new UnionAllOperator(newVarMap); + } + + @Override + public ILogicalOperator visitUnnestOperator(UnnestOperator op, Void arg) throws AlgebricksException { + return new UnnestOperator(op.getVariable(), deepCopyExpressionRef(op.getExpressionRef()), + op.getPositionalVariable(), op.getPositionalVariableType(), op.getPositionWriter()); + } + + @Override + public ILogicalOperator visitUnnestMapOperator(UnnestMapOperator op, Void arg) throws AlgebricksException { + ArrayList newInputList = new ArrayList(); + newInputList.addAll(op.getVariables()); + return new UnnestMapOperator(newInputList, deepCopyExpressionRef(op.getExpressionRef()), new ArrayList( + op.getVariableTypes()), op.propagatesInput()); + } + + @Override + public ILogicalOperator visitDataScanOperator(DataSourceScanOperator op, Void arg) throws AlgebricksException { + ArrayList newInputList = new ArrayList(); + newInputList.addAll(op.getVariables()); + return new DataSourceScanOperator(newInputList, op.getDataSource()); + } + + @Override + public ILogicalOperator visitDistinctOperator(DistinctOperator op, Void arg) throws AlgebricksException { + ArrayList> newExpressions = new ArrayList>(); + deepCopyExpressionRefs(newExpressions, op.getExpressions()); + return new DistinctOperator(newExpressions); + } + + @Override + public ILogicalOperator visitExchangeOperator(ExchangeOperator op, Void arg) throws AlgebricksException { + return new ExchangeOperator(); + } + + @Override + public ILogicalOperator visitWriteOperator(WriteOperator op, Void arg) throws AlgebricksException { + ArrayList> newExpressions = new ArrayList>(); + deepCopyExpressionRefs(newExpressions, op.getExpressions()); + return new WriteOperator(newExpressions, op.getDataSink()); + } + + @Override + public ILogicalOperator visitDistributeResultOperator(DistributeResultOperator op, Void arg) + throws AlgebricksException { + ArrayList> newExpressions = new ArrayList>(); + deepCopyExpressionRefs(newExpressions, op.getExpressions()); + return new DistributeResultOperator(newExpressions, op.getDataSink()); + } + + @Override + public ILogicalOperator visitWriteResultOperator(WriteResultOperator op, Void arg) throws AlgebricksException { + ArrayList> newKeyExpressions = new ArrayList>(); + deepCopyExpressionRefs(newKeyExpressions, op.getKeyExpressions()); + List> newLSMComponentFilterExpressions = new ArrayList>(); + deepCopyExpressionRefs(newKeyExpressions, op.getAdditionalFilteringExpressions()); + WriteResultOperator writeResultOp = new WriteResultOperator(op.getDataSource(), + deepCopyExpressionRef(op.getPayloadExpression()), newKeyExpressions); + writeResultOp.setAdditionalFilteringExpressions(newLSMComponentFilterExpressions); + return writeResultOp; + } + + @Override + public ILogicalOperator visitInsertDeleteOperator(InsertDeleteOperator op, Void arg) throws AlgebricksException { + List> newKeyExpressions = new ArrayList>(); + deepCopyExpressionRefs(newKeyExpressions, op.getPrimaryKeyExpressions()); + List> newLSMComponentFilterExpressions = new ArrayList>(); + deepCopyExpressionRefs(newKeyExpressions, op.getAdditionalFilteringExpressions()); + InsertDeleteOperator insertDeleteOp = new InsertDeleteOperator(op.getDataSource(), + deepCopyExpressionRef(op.getPayloadExpression()), newKeyExpressions, op.getOperation(), op.isBulkload()); + insertDeleteOp.setAdditionalFilteringExpressions(newLSMComponentFilterExpressions); + return insertDeleteOp; + } + + @Override + public ILogicalOperator visitIndexInsertDeleteOperator(IndexInsertDeleteOperator op, Void arg) + throws AlgebricksException { + List> newPrimaryKeyExpressions = new ArrayList>(); + deepCopyExpressionRefs(newPrimaryKeyExpressions, op.getPrimaryKeyExpressions()); + List> newSecondaryKeyExpressions = new ArrayList>(); + deepCopyExpressionRefs(newSecondaryKeyExpressions, op.getSecondaryKeyExpressions()); + Mutable newFilterExpression = new MutableObject( + ((AbstractLogicalExpression) op.getFilterExpression()).cloneExpression()); + List> newLSMComponentFilterExpressions = new ArrayList>(); + deepCopyExpressionRefs(newLSMComponentFilterExpressions, op.getAdditionalFilteringExpressions()); + IndexInsertDeleteOperator indexInsertDeleteOp = new IndexInsertDeleteOperator(op.getDataSourceIndex(), + newPrimaryKeyExpressions, newSecondaryKeyExpressions, newFilterExpression, op.getOperation(), + op.isBulkload()); + indexInsertDeleteOp.setAdditionalFilteringExpressions(newLSMComponentFilterExpressions); + return indexInsertDeleteOp; + } + + @Override + public ILogicalOperator visitTokenizeOperator(TokenizeOperator op, Void arg) throws AlgebricksException { + List> newPrimaryKeyExpressions = new ArrayList>(); + deepCopyExpressionRefs(newPrimaryKeyExpressions, op.getPrimaryKeyExpressions()); + List> newSecondaryKeyExpressions = new ArrayList>(); + deepCopyExpressionRefs(newSecondaryKeyExpressions, op.getSecondaryKeyExpressions()); + List newTokenizeVars = new ArrayList(); + deepCopyVars(newTokenizeVars, op.getTokenizeVars()); + Mutable newFilterExpression = new MutableObject( + ((AbstractLogicalExpression) op.getFilterExpression()).cloneExpression()); + List newTokenizeVarTypes = new ArrayList(); + deepCopyObjects(newTokenizeVarTypes, op.getTokenizeVarTypes()); + + TokenizeOperator tokenizeOp = new TokenizeOperator(op.getDataSourceIndex(), newPrimaryKeyExpressions, + newSecondaryKeyExpressions, newTokenizeVars, newFilterExpression, op.getOperation(), op.isBulkload(), + op.isPartitioned(), newTokenizeVarTypes); + return tokenizeOp; + } + + @Override + public ILogicalOperator visitSinkOperator(SinkOperator op, Void arg) throws AlgebricksException { + return new SinkOperator(); + } + + private void deepCopyExpressionRefs(List> newExprs, + List> oldExprs) { + for (Mutable oldExpr : oldExprs) + newExprs.add(new MutableObject(((AbstractLogicalExpression) oldExpr.getValue()) + .cloneExpression())); + } + + private Mutable deepCopyExpressionRef(Mutable oldExpr) { + return new MutableObject(((AbstractLogicalExpression) oldExpr.getValue()).cloneExpression()); + } + + private List deepCopyVars(List newVars, List oldVars) { + for (LogicalVariable oldVar : oldVars) + newVars.add(oldVar); + return newVars; + } + + private List deepCopyObjects(List newObjs, List oldObjs) { + for (Object oldObj : oldObjs) + newObjs.add(oldObj); + return newObjs; + } + + private List>> deepCopyOrderAndExpression( + List>> ordersAndExprs) { + List>> newOrdersAndExprs = new ArrayList>>(); + for (Pair> pair : ordersAndExprs) + newOrdersAndExprs.add(new Pair>(pair.first, + deepCopyExpressionRef(pair.second))); + return newOrdersAndExprs; + } + + @Override + public ILogicalOperator visitExtensionOperator(ExtensionOperator op, Void arg) throws AlgebricksException { + return new ExtensionOperator(op.getNewInstanceOfDelegateOperator()); + } + + @Override + public ILogicalOperator visitExternalDataLookupOperator(ExternalDataLookupOperator op, Void arg) + throws AlgebricksException { + ArrayList newInputList = new ArrayList(); + newInputList.addAll(op.getVariables()); + return new ExternalDataLookupOperator(newInputList, deepCopyExpressionRef(op.getExpressionRef()), + new ArrayList(op.getVariableTypes()), op.isPropagateInput(), op.getDataSource()); + } + + @Override + public ILogicalOperator visitMaterializeOperator(MaterializeOperator op, Void arg) throws AlgebricksException { + return new MaterializeOperator(); + } +} http://git-wip-us.apache.org/repos/asf/incubator-asterixdb-hyracks/blob/9939b48e/algebricks/algebricks-core/src/main/java/org/apache/hyracks/algebricks/core/algebra/operators/logical/visitors/ProducedVariableVisitor.java ---------------------------------------------------------------------- diff --git a/algebricks/algebricks-core/src/main/java/org/apache/hyracks/algebricks/core/algebra/operators/logical/visitors/ProducedVariableVisitor.java b/algebricks/algebricks-core/src/main/java/org/apache/hyracks/algebricks/core/algebra/operators/logical/visitors/ProducedVariableVisitor.java new file mode 100644 index 0000000..1fa97a6 --- /dev/null +++ b/algebricks/algebricks-core/src/main/java/org/apache/hyracks/algebricks/core/algebra/operators/logical/visitors/ProducedVariableVisitor.java @@ -0,0 +1,275 @@ +/* + * Copyright 2009-2013 by The Regents of the University of California + * Licensed 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 from + * + * 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 edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.visitors; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.apache.commons.lang3.mutable.Mutable; + +import edu.uci.ics.hyracks.algebricks.common.exceptions.AlgebricksException; +import edu.uci.ics.hyracks.algebricks.common.utils.Pair; +import edu.uci.ics.hyracks.algebricks.common.utils.Triple; +import edu.uci.ics.hyracks.algebricks.core.algebra.base.ILogicalExpression; +import edu.uci.ics.hyracks.algebricks.core.algebra.base.ILogicalOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.base.ILogicalPlan; +import edu.uci.ics.hyracks.algebricks.core.algebra.base.LogicalVariable; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.AggregateOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.AssignOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.DataSourceScanOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.DistinctOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.DistributeResultOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.EmptyTupleSourceOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.ExchangeOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.ExtensionOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.ExternalDataLookupOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.GroupByOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.IndexInsertDeleteOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.InnerJoinOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.InsertDeleteOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.LeftOuterJoinOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.LimitOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.MaterializeOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.NestedTupleSourceOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.OrderOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.PartitioningSplitOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.ProjectOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.ReplicateOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.RunningAggregateOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.ScriptOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.SelectOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.SinkOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.SubplanOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.TokenizeOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.UnionAllOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.UnnestMapOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.UnnestOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.WriteOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.WriteResultOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.visitors.ILogicalOperatorVisitor; + +public class ProducedVariableVisitor implements ILogicalOperatorVisitor { + + private Collection producedVariables; + + public ProducedVariableVisitor(Collection producedVariables) throws AlgebricksException { + this.producedVariables = producedVariables; + } + + @Override + public Void visitAggregateOperator(AggregateOperator op, Void arg) throws AlgebricksException { + producedVariables.addAll(op.getVariables()); + return null; + } + + @Override + public Void visitAssignOperator(AssignOperator op, Void arg) throws AlgebricksException { + producedVariables.addAll(op.getVariables()); + return null; + } + + @Override + public Void visitDataScanOperator(DataSourceScanOperator op, Void arg) throws AlgebricksException { + producedVariables.addAll(op.getVariables()); + return null; + } + + @Override + public Void visitDistinctOperator(DistinctOperator op, Void arg) { + return null; + } + + @Override + public Void visitEmptyTupleSourceOperator(EmptyTupleSourceOperator op, Void arg) throws AlgebricksException { + return null; + } + + @Override + public Void visitExchangeOperator(ExchangeOperator op, Void arg) throws AlgebricksException { + return null; + } + + @Override + public Void visitGroupByOperator(GroupByOperator op, Void arg) throws AlgebricksException { + for (ILogicalPlan p : op.getNestedPlans()) { + for (Mutable r : p.getRoots()) { + VariableUtilities.getLiveVariables(r.getValue(), producedVariables); + } + } + for (Pair> p : op.getGroupByList()) { + if (p.first != null) { + producedVariables.add(p.first); + } + } + for (Pair> p : op.getDecorList()) { + if (p.first != null) { + producedVariables.add(p.first); + } + } + return null; + } + + @Override + public Void visitInnerJoinOperator(InnerJoinOperator op, Void arg) throws AlgebricksException { + return null; + } + + @Override + public Void visitLeftOuterJoinOperator(LeftOuterJoinOperator op, Void arg) throws AlgebricksException { + return null; + } + + @Override + public Void visitLimitOperator(LimitOperator op, Void arg) throws AlgebricksException { + return null; + } + + @Override + public Void visitNestedTupleSourceOperator(NestedTupleSourceOperator op, Void arg) throws AlgebricksException { + return null; + } + + @Override + public Void visitOrderOperator(OrderOperator op, Void arg) throws AlgebricksException { + return null; + } + + @Override + public Void visitPartitioningSplitOperator(PartitioningSplitOperator op, Void arg) throws AlgebricksException { + return null; + } + + @Override + public Void visitProjectOperator(ProjectOperator op, Void arg) throws AlgebricksException { + return null; + } + + @Override + public Void visitRunningAggregateOperator(RunningAggregateOperator op, Void arg) throws AlgebricksException { + producedVariables.addAll(op.getVariables()); + return null; + } + + @Override + public Void visitScriptOperator(ScriptOperator op, Void arg) throws AlgebricksException { + List usedVariables = new ArrayList(); + VariableUtilities.getUsedVariables(op, usedVariables); + for (LogicalVariable v : op.getOutputVariables()) { + if (!usedVariables.contains(v)) { + producedVariables.add(v); + } + } + return null; + } + + @Override + public Void visitSelectOperator(SelectOperator op, Void arg) throws AlgebricksException { + return null; + } + + @Override + public Void visitSubplanOperator(SubplanOperator op, Void arg) throws AlgebricksException { + for (ILogicalPlan p : op.getNestedPlans()) { + for (Mutable r : p.getRoots()) { + VariableUtilities.getLiveVariables(r.getValue(), producedVariables); + } + } + return null; + } + + @Override + public Void visitUnionOperator(UnionAllOperator op, Void arg) throws AlgebricksException { + for (Triple t : op.getVariableMappings()) { + producedVariables.add(t.third); + } + return null; + } + + @Override + public Void visitUnnestMapOperator(UnnestMapOperator op, Void arg) throws AlgebricksException { + producedVariables.addAll(op.getVariables()); + return null; + } + + @Override + public Void visitUnnestOperator(UnnestOperator op, Void arg) throws AlgebricksException { + producedVariables.addAll(op.getVariables()); + LogicalVariable positionalVariable = op.getPositionalVariable(); + if (positionalVariable != null) { + if (!producedVariables.contains(positionalVariable)) + producedVariables.add(positionalVariable); + } + return null; + } + + @Override + public Void visitWriteOperator(WriteOperator op, Void arg) throws AlgebricksException { + return null; + } + + @Override + public Void visitDistributeResultOperator(DistributeResultOperator op, Void arg) throws AlgebricksException { + return null; + } + + @Override + public Void visitWriteResultOperator(WriteResultOperator op, Void arg) throws AlgebricksException { + return null; + } + + @Override + public Void visitReplicateOperator(ReplicateOperator op, Void arg) throws AlgebricksException { + return null; + } + + @Override + public Void visitMaterializeOperator(MaterializeOperator op, Void arg) throws AlgebricksException { + return null; + } + + @Override + public Void visitInsertDeleteOperator(InsertDeleteOperator op, Void arg) throws AlgebricksException { + return null; + } + + @Override + public Void visitIndexInsertDeleteOperator(IndexInsertDeleteOperator op, Void arg) throws AlgebricksException { + return null; + } + + @Override + public Void visitTokenizeOperator(TokenizeOperator op, Void arg) throws AlgebricksException { + producedVariables.addAll(op.getTokenizeVars()); + return null; + } + + @Override + public Void visitSinkOperator(SinkOperator op, Void arg) throws AlgebricksException { + return null; + } + + @Override + public Void visitExtensionOperator(ExtensionOperator op, Void arg) throws AlgebricksException { + op.getDelegate().getProducedVariables(producedVariables); + return null; + } + + @Override + public Void visitExternalDataLookupOperator(ExternalDataLookupOperator op, Void arg) throws AlgebricksException { + producedVariables.add(op.getVariables().get(0)); + return null; + } +} http://git-wip-us.apache.org/repos/asf/incubator-asterixdb-hyracks/blob/9939b48e/algebricks/algebricks-core/src/main/java/org/apache/hyracks/algebricks/core/algebra/operators/logical/visitors/SchemaVariableVisitor.java ---------------------------------------------------------------------- diff --git a/algebricks/algebricks-core/src/main/java/org/apache/hyracks/algebricks/core/algebra/operators/logical/visitors/SchemaVariableVisitor.java b/algebricks/algebricks-core/src/main/java/org/apache/hyracks/algebricks/core/algebra/operators/logical/visitors/SchemaVariableVisitor.java new file mode 100644 index 0000000..0b37b92 --- /dev/null +++ b/algebricks/algebricks-core/src/main/java/org/apache/hyracks/algebricks/core/algebra/operators/logical/visitors/SchemaVariableVisitor.java @@ -0,0 +1,330 @@ +/* + * Copyright 2009-2013 by The Regents of the University of California + * Licensed 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 from + * + * 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 edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.visitors; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.apache.commons.lang3.mutable.Mutable; + +import edu.uci.ics.hyracks.algebricks.common.exceptions.AlgebricksException; +import edu.uci.ics.hyracks.algebricks.common.utils.Pair; +import edu.uci.ics.hyracks.algebricks.core.algebra.base.ILogicalExpression; +import edu.uci.ics.hyracks.algebricks.core.algebra.base.ILogicalOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.base.ILogicalPlan; +import edu.uci.ics.hyracks.algebricks.core.algebra.base.LogicalExpressionTag; +import edu.uci.ics.hyracks.algebricks.core.algebra.base.LogicalVariable; +import edu.uci.ics.hyracks.algebricks.core.algebra.expressions.VariableReferenceExpression; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.AggregateOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.AssignOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.DataSourceScanOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.DistinctOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.DistributeResultOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.EmptyTupleSourceOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.ExchangeOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.ExtensionOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.ExternalDataLookupOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.GroupByOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.IndexInsertDeleteOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.InnerJoinOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.InsertDeleteOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.LeftOuterJoinOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.LimitOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.MaterializeOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.NestedTupleSourceOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.OrderOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.PartitioningSplitOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.ProjectOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.ReplicateOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.RunningAggregateOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.ScriptOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.SelectOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.SinkOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.SubplanOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.TokenizeOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.UnionAllOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.UnnestMapOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.UnnestOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.WriteOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.WriteResultOperator; +import edu.uci.ics.hyracks.algebricks.core.algebra.visitors.ILogicalOperatorVisitor; + +public class SchemaVariableVisitor implements ILogicalOperatorVisitor { + + private Collection schemaVariables; + + public SchemaVariableVisitor(Collection schemaVariables) { + this.schemaVariables = schemaVariables; + } + + @Override + public Void visitAggregateOperator(AggregateOperator op, Void arg) throws AlgebricksException { + schemaVariables.addAll(op.getVariables()); + return null; + } + + @Override + public Void visitAssignOperator(AssignOperator op, Void arg) throws AlgebricksException { + standardLayout(op); + return null; + } + + @Override + public Void visitDataScanOperator(DataSourceScanOperator op, Void arg) throws AlgebricksException { + standardLayout(op); + return null; + } + + @Override + public Void visitDistinctOperator(DistinctOperator op, Void arg) throws AlgebricksException { + List allLiveVars = new ArrayList(); + for (Mutable c : op.getInputs()) { + VariableUtilities.getLiveVariables(c.getValue(), allLiveVars); + } + VariableUtilities.getProducedVariables(op, allLiveVars); + /** put distinct vars first */ + schemaVariables.addAll(op.getDistinctByVarList()); + /** then other live vars */ + for (LogicalVariable var : allLiveVars) { + if (!schemaVariables.contains(var)) { + schemaVariables.add(var); + } + } + return null; + } + + @Override + public Void visitEmptyTupleSourceOperator(EmptyTupleSourceOperator op, Void arg) throws AlgebricksException { + standardLayout(op); + return null; + } + + @Override + public Void visitExchangeOperator(ExchangeOperator op, Void arg) throws AlgebricksException { + standardLayout(op); + return null; + } + + @Override + public Void visitGroupByOperator(GroupByOperator op, Void arg) throws AlgebricksException { + for (ILogicalPlan p : op.getNestedPlans()) { + for (Mutable r : p.getRoots()) { + VariableUtilities.getLiveVariables(r.getValue(), schemaVariables); + } + } + for (Pair> p : op.getGroupByList()) { + if (p.first != null) { + schemaVariables.add(p.first); + } + } + for (Pair> p : op.getDecorList()) { + if (p.first != null) { + schemaVariables.add(p.first); + } else { + ILogicalExpression e = p.second.getValue(); + if (e.getExpressionTag() == LogicalExpressionTag.VARIABLE) { + schemaVariables.add(((VariableReferenceExpression) e).getVariableReference()); + } + } + } + return null; + } + + @Override + public Void visitInnerJoinOperator(InnerJoinOperator op, Void arg) throws AlgebricksException { + standardLayout(op); + return null; + } + + @Override + public Void visitLeftOuterJoinOperator(LeftOuterJoinOperator op, Void arg) throws AlgebricksException { + standardLayout(op); + return null; + } + + @Override + public Void visitLimitOperator(LimitOperator op, Void arg) throws AlgebricksException { + standardLayout(op); + return null; + } + + @Override + public Void visitNestedTupleSourceOperator(NestedTupleSourceOperator op, Void arg) throws AlgebricksException { + VariableUtilities.getLiveVariables(op.getSourceOperator(), schemaVariables); + return null; + } + + @Override + public Void visitOrderOperator(OrderOperator op, Void arg) throws AlgebricksException { + standardLayout(op); + return null; + } + + @Override + public Void visitPartitioningSplitOperator(PartitioningSplitOperator op, Void arg) throws AlgebricksException { + standardLayout(op); + return null; + } + + @Override + public Void visitProjectOperator(ProjectOperator op, Void arg) throws AlgebricksException { + schemaVariables.addAll(op.getVariables()); + return null; + } + + @Override + public Void visitRunningAggregateOperator(RunningAggregateOperator op, Void arg) throws AlgebricksException { + // VariableUtilities.getProducedVariables(op, schemaVariables); + standardLayout(op); + return null; + } + + @Override + public Void visitScriptOperator(ScriptOperator op, Void arg) throws AlgebricksException { + schemaVariables.addAll(op.getOutputVariables()); + return null; + } + + @Override + public Void visitSelectOperator(SelectOperator op, Void arg) throws AlgebricksException { + standardLayout(op); + return null; + } + + @Override + public Void visitSubplanOperator(SubplanOperator op, Void arg) throws AlgebricksException { + for (Mutable c : op.getInputs()) { + VariableUtilities.getLiveVariables(c.getValue(), schemaVariables); + } + VariableUtilities.getProducedVariables(op, schemaVariables); + for (ILogicalPlan p : op.getNestedPlans()) { + for (Mutable r : p.getRoots()) { + VariableUtilities.getLiveVariables(r.getValue(), schemaVariables); + } + } + return null; + } + + @Override + public Void visitUnionOperator(UnionAllOperator op, Void arg) throws AlgebricksException { + VariableUtilities.getProducedVariables(op, schemaVariables); + return null; + } + + @Override + public Void visitUnnestMapOperator(UnnestMapOperator op, Void arg) throws AlgebricksException { + if (op.propagatesInput()) { + standardLayout(op); + } else { + VariableUtilities.getProducedVariables(op, schemaVariables); + } + return null; + } + + @Override + public Void visitUnnestOperator(UnnestOperator op, Void arg) throws AlgebricksException { + standardLayout(op); + return null; + } + + @Override + public Void visitWriteOperator(WriteOperator op, Void arg) throws AlgebricksException { + standardLayout(op); + return null; + } + + @Override + public Void visitDistributeResultOperator(DistributeResultOperator op, Void arg) throws AlgebricksException { + standardLayout(op); + return null; + } + + @Override + public Void visitWriteResultOperator(WriteResultOperator op, Void arg) throws AlgebricksException { + standardLayout(op); + return null; + } + + private void standardLayout(ILogicalOperator op) throws AlgebricksException { + for (Mutable c : op.getInputs()) { + VariableUtilities.getLiveVariables(c.getValue(), schemaVariables); + } + VariableUtilities.getProducedVariables(op, schemaVariables); + } + + @Override + public Void visitReplicateOperator(ReplicateOperator op, Void arg) throws AlgebricksException { + standardLayout(op); + return null; + } + + @Override + public Void visitMaterializeOperator(MaterializeOperator op, Void arg) throws AlgebricksException { + standardLayout(op); + return null; + } + + @Override + public Void visitInsertDeleteOperator(InsertDeleteOperator op, Void arg) throws AlgebricksException { + standardLayout(op); + return null; + } + + @Override + public Void visitIndexInsertDeleteOperator(IndexInsertDeleteOperator op, Void arg) throws AlgebricksException { + standardLayout(op); + return null; + } + + @Override + public Void visitTokenizeOperator(TokenizeOperator op, Void arg) throws AlgebricksException { + standardLayout(op); + return null; + } + + @Override + public Void visitSinkOperator(SinkOperator op, Void arg) throws AlgebricksException { + standardLayout(op); + return null; + } + + @Override + public Void visitExtensionOperator(ExtensionOperator op, Void arg) throws AlgebricksException { + standardLayout(op); + return null; + } + + @Override + public Void visitExternalDataLookupOperator(ExternalDataLookupOperator op, Void arg) throws AlgebricksException { + ArrayList liveVariables = new ArrayList(); + ArrayList usedVariables = new ArrayList(); + //get used variables + op.getExpressionRef().getValue().getUsedVariables(usedVariables); + //live variables - used variables + for (Mutable c : op.getInputs()) { + VariableUtilities.getLiveVariables(c.getValue(), liveVariables); + } + for (LogicalVariable v : liveVariables) { + if (!usedVariables.contains(v)) { + schemaVariables.add(v); + } + } + VariableUtilities.getProducedVariables(op, schemaVariables); + //+ produced variables + return null; + } + +}