You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@asterixdb.apache.org by im...@apache.org on 2015/08/25 18:41:25 UTC
[12/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-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/PushGroupByIntoSortRule.java
----------------------------------------------------------------------
diff --git a/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/PushGroupByIntoSortRule.java b/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/PushGroupByIntoSortRule.java
deleted file mode 100644
index 56b2a8e..0000000
--- a/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/PushGroupByIntoSortRule.java
+++ /dev/null
@@ -1,150 +0,0 @@
-/*
- * 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.rewriter.rules;
-
-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.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.IOptimizationContext;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.LogicalOperatorTag;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.LogicalVariable;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.PhysicalOperatorTag;
-import edu.uci.ics.hyracks.algebricks.core.algebra.expressions.IMergeAggregationExpressionFactory;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.AbstractLogicalOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.AggregateOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.GroupByOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.physical.AbstractStableSortPOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.physical.SortGroupByPOperator;
-import edu.uci.ics.hyracks.algebricks.core.rewriter.base.IAlgebraicRewriteRule;
-
-/**
- * @author yingyib
- * merge externalsort+preclustered-gby into sort-gby
- */
-public class PushGroupByIntoSortRule implements IAlgebraicRewriteRule {
-
- @Override
- public boolean rewritePre(Mutable<ILogicalOperator> opRef, IOptimizationContext context) throws AlgebricksException {
- return false;
- }
-
- @Override
- public boolean rewritePost(Mutable<ILogicalOperator> opRef, IOptimizationContext context)
- throws AlgebricksException {
- ILogicalOperator op1 = opRef.getValue();
- if (op1 == null) {
- return false;
- }
- boolean changed = false;
- for (Mutable<ILogicalOperator> childRef : op1.getInputs()) {
- AbstractLogicalOperator op = (AbstractLogicalOperator) childRef.getValue();
- if (op.getOperatorTag() == LogicalOperatorTag.GROUP) {
- PhysicalOperatorTag opTag = op.getPhysicalOperator().getOperatorTag();
- GroupByOperator groupByOperator = (GroupByOperator) op;
- if (opTag == PhysicalOperatorTag.PRE_CLUSTERED_GROUP_BY) {
- Mutable<ILogicalOperator> op2Ref = op.getInputs().get(0).getValue().getInputs().get(0);
- AbstractLogicalOperator op2 = (AbstractLogicalOperator) op2Ref.getValue();
- if (op2.getPhysicalOperator().getOperatorTag() == PhysicalOperatorTag.STABLE_SORT) {
- AbstractStableSortPOperator sortPhysicalOperator = (AbstractStableSortPOperator) op2
- .getPhysicalOperator();
- if (groupByOperator.getNestedPlans().size() != 1) {
- //Sort group-by currently works only for one nested plan with one root containing
- //an aggregate and a nested-tuple-source.
- continue;
- }
- ILogicalPlan p0 = groupByOperator.getNestedPlans().get(0);
- if (p0.getRoots().size() != 1) {
- //Sort group-by currently works only for one nested plan with one root containing
- //an aggregate and a nested-tuple-source.
- continue;
- }
-
- Mutable<ILogicalOperator> r0 = p0.getRoots().get(0);
- AbstractLogicalOperator r0Logical = (AbstractLogicalOperator) r0.getValue();
- if (r0Logical.getOperatorTag() != LogicalOperatorTag.AGGREGATE) {
- //we only rewrite aggregation function; do nothing for running aggregates
- continue;
- }
- AggregateOperator aggOp = (AggregateOperator) r0.getValue();
- AbstractLogicalOperator aggInputOp = (AbstractLogicalOperator) aggOp.getInputs().get(0)
- .getValue();
- if (aggInputOp.getOperatorTag() != LogicalOperatorTag.NESTEDTUPLESOURCE) {
- continue;
- }
-
- boolean hasIntermediateAggregate = generateMergeAggregationExpressions(groupByOperator, context);
- if (!hasIntermediateAggregate) {
- continue;
- }
-
- //replace preclustered gby with sort gby
- op.setPhysicalOperator(new SortGroupByPOperator(groupByOperator.getGroupByList(), context
- .getPhysicalOptimizationConfig().getMaxFramesExternalGroupBy(), sortPhysicalOperator
- .getSortColumns()));
-
- // remove the stable sort operator
- op.getInputs().clear();
- op.getInputs().addAll(op2.getInputs());
- changed = true;
- }
- }
- continue;
- } else {
- continue;
- }
- }
- return changed;
- }
-
- private boolean generateMergeAggregationExpressions(GroupByOperator gby, IOptimizationContext context)
- throws AlgebricksException {
- if (gby.getNestedPlans().size() != 1) {
- throw new AlgebricksException(
- "External/sort group-by currently works only for one nested plan with one root containing"
- + "an aggregate and a nested-tuple-source.");
- }
- ILogicalPlan p0 = gby.getNestedPlans().get(0);
- if (p0.getRoots().size() != 1) {
- throw new AlgebricksException(
- "External/sort group-by currently works only for one nested plan with one root containing"
- + "an aggregate and a nested-tuple-source.");
- }
- IMergeAggregationExpressionFactory mergeAggregationExpressionFactory = context
- .getMergeAggregationExpressionFactory();
- Mutable<ILogicalOperator> r0 = p0.getRoots().get(0);
- AggregateOperator aggOp = (AggregateOperator) r0.getValue();
- List<Mutable<ILogicalExpression>> aggFuncRefs = aggOp.getExpressions();
- List<LogicalVariable> originalAggVars = aggOp.getVariables();
- int n = aggOp.getExpressions().size();
- List<Mutable<ILogicalExpression>> mergeExpressionRefs = new ArrayList<Mutable<ILogicalExpression>>();
- for (int i = 0; i < n; i++) {
- ILogicalExpression mergeExpr = mergeAggregationExpressionFactory.createMergeAggregation(
- originalAggVars.get(i), aggFuncRefs.get(i).getValue(), context);
- if (mergeExpr == null) {
- return false;
- }
- mergeExpressionRefs.add(new MutableObject<ILogicalExpression>(mergeExpr));
- }
- aggOp.setMergeExpressions(mergeExpressionRefs);
- return true;
- }
-}
http://git-wip-us.apache.org/repos/asf/incubator-asterixdb-hyracks/blob/9939b48e/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/PushMapOperatorDownThroughProductRule.java
----------------------------------------------------------------------
diff --git a/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/PushMapOperatorDownThroughProductRule.java b/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/PushMapOperatorDownThroughProductRule.java
deleted file mode 100644
index 16a71a4..0000000
--- a/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/PushMapOperatorDownThroughProductRule.java
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
- * 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.rewriter.rules;
-
-import java.util.ArrayList;
-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.core.algebra.base.ILogicalOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.IOptimizationContext;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.LogicalOperatorTag;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.LogicalVariable;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.AbstractBinaryJoinOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.AbstractLogicalOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.visitors.VariableUtilities;
-import edu.uci.ics.hyracks.algebricks.core.algebra.util.OperatorPropertiesUtil;
-import edu.uci.ics.hyracks.algebricks.core.rewriter.base.IAlgebraicRewriteRule;
-
-public class PushMapOperatorDownThroughProductRule implements IAlgebraicRewriteRule {
-
- @Override
- public boolean rewritePre(Mutable<ILogicalOperator> opRef, IOptimizationContext context) throws AlgebricksException {
- return false;
- }
-
- @Override
- public boolean rewritePost(Mutable<ILogicalOperator> opRef, IOptimizationContext context)
- throws AlgebricksException {
- AbstractLogicalOperator op1 = (AbstractLogicalOperator) opRef.getValue();
- if (!op1.isMap()) {
- return false;
- }
- Mutable<ILogicalOperator> op2Ref = op1.getInputs().get(0);
- AbstractLogicalOperator op2 = (AbstractLogicalOperator) op2Ref.getValue();
- if (op2.getOperatorTag() != LogicalOperatorTag.INNERJOIN) {
- return false;
- }
- AbstractBinaryJoinOperator join = (AbstractBinaryJoinOperator) op2;
- if (!OperatorPropertiesUtil.isAlwaysTrueCond(join.getCondition().getValue())) {
- return false;
- }
-
- List<LogicalVariable> used = new ArrayList<LogicalVariable>();
- VariableUtilities.getUsedVariables(op1, used);
-
- Mutable<ILogicalOperator> b0Ref = op2.getInputs().get(0);
- ILogicalOperator b0 = b0Ref.getValue();
- List<LogicalVariable> b0Scm = new ArrayList<LogicalVariable>();
- VariableUtilities.getLiveVariables(b0, b0Scm);
- if (b0Scm.containsAll(used)) {
- // push operator on left branch
- op2Ref.setValue(b0);
- b0Ref.setValue(op1);
- opRef.setValue(op2);
- return true;
- } else {
- Mutable<ILogicalOperator> b1Ref = op2.getInputs().get(1);
- ILogicalOperator b1 = b1Ref.getValue();
- List<LogicalVariable> b1Scm = new ArrayList<LogicalVariable>();
- VariableUtilities.getLiveVariables(b1, b1Scm);
- if (b1Scm.containsAll(used)) {
- // push operator on right branch
- op2Ref.setValue(b1);
- b1Ref.setValue(op1);
- opRef.setValue(op2);
- return true;
- } else {
- return false;
- }
- }
- }
-
-}
http://git-wip-us.apache.org/repos/asf/incubator-asterixdb-hyracks/blob/9939b48e/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/PushNestedOrderByUnderPreSortedGroupByRule.java
----------------------------------------------------------------------
diff --git a/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/PushNestedOrderByUnderPreSortedGroupByRule.java b/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/PushNestedOrderByUnderPreSortedGroupByRule.java
deleted file mode 100644
index 476096d..0000000
--- a/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/PushNestedOrderByUnderPreSortedGroupByRule.java
+++ /dev/null
@@ -1,119 +0,0 @@
-/*
- * 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.rewriter.rules;
-
-import java.util.HashSet;
-import java.util.Set;
-
-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.IOptimizationContext;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.LogicalOperatorTag;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.LogicalVariable;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.PhysicalOperatorTag;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.AbstractLogicalOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.GroupByOperator;
-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.visitors.VariableUtilities;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.physical.AbstractPhysicalOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.physical.StableSortPOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.util.OperatorPropertiesUtil;
-import edu.uci.ics.hyracks.algebricks.core.rewriter.base.IAlgebraicRewriteRule;
-
-public class PushNestedOrderByUnderPreSortedGroupByRule implements IAlgebraicRewriteRule {
-
- @Override
- public boolean rewritePre(Mutable<ILogicalOperator> opRef, IOptimizationContext context) throws AlgebricksException {
- return false;
- }
-
- @Override
- public boolean rewritePost(Mutable<ILogicalOperator> opRef, IOptimizationContext context)
- throws AlgebricksException {
- AbstractLogicalOperator op = (AbstractLogicalOperator) opRef.getValue();
- if (op.getOperatorTag() != LogicalOperatorTag.GROUP) {
- return false;
- }
- if (op.getPhysicalOperator() == null) {
- return false;
- }
- AbstractPhysicalOperator pOp = (AbstractPhysicalOperator) op.getPhysicalOperator();
- if (pOp.getOperatorTag() != PhysicalOperatorTag.PRE_CLUSTERED_GROUP_BY) {
- return false;
- }
- GroupByOperator gby = (GroupByOperator) op;
- ILogicalPlan plan = gby.getNestedPlans().get(0);
- AbstractLogicalOperator op1 = (AbstractLogicalOperator) plan.getRoots().get(0).getValue();
- if (op1.getOperatorTag() != LogicalOperatorTag.AGGREGATE) {
- return false;
- }
- Mutable<ILogicalOperator> opRef2 = op1.getInputs().get(0);
- AbstractLogicalOperator op2 = (AbstractLogicalOperator) opRef2.getValue();
- if (op2.getOperatorTag() != LogicalOperatorTag.ORDER) {
- return false;
- }
- OrderOperator order1 = (OrderOperator) op2;
- if (!isIndependentFromChildren(order1)) {
- return false;
- }
- AbstractPhysicalOperator pOrder1 = (AbstractPhysicalOperator) op2.getPhysicalOperator();
- if (pOrder1.getOperatorTag() != PhysicalOperatorTag.STABLE_SORT
- && pOrder1.getOperatorTag() != PhysicalOperatorTag.IN_MEMORY_STABLE_SORT) {
- return false;
- }
- // StableSortPOperator sort1 = (StableSortPOperator) pOrder1;
- AbstractLogicalOperator op3 = (AbstractLogicalOperator) op.getInputs().get(0).getValue();
- if (op3.getOperatorTag() != LogicalOperatorTag.ORDER) {
- return false;
- }
- AbstractPhysicalOperator pOp3 = (AbstractPhysicalOperator) op3.getPhysicalOperator();
- if (pOp3.getOperatorTag() != PhysicalOperatorTag.STABLE_SORT) {
- return false;
- }
- OrderOperator order2 = (OrderOperator) op3;
- StableSortPOperator sort2 = (StableSortPOperator) pOp3;
- // int n1 = sort1.getSortColumns().length;
- // int n2 = sort2.getSortColumns().length;
- // OrderColumn[] sortColumns = new OrderColumn[n2 + n1];
- // System.arraycopy(sort2.getSortColumns(), 0, sortColumns, 0, n2);
- // int k = 0;
- for (Pair<IOrder, Mutable<ILogicalExpression>> oe : order1.getOrderExpressions()) {
- order2.getOrderExpressions().add(oe);
- // sortColumns[n2 + k] = sort1.getSortColumns()[k];
- // ++k;
- }
- // sort2.setSortColumns(sortColumns);
- sort2.computeDeliveredProperties(order2, null);
- // remove order1
- ILogicalOperator underOrder1 = order1.getInputs().get(0).getValue();
- opRef2.setValue(underOrder1);
- return true;
- }
-
- private boolean isIndependentFromChildren(OrderOperator order1) throws AlgebricksException {
- Set<LogicalVariable> free = new HashSet<LogicalVariable>();
- OperatorPropertiesUtil.getFreeVariablesInSelfOrDesc(order1, free);
- Set<LogicalVariable> usedInOrder = new HashSet<LogicalVariable>();
- VariableUtilities.getUsedVariables(order1, usedInOrder);
- return free.containsAll(usedInOrder);
- }
-
-}
http://git-wip-us.apache.org/repos/asf/incubator-asterixdb-hyracks/blob/9939b48e/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/PushProjectDownRule.java
----------------------------------------------------------------------
diff --git a/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/PushProjectDownRule.java b/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/PushProjectDownRule.java
deleted file mode 100644
index b8ff247..0000000
--- a/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/PushProjectDownRule.java
+++ /dev/null
@@ -1,219 +0,0 @@
-/*
- * 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.rewriter.rules;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.HashSet;
-import java.util.LinkedList;
-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.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.IOptimizationContext;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.LogicalOperatorTag;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.LogicalVariable;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.AbstractLogicalOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.AbstractOperatorWithNestedPlans;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.GroupByOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.ProjectOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.visitors.VariableUtilities;
-import edu.uci.ics.hyracks.algebricks.core.rewriter.base.IAlgebraicRewriteRule;
-
-/**
- * Pushes projections through its input operator, provided that operator does
- * not produce the projected variables.
- *
- * @author Nicola
- */
-public class PushProjectDownRule implements IAlgebraicRewriteRule {
-
- @Override
- public boolean rewritePost(Mutable<ILogicalOperator> opRef, IOptimizationContext context) {
- return false;
- }
-
- @Override
- public boolean rewritePre(Mutable<ILogicalOperator> opRef, IOptimizationContext context) throws AlgebricksException {
- AbstractLogicalOperator op = (AbstractLogicalOperator) opRef.getValue();
- if (op.getOperatorTag() != LogicalOperatorTag.PROJECT) {
- return false;
- }
- ProjectOperator pi = (ProjectOperator) op;
- Mutable<ILogicalOperator> opRef2 = pi.getInputs().get(0);
-
- HashSet<LogicalVariable> toPush = new HashSet<LogicalVariable>();
- toPush.addAll(pi.getVariables());
-
- Pair<Boolean, Boolean> p = pushThroughOp(toPush, opRef2, op, context);
- boolean smthWasPushed = p.first;
- if (p.second) { // the original projection is redundant
- opRef.setValue(op.getInputs().get(0).getValue());
- smthWasPushed = true;
- }
-
- return smthWasPushed;
- }
-
- private static Pair<Boolean, Boolean> pushThroughOp(HashSet<LogicalVariable> toPush,
- Mutable<ILogicalOperator> opRef2, ILogicalOperator initialOp, IOptimizationContext context)
- throws AlgebricksException {
- List<LogicalVariable> initProjectList = new ArrayList<LogicalVariable>(toPush);
- AbstractLogicalOperator op2 = (AbstractLogicalOperator) opRef2.getValue();
- do {
- if (op2.getOperatorTag() == LogicalOperatorTag.EMPTYTUPLESOURCE
- || op2.getOperatorTag() == LogicalOperatorTag.NESTEDTUPLESOURCE
- || op2.getOperatorTag() == LogicalOperatorTag.PROJECT
- || op2.getOperatorTag() == LogicalOperatorTag.REPLICATE
- || op2.getOperatorTag() == LogicalOperatorTag.UNIONALL) {
- return new Pair<Boolean, Boolean>(false, false);
- }
- if (!op2.isMap()) {
- break;
- }
- LinkedList<LogicalVariable> usedVars = new LinkedList<LogicalVariable>();
- VariableUtilities.getUsedVariables(op2, usedVars);
- toPush.addAll(usedVars);
- LinkedList<LogicalVariable> producedVars = new LinkedList<LogicalVariable>();
- VariableUtilities.getProducedVariables(op2, producedVars);
- toPush.removeAll(producedVars);
- // we assume pipelineable ops. have only one input
- opRef2 = op2.getInputs().get(0);
- op2 = (AbstractLogicalOperator) opRef2.getValue();
- } while (true);
-
- LinkedList<LogicalVariable> produced2 = new LinkedList<LogicalVariable>();
- VariableUtilities.getProducedVariables(op2, produced2);
- LinkedList<LogicalVariable> used2 = new LinkedList<LogicalVariable>();
- VariableUtilities.getUsedVariables(op2, used2);
-
- boolean canCommuteProjection = initProjectList.containsAll(toPush) && initProjectList.containsAll(produced2)
- && initProjectList.containsAll(used2);
- // if true, we can get rid of the initial projection
-
- // get rid of useless decor vars.
- if (!canCommuteProjection && op2.getOperatorTag() == LogicalOperatorTag.GROUP) {
- boolean gbyChanged = false;
- GroupByOperator gby = (GroupByOperator) op2;
- List<Pair<LogicalVariable, Mutable<ILogicalExpression>>> newDecorList = new ArrayList<Pair<LogicalVariable, Mutable<ILogicalExpression>>>();
- for (Pair<LogicalVariable, Mutable<ILogicalExpression>> p : gby.getDecorList()) {
- LogicalVariable decorVar = GroupByOperator.getDecorVariable(p);
- if (!toPush.contains(decorVar)) {
- used2.remove(decorVar);
- gbyChanged = true;
- } else {
- newDecorList.add(p);
- }
- }
- gby.getDecorList().clear();
- gby.getDecorList().addAll(newDecorList);
- if (gbyChanged) {
- context.computeAndSetTypeEnvironmentForOperator(gby);
- }
- }
- used2.clear();
- VariableUtilities.getUsedVariables(op2, used2);
-
- toPush.addAll(used2); // remember that toPush is a Set
- toPush.removeAll(produced2);
-
- if (toPush.isEmpty()) {
- return new Pair<Boolean, Boolean>(false, false);
- }
-
- boolean smthWasPushed = false;
- for (Mutable<ILogicalOperator> c : op2.getInputs()) {
- if (pushNeededProjections(toPush, c, context, initialOp)) {
- smthWasPushed = true;
- }
- }
- if (op2.hasNestedPlans()) {
- AbstractOperatorWithNestedPlans n = (AbstractOperatorWithNestedPlans) op2;
- for (ILogicalPlan p : n.getNestedPlans()) {
- for (Mutable<ILogicalOperator> r : p.getRoots()) {
- if (pushNeededProjections(toPush, r, context, initialOp)) {
- smthWasPushed = true;
- }
- }
- }
- }
- return new Pair<Boolean, Boolean>(smthWasPushed, canCommuteProjection);
- }
-
- // It does not try to push above another Projection.
- private static boolean pushNeededProjections(HashSet<LogicalVariable> toPush, Mutable<ILogicalOperator> opRef,
- IOptimizationContext context, ILogicalOperator initialOp) throws AlgebricksException {
- HashSet<LogicalVariable> allP = new HashSet<LogicalVariable>();
- AbstractLogicalOperator op = (AbstractLogicalOperator) opRef.getValue();
- VariableUtilities.getLiveVariables(op, allP);
-
- HashSet<LogicalVariable> toProject = new HashSet<LogicalVariable>();
- for (LogicalVariable v : toPush) {
- if (allP.contains(v)) {
- toProject.add(v);
- }
- }
- if (toProject.equals(allP)) {
- // projection would be redundant, since we would project everything
- // but we can try with the children
- boolean push = false;
- if (pushThroughOp(toProject, opRef, initialOp, context).first) {
- push = true;
- }
- return push;
- } else {
- return pushAllProjectionsOnTopOf(toProject, opRef, context, initialOp);
- }
- }
-
- // It does not try to push above another Projection.
- private static boolean pushAllProjectionsOnTopOf(Collection<LogicalVariable> toPush,
- Mutable<ILogicalOperator> opRef, IOptimizationContext context, ILogicalOperator initialOp)
- throws AlgebricksException {
- if (toPush.isEmpty()) {
- return false;
- }
- AbstractLogicalOperator op = (AbstractLogicalOperator) opRef.getValue();
-
- if (context.checkAndAddToAlreadyCompared(initialOp, op)) {
- return false;
- }
-
- switch (op.getOperatorTag()) {
- case EXCHANGE: {
- opRef = opRef.getValue().getInputs().get(0);
- op = (AbstractLogicalOperator) opRef.getValue();
- break;
- }
- case PROJECT: {
- return false;
- }
- }
-
- ProjectOperator pi2 = new ProjectOperator(new ArrayList<LogicalVariable>(toPush));
- pi2.getInputs().add(new MutableObject<ILogicalOperator>(op));
- opRef.setValue(pi2);
- pi2.setExecutionMode(op.getExecutionMode());
- context.computeAndSetTypeEnvironmentForOperator(pi2);
- return true;
- }
-
-}
http://git-wip-us.apache.org/repos/asf/incubator-asterixdb-hyracks/blob/9939b48e/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/PushProjectIntoDataSourceScanRule.java
----------------------------------------------------------------------
diff --git a/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/PushProjectIntoDataSourceScanRule.java b/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/PushProjectIntoDataSourceScanRule.java
deleted file mode 100644
index b17d50f..0000000
--- a/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/PushProjectIntoDataSourceScanRule.java
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
- * 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.rewriter.rules;
-
-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.ILogicalOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.IOptimizationContext;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.LogicalOperatorTag;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.AbstractLogicalOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.DataSourceScanOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.ProjectOperator;
-import edu.uci.ics.hyracks.algebricks.core.rewriter.base.IAlgebraicRewriteRule;
-
-public class PushProjectIntoDataSourceScanRule implements IAlgebraicRewriteRule {
-
- @Override
- public boolean rewritePre(Mutable<ILogicalOperator> opRef, IOptimizationContext context) throws AlgebricksException {
- return false;
- }
-
- @Override
- public boolean rewritePost(Mutable<ILogicalOperator> opRef, IOptimizationContext context)
- throws AlgebricksException {
- AbstractLogicalOperator op = (AbstractLogicalOperator) opRef.getValue();
- if (op.getInputs().size() <= 0)
- return false;
- AbstractLogicalOperator project = (AbstractLogicalOperator) op.getInputs().get(0).getValue();
- if (project.getOperatorTag() != LogicalOperatorTag.PROJECT)
- return false;
- AbstractLogicalOperator exchange = (AbstractLogicalOperator) project.getInputs().get(0).getValue();
- if (exchange.getOperatorTag() != LogicalOperatorTag.EXCHANGE)
- return false;
- AbstractLogicalOperator inputOp = (AbstractLogicalOperator) exchange.getInputs().get(0).getValue();
- if (inputOp.getOperatorTag() != LogicalOperatorTag.DATASOURCESCAN)
- return false;
- DataSourceScanOperator scanOp = (DataSourceScanOperator) inputOp;
- ProjectOperator projectOp = (ProjectOperator) project;
- scanOp.addProjectVariables(projectOp.getVariables());
- if (op.getOperatorTag() != LogicalOperatorTag.EXCHANGE) {
- op.getInputs().set(0, project.getInputs().get(0));
- } else {
- op.getInputs().set(0, exchange.getInputs().get(0));
- }
- return true;
- }
-}
http://git-wip-us.apache.org/repos/asf/incubator-asterixdb-hyracks/blob/9939b48e/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/PushSelectDownRule.java
----------------------------------------------------------------------
diff --git a/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/PushSelectDownRule.java b/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/PushSelectDownRule.java
deleted file mode 100644
index cc65996..0000000
--- a/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/PushSelectDownRule.java
+++ /dev/null
@@ -1,98 +0,0 @@
-/*
- * 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.rewriter.rules;
-
-import java.util.LinkedList;
-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.core.algebra.base.ILogicalOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.IOptimizationContext;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.LogicalOperatorTag;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.LogicalVariable;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.AbstractLogicalOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.SelectOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.visitors.VariableUtilities;
-import edu.uci.ics.hyracks.algebricks.core.algebra.util.OperatorPropertiesUtil;
-import edu.uci.ics.hyracks.algebricks.core.rewriter.base.IAlgebraicRewriteRule;
-
-public class PushSelectDownRule implements IAlgebraicRewriteRule {
-
- @Override
- public boolean rewritePost(Mutable<ILogicalOperator> opRef, IOptimizationContext context) {
- return false;
- }
-
- @Override
- public boolean rewritePre(Mutable<ILogicalOperator> opRef, IOptimizationContext context) throws AlgebricksException {
- AbstractLogicalOperator op = (AbstractLogicalOperator) opRef.getValue();
- if (op.getOperatorTag() != LogicalOperatorTag.SELECT) {
- return false;
- }
-
- Mutable<ILogicalOperator> opRef2 = op.getInputs().get(0);
- AbstractLogicalOperator op2 = (AbstractLogicalOperator) opRef2.getValue();
-
- if (context.checkAndAddToAlreadyCompared(op, op2)) {
- return false;
- }
-
- LogicalOperatorTag tag2 = op2.getOperatorTag();
-
- if (tag2 == LogicalOperatorTag.INNERJOIN || tag2 == LogicalOperatorTag.LEFTOUTERJOIN
- || tag2 == LogicalOperatorTag.REPLICATE) {
- return false;
- } else { // not a join
- boolean res = propagateSelectionRec(opRef, opRef2);
- if (res) {
- OperatorPropertiesUtil.typeOpRec(opRef, context);
- }
- return res;
- }
- }
-
- private static boolean propagateSelectionRec(Mutable<ILogicalOperator> sigmaRef, Mutable<ILogicalOperator> opRef2)
- throws AlgebricksException {
- AbstractLogicalOperator op2 = (AbstractLogicalOperator) opRef2.getValue();
- if (op2.getInputs().size() != 1 || op2.getOperatorTag() == LogicalOperatorTag.DATASOURCESCAN) {
- return false;
- }
-
- SelectOperator sigma = (SelectOperator) sigmaRef.getValue();
- LinkedList<LogicalVariable> usedInSigma = new LinkedList<LogicalVariable>();
- sigma.getCondition().getValue().getUsedVariables(usedInSigma);
-
- LinkedList<LogicalVariable> produced2 = new LinkedList<LogicalVariable>();
- VariableUtilities.getProducedVariables(op2, produced2);
- if (OperatorPropertiesUtil.disjoint(produced2, usedInSigma)) {
- // just swap
- opRef2.setValue(sigma);
- sigmaRef.setValue(op2);
- List<Mutable<ILogicalOperator>> sigmaInpList = sigma.getInputs();
- sigmaInpList.clear();
- sigmaInpList.addAll(op2.getInputs());
- List<Mutable<ILogicalOperator>> op2InpList = op2.getInputs();
- op2InpList.clear();
- op2InpList.add(opRef2);
- propagateSelectionRec(opRef2, sigma.getInputs().get(0));
- return true;
-
- }
- return false;
- }
-
-}
http://git-wip-us.apache.org/repos/asf/incubator-asterixdb-hyracks/blob/9939b48e/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/PushSelectIntoJoinRule.java
----------------------------------------------------------------------
diff --git a/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/PushSelectIntoJoinRule.java b/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/PushSelectIntoJoinRule.java
deleted file mode 100644
index e29299c..0000000
--- a/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/PushSelectIntoJoinRule.java
+++ /dev/null
@@ -1,309 +0,0 @@
-/*
- * 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.rewriter.rules;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.ListIterator;
-
-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.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.LogicalExpressionTag;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.LogicalOperatorTag;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.LogicalVariable;
-import edu.uci.ics.hyracks.algebricks.core.algebra.expressions.AbstractFunctionCallExpression;
-import edu.uci.ics.hyracks.algebricks.core.algebra.expressions.ScalarFunctionCallExpression;
-import edu.uci.ics.hyracks.algebricks.core.algebra.functions.AlgebricksBuiltinFunctions;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.AbstractBinaryJoinOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.AbstractLogicalOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.InnerJoinOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.SelectOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.visitors.VariableUtilities;
-import edu.uci.ics.hyracks.algebricks.core.algebra.util.OperatorPropertiesUtil;
-import edu.uci.ics.hyracks.algebricks.core.rewriter.base.IAlgebraicRewriteRule;
-
-public class PushSelectIntoJoinRule implements IAlgebraicRewriteRule {
-
- @Override
- public boolean rewritePre(Mutable<ILogicalOperator> opRef, IOptimizationContext context) {
- return false;
- }
-
- @Override
- public boolean rewritePost(Mutable<ILogicalOperator> opRef, IOptimizationContext context)
- throws AlgebricksException {
- Collection<LogicalVariable> joinLiveVarsLeft = new HashSet<LogicalVariable>();
- Collection<LogicalVariable> joinLiveVarsRight = new HashSet<LogicalVariable>();
- Collection<LogicalVariable> liveInOpsToPushLeft = new HashSet<LogicalVariable>();
- Collection<LogicalVariable> liveInOpsToPushRight = new HashSet<LogicalVariable>();
-
- List<ILogicalOperator> pushedOnLeft = new ArrayList<ILogicalOperator>();
- List<ILogicalOperator> pushedOnRight = new ArrayList<ILogicalOperator>();
- LinkedList<ILogicalOperator> notPushedStack = new LinkedList<ILogicalOperator>();
- Collection<LogicalVariable> usedVars = new HashSet<LogicalVariable>();
- Collection<LogicalVariable> producedVars = new HashSet<LogicalVariable>();
-
- AbstractLogicalOperator op = (AbstractLogicalOperator) opRef.getValue();
- if (op.getOperatorTag() != LogicalOperatorTag.SELECT) {
- return false;
- }
- SelectOperator select = (SelectOperator) op;
- Mutable<ILogicalOperator> opRef2 = op.getInputs().get(0);
- AbstractLogicalOperator son = (AbstractLogicalOperator) opRef2.getValue();
- AbstractLogicalOperator op2 = son;
- boolean needToPushOps = false;
- while (son.isMap()) {
- needToPushOps = true;
- Mutable<ILogicalOperator> opRefLink = son.getInputs().get(0);
- son = (AbstractLogicalOperator) opRefLink.getValue();
- }
-
- if (son.getOperatorTag() != LogicalOperatorTag.INNERJOIN
- && son.getOperatorTag() != LogicalOperatorTag.LEFTOUTERJOIN) {
- return false;
- }
- boolean isLoj = son.getOperatorTag() == LogicalOperatorTag.LEFTOUTERJOIN;
- AbstractBinaryJoinOperator join = (AbstractBinaryJoinOperator) son;
-
- Mutable<ILogicalOperator> joinBranchLeftRef = join.getInputs().get(0);
- Mutable<ILogicalOperator> joinBranchRightRef = join.getInputs().get(1);
-
- if (needToPushOps) {
- ILogicalOperator joinBranchLeft = joinBranchLeftRef.getValue();
- ILogicalOperator joinBranchRight = joinBranchRightRef.getValue();
- VariableUtilities.getLiveVariables(joinBranchLeft, joinLiveVarsLeft);
- VariableUtilities.getLiveVariables(joinBranchRight, joinLiveVarsRight);
- Mutable<ILogicalOperator> opIterRef = opRef2;
- ILogicalOperator opIter = op2;
- while (opIter != join) {
- LogicalOperatorTag tag = ((AbstractLogicalOperator) opIter).getOperatorTag();
- if (tag == LogicalOperatorTag.PROJECT) {
- notPushedStack.addFirst(opIter);
- } else {
- VariableUtilities.getUsedVariables(opIter, usedVars);
- VariableUtilities.getProducedVariables(opIter, producedVars);
- if (joinLiveVarsLeft.containsAll(usedVars)) {
- pushedOnLeft.add(opIter);
- liveInOpsToPushLeft.addAll(producedVars);
- } else if (joinLiveVarsRight.containsAll(usedVars)) {
- pushedOnRight.add(opIter);
- liveInOpsToPushRight.addAll(producedVars);
- } else {
- return false;
- }
- }
- opIterRef = opIter.getInputs().get(0);
- opIter = opIterRef.getValue();
- }
- if (isLoj && pushedOnLeft.isEmpty()) {
- return false;
- }
- }
-
- boolean intersectsAllBranches = true;
- boolean[] intersectsBranch = new boolean[join.getInputs().size()];
- LinkedList<LogicalVariable> selectVars = new LinkedList<LogicalVariable>();
- select.getCondition().getValue().getUsedVariables(selectVars);
- int i = 0;
- for (Mutable<ILogicalOperator> branch : join.getInputs()) {
- LinkedList<LogicalVariable> branchVars = new LinkedList<LogicalVariable>();
- VariableUtilities.getLiveVariables(branch.getValue(), branchVars);
- if (i == 0) {
- branchVars.addAll(liveInOpsToPushLeft);
- } else {
- branchVars.addAll(liveInOpsToPushRight);
- }
- if (OperatorPropertiesUtil.disjoint(selectVars, branchVars)) {
- intersectsAllBranches = false;
- } else {
- intersectsBranch[i] = true;
- }
- i++;
- }
- if (!intersectsBranch[0] && !intersectsBranch[1]) {
- return false;
- }
- if (needToPushOps) {
- pushOps(pushedOnLeft, joinBranchLeftRef, context);
- pushOps(pushedOnRight, joinBranchRightRef, context);
- }
- if (intersectsAllBranches) {
- addCondToJoin(select, join, context);
- } else { // push down
- Iterator<Mutable<ILogicalOperator>> branchIter = join.getInputs().iterator();
- ILogicalExpression selectCondition = select.getCondition().getValue();
- boolean lojToInner = false;
- for (int j = 0; j < intersectsBranch.length; j++) {
- Mutable<ILogicalOperator> branch = branchIter.next();
- boolean inter = intersectsBranch[j];
- if (inter) {
- if (j > 0 && isLoj) {
- // if a left outer join, if the select condition is not-null filtering,
- // we rewrite left outer join
- // to inner join for this case.
- if (containsNotNullFiltering(selectCondition)) {
- lojToInner = true;
- }
- }
- if ((j > 0 && isLoj) && containsNullFiltering(selectCondition)) {
- // Select is-null($$var) cannot be pushed in the right branch of a LOJ;
- notPushedStack.addFirst(select);
- } else {
- // Conditions for the left branch can always be pushed.
- // Other conditions can be pushed to the right branch of a LOJ.
- copySelectToBranch(select, branch, context);
- }
- }
- }
- if (lojToInner) {
- // Rewrites left outer join to inner join.
- InnerJoinOperator innerJoin = new InnerJoinOperator(join.getCondition());
- innerJoin.getInputs().addAll(join.getInputs());
- join = innerJoin;
- context.computeAndSetTypeEnvironmentForOperator(join);
- }
- }
- ILogicalOperator top = join;
- for (ILogicalOperator npOp : notPushedStack) {
- List<Mutable<ILogicalOperator>> npInpList = npOp.getInputs();
- npInpList.clear();
- npInpList.add(new MutableObject<ILogicalOperator>(top));
- context.computeAndSetTypeEnvironmentForOperator(npOp);
- top = npOp;
- }
- opRef.setValue(top);
- return true;
-
- }
-
- private void pushOps(List<ILogicalOperator> opList, Mutable<ILogicalOperator> joinBranch,
- IOptimizationContext context) throws AlgebricksException {
- ILogicalOperator topOp = joinBranch.getValue();
- ListIterator<ILogicalOperator> iter = opList.listIterator(opList.size());
- while (iter.hasPrevious()) {
- ILogicalOperator op = iter.previous();
- List<Mutable<ILogicalOperator>> opInpList = op.getInputs();
- opInpList.clear();
- opInpList.add(new MutableObject<ILogicalOperator>(topOp));
- topOp = op;
- context.computeAndSetTypeEnvironmentForOperator(op);
- }
- joinBranch.setValue(topOp);
- }
-
- private static void addCondToJoin(SelectOperator select, AbstractBinaryJoinOperator join,
- IOptimizationContext context) {
- ILogicalExpression cond = join.getCondition().getValue();
- if (OperatorPropertiesUtil.isAlwaysTrueCond(cond)) { // the join was a product
- join.getCondition().setValue(select.getCondition().getValue());
- } else {
- boolean bAddedToConj = false;
- if (cond.getExpressionTag() == LogicalExpressionTag.FUNCTION_CALL) {
- AbstractFunctionCallExpression fcond = (AbstractFunctionCallExpression) cond;
- if (fcond.getFunctionIdentifier().equals(AlgebricksBuiltinFunctions.AND)) {
- AbstractFunctionCallExpression newCond = new ScalarFunctionCallExpression(context
- .getMetadataProvider().lookupFunction(AlgebricksBuiltinFunctions.AND));
- newCond.getArguments().add(select.getCondition());
- newCond.getArguments().addAll(fcond.getArguments());
- join.getCondition().setValue(newCond);
- bAddedToConj = true;
- }
- }
- if (!bAddedToConj) {
- AbstractFunctionCallExpression newCond = new ScalarFunctionCallExpression(context.getMetadataProvider()
- .lookupFunction(AlgebricksBuiltinFunctions.AND), select.getCondition(),
- new MutableObject<ILogicalExpression>(join.getCondition().getValue()));
- join.getCondition().setValue(newCond);
- }
- }
- }
-
- private static void copySelectToBranch(SelectOperator select, Mutable<ILogicalOperator> branch,
- IOptimizationContext context) throws AlgebricksException {
- ILogicalOperator newSelect = new SelectOperator(select.getCondition(), select.getRetainNull(),
- select.getNullPlaceholderVariable());
- Mutable<ILogicalOperator> newRef = new MutableObject<ILogicalOperator>(branch.getValue());
- newSelect.getInputs().add(newRef);
- branch.setValue(newSelect);
- context.computeAndSetTypeEnvironmentForOperator(newSelect);
- }
-
- /**
- * Whether the expression contains a not-null filtering
- *
- * @param expr
- * @return true if the expression contains a not-null filtering function call; false otherwise.
- */
- private boolean containsNotNullFiltering(ILogicalExpression expr) {
- if (expr.getExpressionTag() != LogicalExpressionTag.FUNCTION_CALL) {
- return false;
- }
- ScalarFunctionCallExpression func = (ScalarFunctionCallExpression) expr;
- if (func.getFunctionIdentifier() == AlgebricksBuiltinFunctions.AND) {
- for (Mutable<ILogicalExpression> argumentRef : func.getArguments()) {
- if (containsNotNullFiltering(argumentRef.getValue())) {
- return true;
- }
- }
- return false;
- }
- if (func.getFunctionIdentifier() != AlgebricksBuiltinFunctions.NOT) {
- return false;
- }
- ILogicalExpression arg = func.getArguments().get(0).getValue();
- if (arg.getExpressionTag() != LogicalExpressionTag.FUNCTION_CALL) {
- return false;
- }
- ScalarFunctionCallExpression func2 = (ScalarFunctionCallExpression) arg;
- if (func2.getFunctionIdentifier() != AlgebricksBuiltinFunctions.IS_NULL) {
- return false;
- }
- return true;
- }
-
- /**
- * Whether the expression contains a null filtering
- *
- * @param expr
- * @return true if the expression contains a null filtering function call; false otherwise.
- */
- private boolean containsNullFiltering(ILogicalExpression expr) {
- if (expr.getExpressionTag() != LogicalExpressionTag.FUNCTION_CALL) {
- return false;
- }
- ScalarFunctionCallExpression func = (ScalarFunctionCallExpression) expr;
- if (func.getFunctionIdentifier() == AlgebricksBuiltinFunctions.AND) {
- for (Mutable<ILogicalExpression> argumentRef : func.getArguments()) {
- if (containsNullFiltering(argumentRef.getValue())) {
- return true;
- }
- }
- return false;
- }
- if (func.getFunctionIdentifier() != AlgebricksBuiltinFunctions.IS_NULL) {
- return false;
- }
- return true;
- }
-}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/incubator-asterixdb-hyracks/blob/9939b48e/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/PushSubplanIntoGroupByRule.java
----------------------------------------------------------------------
diff --git a/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/PushSubplanIntoGroupByRule.java b/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/PushSubplanIntoGroupByRule.java
deleted file mode 100644
index 1eef9f8..0000000
--- a/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/PushSubplanIntoGroupByRule.java
+++ /dev/null
@@ -1,217 +0,0 @@
-/*
-
- * 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.rewriter.rules;
-
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-
-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.ListSet;
-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.IOptimizationContext;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.LogicalOperatorTag;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.LogicalVariable;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.AbstractLogicalOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.AggregateOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.GroupByOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.NestedTupleSourceOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.SubplanOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.visitors.VariableUtilities;
-import edu.uci.ics.hyracks.algebricks.core.algebra.util.OperatorManipulationUtil;
-import edu.uci.ics.hyracks.algebricks.core.rewriter.base.IAlgebraicRewriteRule;
-
-/**
- * This rule pushes an array of subplans on top of a group-by into the
- * nested plan of the group-by.
- *
- * @author yingyib
- */
-
-public class PushSubplanIntoGroupByRule implements IAlgebraicRewriteRule {
- /** Stores used variables above the current operator. */
- private final Set<LogicalVariable> usedVarsSoFar = new HashSet<LogicalVariable>();
-
- @Override
- public boolean rewritePost(Mutable<ILogicalOperator> opRef, IOptimizationContext context)
- throws AlgebricksException {
- return false;
- }
-
- @Override
- public boolean rewritePre(Mutable<ILogicalOperator> opRef, IOptimizationContext context) throws AlgebricksException {
- ILogicalOperator parentOperator = opRef.getValue();
- if (context.checkIfInDontApplySet(this, parentOperator)) {
- return false;
- }
- context.addToDontApplySet(this, parentOperator);
- VariableUtilities.getUsedVariables(parentOperator, usedVarsSoFar);
- if (parentOperator.getInputs().size() <= 0) {
- return false;
- }
- boolean changed = false;
- GroupByOperator gby = null;
- for (Mutable<ILogicalOperator> ref : parentOperator.getInputs()) {
- AbstractLogicalOperator op = (AbstractLogicalOperator) ref.getValue();
- /** Only processes subplan operator. */
- List<SubplanOperator> subplans = new ArrayList<SubplanOperator>();
- if (op.getOperatorTag() == LogicalOperatorTag.SUBPLAN) {
- while (op.getOperatorTag() == LogicalOperatorTag.SUBPLAN) {
- SubplanOperator currentSubplan = (SubplanOperator) op;
- subplans.add(currentSubplan);
- op = (AbstractLogicalOperator) op.getInputs().get(0).getValue();
- }
- /** Only processes the case a group-by operator is the input of the subplan operators. */
- if (op.getOperatorTag() == LogicalOperatorTag.GROUP) {
- gby = (GroupByOperator) op;
- List<ILogicalPlan> newGbyNestedPlans = new ArrayList<ILogicalPlan>();
- for (SubplanOperator subplan : subplans) {
- List<ILogicalPlan> subplanNestedPlans = subplan.getNestedPlans();
- List<ILogicalPlan> gbyNestedPlans = gby.getNestedPlans();
- List<ILogicalPlan> subplanNestedPlansToRemove = new ArrayList<ILogicalPlan>();
- for (ILogicalPlan subplanNestedPlan : subplanNestedPlans) {
- List<Mutable<ILogicalOperator>> rootOpRefs = subplanNestedPlan.getRoots();
- List<Mutable<ILogicalOperator>> rootOpRefsToRemove = new ArrayList<Mutable<ILogicalOperator>>();
- for (Mutable<ILogicalOperator> rootOpRef : rootOpRefs) {
- /** Gets free variables in the root operator of a nested plan and its descent. */
- Set<LogicalVariable> freeVars = new ListSet<LogicalVariable>();
- VariableUtilities.getUsedVariablesInDescendantsAndSelf(rootOpRef.getValue(), freeVars);
- Set<LogicalVariable> producedVars = new ListSet<LogicalVariable>();
- VariableUtilities.getProducedVariablesInDescendantsAndSelf(rootOpRef.getValue(),
- producedVars);
- freeVars.removeAll(producedVars);
- /** * Checks whether the above freeVars are all contained in live variables * of one nested plan inside the group-by operator. * If yes, then the subplan can be pushed into the nested plan of the group-by. */
- for (ILogicalPlan gbyNestedPlanOriginal : gbyNestedPlans) {
- // add a subplan in the original gby
- if (!newGbyNestedPlans.contains(gbyNestedPlanOriginal)) {
- newGbyNestedPlans.add(gbyNestedPlanOriginal);
- }
-
- // add a pushed subplan
- ILogicalPlan gbyNestedPlan = OperatorManipulationUtil.deepCopy(
- gbyNestedPlanOriginal, context);
- List<Mutable<ILogicalOperator>> gbyRootOpRefs = gbyNestedPlan.getRoots();
- for (int rootIndex = 0; rootIndex < gbyRootOpRefs.size(); rootIndex++) {
- //set the nts for a original subplan
- Mutable<ILogicalOperator> originalGbyRootOpRef = gbyNestedPlanOriginal
- .getRoots().get(rootIndex);
- Mutable<ILogicalOperator> originalGbyNtsRef = downToNts(originalGbyRootOpRef);
- NestedTupleSourceOperator originalNts = (NestedTupleSourceOperator) originalGbyNtsRef
- .getValue();
- originalNts.setDataSourceReference(new MutableObject<ILogicalOperator>(gby));
-
- //push a new subplan if possible
- Mutable<ILogicalOperator> gbyRootOpRef = gbyRootOpRefs.get(rootIndex);
- Set<LogicalVariable> liveVars = new ListSet<LogicalVariable>();
- VariableUtilities.getLiveVariables(gbyRootOpRef.getValue(), liveVars);
- if (liveVars.containsAll(freeVars)) {
- /** Does the actual push. */
- Mutable<ILogicalOperator> ntsRef = downToNts(rootOpRef);
- ntsRef.setValue(gbyRootOpRef.getValue());
- // Removes unused vars.
- AggregateOperator aggOp = (AggregateOperator) gbyRootOpRef.getValue();
- for (int varIndex = aggOp.getVariables().size() - 1; varIndex >= 0; varIndex--) {
- if (!freeVars.contains(aggOp.getVariables().get(varIndex))) {
- aggOp.getVariables().remove(varIndex);
- aggOp.getExpressions().remove(varIndex);
- }
- }
-
- gbyRootOpRef.setValue(rootOpRef.getValue());
- rootOpRefsToRemove.add(rootOpRef);
-
- // Sets the nts for a new pushed plan.
- Mutable<ILogicalOperator> oldGbyNtsRef = downToNts(gbyRootOpRef);
- NestedTupleSourceOperator nts = (NestedTupleSourceOperator) oldGbyNtsRef
- .getValue();
- nts.setDataSourceReference(new MutableObject<ILogicalOperator>(gby));
-
- newGbyNestedPlans.add(gbyNestedPlan);
- changed = true;
- continue;
- }
- }
- }
- }
- rootOpRefs.removeAll(rootOpRefsToRemove);
- if (rootOpRefs.size() == 0) {
- subplanNestedPlansToRemove.add(subplanNestedPlan);
- }
- }
- subplanNestedPlans.removeAll(subplanNestedPlansToRemove);
- }
- if (changed) {
- ref.setValue(gby);
- gby.getNestedPlans().clear();
- gby.getNestedPlans().addAll(newGbyNestedPlans);
- }
- }
- }
- }
- if (changed) {
- cleanup(gby);
- }
- return changed;
- }
-
- /**
- * Removes unused aggregation variables (and expressions)
- *
- * @param gby
- * @throws AlgebricksException
- */
- private void cleanup(GroupByOperator gby) throws AlgebricksException {
- for (ILogicalPlan nestedPlan : gby.getNestedPlans()) {
- for (Mutable<ILogicalOperator> rootRef : nestedPlan.getRoots()) {
- AggregateOperator aggOp = (AggregateOperator) rootRef.getValue();
- for (int varIndex = aggOp.getVariables().size() - 1; varIndex >= 0; varIndex--) {
- if (!usedVarsSoFar.contains(aggOp.getVariables().get(varIndex))) {
- aggOp.getVariables().remove(varIndex);
- aggOp.getExpressions().remove(varIndex);
- }
- }
- }
-
- }
- }
-
- private Mutable<ILogicalOperator> downToNts(Mutable<ILogicalOperator> opRef) {
- Mutable<ILogicalOperator> currentOpRef = opRef;
- while (currentOpRef.getValue().getInputs().size() > 0) {
- currentOpRef = currentOpRef.getValue().getInputs().get(0);
- }
- return currentOpRef;
- }
-
-}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/incubator-asterixdb-hyracks/blob/9939b48e/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/PushSubplanWithAggregateDownThroughProductRule.java
----------------------------------------------------------------------
diff --git a/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/PushSubplanWithAggregateDownThroughProductRule.java b/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/PushSubplanWithAggregateDownThroughProductRule.java
deleted file mode 100644
index 9c15f77..0000000
--- a/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/PushSubplanWithAggregateDownThroughProductRule.java
+++ /dev/null
@@ -1,104 +0,0 @@
-/*
- * 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.rewriter.rules;
-
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-
-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.ILogicalOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.ILogicalPlan;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.IOptimizationContext;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.LogicalOperatorTag;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.LogicalVariable;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.AbstractBinaryJoinOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.AbstractLogicalOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.SubplanOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.visitors.VariableUtilities;
-import edu.uci.ics.hyracks.algebricks.core.algebra.util.OperatorPropertiesUtil;
-import edu.uci.ics.hyracks.algebricks.core.rewriter.base.IAlgebraicRewriteRule;
-
-public class PushSubplanWithAggregateDownThroughProductRule implements IAlgebraicRewriteRule {
-
- @Override
- public boolean rewritePre(Mutable<ILogicalOperator> opRef, IOptimizationContext context) throws AlgebricksException {
- return false;
- }
-
- @Override
- public boolean rewritePost(Mutable<ILogicalOperator> opRef, IOptimizationContext context)
- throws AlgebricksException {
- AbstractLogicalOperator op1 = (AbstractLogicalOperator) opRef.getValue();
- if (op1.getOperatorTag() != LogicalOperatorTag.SUBPLAN) {
- return false;
- }
- SubplanOperator subplan = (SubplanOperator) op1;
- if (subplan.getNestedPlans().size() != 1) {
- return false;
- }
- ILogicalPlan p = subplan.getNestedPlans().get(0);
- if (p.getRoots().size() != 1) {
- return false;
- }
- Mutable<ILogicalOperator> r = p.getRoots().get(0);
- if (((AbstractLogicalOperator) r.getValue()).getOperatorTag() != LogicalOperatorTag.AGGREGATE) {
- return false;
- }
-
- Set<LogicalVariable> free = new HashSet<LogicalVariable>();
- OperatorPropertiesUtil.getFreeVariablesInSubplans(subplan, free);
-
- Mutable<ILogicalOperator> op2Ref = op1.getInputs().get(0);
- AbstractLogicalOperator op2 = (AbstractLogicalOperator) op2Ref.getValue();
- if (op2.getOperatorTag() != LogicalOperatorTag.INNERJOIN) {
- return false;
- }
- AbstractBinaryJoinOperator join = (AbstractBinaryJoinOperator) op2;
- if (!OperatorPropertiesUtil.isAlwaysTrueCond(join.getCondition().getValue())) {
- return false;
- }
-
- Mutable<ILogicalOperator> b0Ref = op2.getInputs().get(0);
- ILogicalOperator b0 = b0Ref.getValue();
- List<LogicalVariable> b0Scm = new ArrayList<LogicalVariable>();
- VariableUtilities.getLiveVariables(b0, b0Scm);
- if (b0Scm.containsAll(free)) {
- // push subplan on left branch
- op2Ref.setValue(b0);
- b0Ref.setValue(op1);
- opRef.setValue(op2);
- return true;
- } else {
- Mutable<ILogicalOperator> b1Ref = op2.getInputs().get(1);
- ILogicalOperator b1 = b1Ref.getValue();
- List<LogicalVariable> b1Scm = new ArrayList<LogicalVariable>();
- VariableUtilities.getLiveVariables(b1, b1Scm);
- if (b1Scm.containsAll(free)) {
- // push subplan on right branch
- op2Ref.setValue(b1);
- b1Ref.setValue(op1);
- opRef.setValue(op2);
- return true;
- } else {
- return false;
- }
- }
-
- }
-}
http://git-wip-us.apache.org/repos/asf/incubator-asterixdb-hyracks/blob/9939b48e/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/PushUnnestDownThroughProductRule.java
----------------------------------------------------------------------
diff --git a/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/PushUnnestDownThroughProductRule.java b/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/PushUnnestDownThroughProductRule.java
deleted file mode 100644
index c70fca9..0000000
--- a/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/PushUnnestDownThroughProductRule.java
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
- * 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.rewriter.rules;
-
-import java.util.ArrayList;
-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.core.algebra.base.ILogicalOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.IOptimizationContext;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.LogicalOperatorTag;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.LogicalVariable;
-import edu.uci.ics.hyracks.algebricks.core.algebra.expressions.ConstantExpression;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.AbstractBinaryJoinOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.AbstractLogicalOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.visitors.VariableUtilities;
-import edu.uci.ics.hyracks.algebricks.core.rewriter.base.IAlgebraicRewriteRule;
-
-public class PushUnnestDownThroughProductRule implements IAlgebraicRewriteRule {
-
- @Override
- public boolean rewritePre(Mutable<ILogicalOperator> opRef, IOptimizationContext context) throws AlgebricksException {
- return false;
- }
-
- @Override
- public boolean rewritePost(Mutable<ILogicalOperator> opRef, IOptimizationContext context)
- throws AlgebricksException {
- AbstractLogicalOperator op1 = (AbstractLogicalOperator) opRef.getValue();
- if (op1.getOperatorTag() != LogicalOperatorTag.UNNEST) {
- return false;
- }
- Mutable<ILogicalOperator> op2Ref = op1.getInputs().get(0);
- AbstractLogicalOperator op2 = (AbstractLogicalOperator) op2Ref.getValue();
- if (op2.getOperatorTag() != LogicalOperatorTag.INNERJOIN) {
- return false;
- }
- AbstractBinaryJoinOperator join = (AbstractBinaryJoinOperator) op2;
- if (join.getCondition().getValue() != ConstantExpression.TRUE) {
- return false;
- }
-
- List<LogicalVariable> used = new ArrayList<LogicalVariable>();
- VariableUtilities.getUsedVariables(op1, used);
-
- Mutable<ILogicalOperator> b0Ref = op2.getInputs().get(0);
- ILogicalOperator b0 = b0Ref.getValue();
- List<LogicalVariable> b0Scm = new ArrayList<LogicalVariable>();
- VariableUtilities.getLiveVariables(b0, b0Scm);
- if (b0Scm.containsAll(used)) {
- // push unnest on left branch
- op2Ref.setValue(b0);
- b0Ref.setValue(op1);
- opRef.setValue(op2);
- return true;
- } else {
- Mutable<ILogicalOperator> b1Ref = op2.getInputs().get(1);
- ILogicalOperator b1 = b1Ref.getValue();
- List<LogicalVariable> b1Scm = new ArrayList<LogicalVariable>();
- VariableUtilities.getLiveVariables(b1, b1Scm);
- if (b1Scm.containsAll(used)) {
- // push unnest on right branch
- op2Ref.setValue(b1);
- b1Ref.setValue(op1);
- opRef.setValue(op2);
- return true;
- } else {
- return false;
- }
- }
- }
-
-}
http://git-wip-us.apache.org/repos/asf/incubator-asterixdb-hyracks/blob/9939b48e/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/PushUnnestDownThroughUnionRule.java
----------------------------------------------------------------------
diff --git a/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/PushUnnestDownThroughUnionRule.java b/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/PushUnnestDownThroughUnionRule.java
deleted file mode 100644
index b69bfb3..0000000
--- a/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/PushUnnestDownThroughUnionRule.java
+++ /dev/null
@@ -1,125 +0,0 @@
-/*
- * 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.rewriter.rules;
-
-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.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.IOptimizationContext;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.LogicalOperatorTag;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.LogicalVariable;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.AbstractLogicalOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.UnionAllOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.UnnestOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.visitors.VariableUtilities;
-import edu.uci.ics.hyracks.algebricks.core.rewriter.base.IAlgebraicRewriteRule;
-
-/**
- * @author kereno, ecarm002, ildar.absalyamov
- * Pushes down unnest through both branches of the union operator
- * Before rule:
- * ============
- * unnest
- * union (left_branch, right_branch, res)
- * left_branch
- * right_branch
- * After rule:
- * ============
- * union (left_branch, right_branch, res)
- * unnest
- * left_branch
- * unnest
- * right_branch
- */
-public class PushUnnestDownThroughUnionRule implements IAlgebraicRewriteRule {
-
- @Override
- public boolean rewritePre(Mutable<ILogicalOperator> opRef, IOptimizationContext context) {
- return false;
- }
-
- @Override
- public boolean rewritePost(Mutable<ILogicalOperator> opRef, IOptimizationContext context)
- throws AlgebricksException {
-
- AbstractLogicalOperator unnest = (AbstractLogicalOperator) opRef.getValue();
- if (unnest.getOperatorTag() != LogicalOperatorTag.UNNEST) {
- return false;
- }
- UnnestOperator unnestOpRef = (UnnestOperator) opRef.getValue();
- Mutable<ILogicalOperator> unionOp = unnest.getInputs().get(0);
-
- AbstractLogicalOperator unionAbstractOp = (AbstractLogicalOperator) unionOp.getValue();
- if (unionAbstractOp.getOperatorTag() != LogicalOperatorTag.UNIONALL) {
- return false;
- }
-
- LogicalVariable unnestVar1 = context.newVar();
- UnnestOperator unnest1 = new UnnestOperator(unnestVar1, new MutableObject<ILogicalExpression>(unnestOpRef
- .getExpressionRef().getValue().cloneExpression()));
- LogicalVariable unnestVar2 = context.newVar();
- UnnestOperator unnest2 = new UnnestOperator(unnestVar2, new MutableObject<ILogicalExpression>(unnestOpRef
- .getExpressionRef().getValue().cloneExpression()));
-
- //Getting the two topmost branched and adding them as an input to the unnests:
- Mutable<ILogicalOperator> branch1 = unionAbstractOp.getInputs().get(0);
- ILogicalOperator agg1 = branch1.getValue();
- List<LogicalVariable> agg1_var = new ArrayList<LogicalVariable>();
- VariableUtilities.getLiveVariables(agg1, agg1_var);
- Mutable<ILogicalOperator> branch2 = unionAbstractOp.getInputs().get(1);
- ILogicalOperator agg2 = branch2.getValue();
- List<LogicalVariable> agg2_var = new ArrayList<LogicalVariable>();
- VariableUtilities.getLiveVariables(agg2, agg2_var);
-
- //Modifying the unnest so it has the right variable
- List<LogicalVariable> var_unnest_1 = new ArrayList<LogicalVariable>();
- unnest1.getExpressionRef().getValue().getUsedVariables(var_unnest_1);
- unnest1.getExpressionRef().getValue().substituteVar(var_unnest_1.get(0), agg1_var.get(0));
-
- List<LogicalVariable> var_unnest2 = new ArrayList<LogicalVariable>();
- unnest2.getExpressionRef().getValue().getUsedVariables(var_unnest2);
- unnest2.getExpressionRef().getValue().substituteVar(var_unnest2.get(0), agg2_var.get(0));
-
- unnest1.getInputs().add(branch1);
- unnest2.getInputs().add(branch2);
- context.computeAndSetTypeEnvironmentForOperator(unnest1);
- context.computeAndSetTypeEnvironmentForOperator(unnest2);
-
- //creating a new union operator with the updated logical variables
- List<Triple<LogicalVariable, LogicalVariable, LogicalVariable>> varMap = new ArrayList<Triple<LogicalVariable, LogicalVariable, LogicalVariable>>(
- 1);
- Triple<LogicalVariable, LogicalVariable, LogicalVariable> union_triple_vars = new Triple<LogicalVariable, LogicalVariable, LogicalVariable>(
- unnestVar1, unnestVar2, unnestOpRef.getVariables().get(0));
- varMap.add(union_triple_vars);
- UnionAllOperator unionOpFinal = new UnionAllOperator(varMap);
-
- unionOpFinal.getInputs().add(new MutableObject<ILogicalOperator>(unnest1));
- unionOpFinal.getInputs().add(new MutableObject<ILogicalOperator>(unnest2));
-
- context.computeAndSetTypeEnvironmentForOperator(unionOpFinal);
-
- opRef.setValue(unionOpFinal);
- return true;
-
- }
-}
http://git-wip-us.apache.org/repos/asf/incubator-asterixdb-hyracks/blob/9939b48e/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/ReinferAllTypesRule.java
----------------------------------------------------------------------
diff --git a/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/ReinferAllTypesRule.java b/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/ReinferAllTypesRule.java
deleted file mode 100644
index aac3a18..0000000
--- a/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/ReinferAllTypesRule.java
+++ /dev/null
@@ -1,64 +0,0 @@
-/*
- * 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.rewriter.rules;
-
-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.ILogicalOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.ILogicalPlan;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.IOptimizationContext;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.AbstractLogicalOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.AbstractOperatorWithNestedPlans;
-import edu.uci.ics.hyracks.algebricks.core.rewriter.base.IAlgebraicRewriteRule;
-
-public class ReinferAllTypesRule implements IAlgebraicRewriteRule {
-
- @Override
- public boolean rewritePost(Mutable<ILogicalOperator> opRef, IOptimizationContext context)
- throws AlgebricksException {
- return false;
- }
-
- @Override
- public boolean rewritePre(Mutable<ILogicalOperator> opRef, IOptimizationContext context) throws AlgebricksException {
- if (context.checkIfInDontApplySet(this, opRef.getValue())) {
- return false;
- }
- typeOpRec(opRef, context);
- return true;
- }
-
- private void typePlan(ILogicalPlan p, IOptimizationContext context) throws AlgebricksException {
- for (Mutable<ILogicalOperator> r : p.getRoots()) {
- typeOpRec(r, context);
- }
- }
-
- private void typeOpRec(Mutable<ILogicalOperator> r, IOptimizationContext context) throws AlgebricksException {
- AbstractLogicalOperator op = (AbstractLogicalOperator) r.getValue();
- for (Mutable<ILogicalOperator> i : op.getInputs()) {
- typeOpRec(i, context);
- }
- if (op.hasNestedPlans()) {
- for (ILogicalPlan p : ((AbstractOperatorWithNestedPlans) op).getNestedPlans()) {
- typePlan(p, context);
- }
- }
- context.computeAndSetTypeEnvironmentForOperator(op);
- context.addToDontApplySet(this, op);
- }
-
-}