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:24 UTC
[11/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/RemoveRedundantGroupByDecorVars.java
----------------------------------------------------------------------
diff --git a/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/RemoveRedundantGroupByDecorVars.java b/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/RemoveRedundantGroupByDecorVars.java
deleted file mode 100644
index 1862834..0000000
--- a/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/RemoveRedundantGroupByDecorVars.java
+++ /dev/null
@@ -1,81 +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.Iterator;
-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.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.VariableReferenceExpression;
-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.rewriter.base.IAlgebraicRewriteRule;
-
-/**
- * Removes duplicate variables from a group-by operator's decor list.
- */
-public class RemoveRedundantGroupByDecorVars implements IAlgebraicRewriteRule {
-
- private final Set<LogicalVariable> vars = new HashSet<LogicalVariable>();
-
- @Override
- public boolean rewritePost(Mutable<ILogicalOperator> opRef, IOptimizationContext context) {
- AbstractLogicalOperator op = (AbstractLogicalOperator) opRef.getValue();
- if (op.getOperatorTag() != LogicalOperatorTag.GROUP) {
- return false;
- }
- if (context.checkIfInDontApplySet(this, op)) {
- return false;
- }
- vars.clear();
-
- boolean modified = false;
- GroupByOperator groupOp = (GroupByOperator) op;
- Iterator<Pair<LogicalVariable, Mutable<ILogicalExpression>>> iter = groupOp.getDecorList().iterator();
- while (iter.hasNext()) {
- Pair<LogicalVariable, Mutable<ILogicalExpression>> decor = iter.next();
- if (decor.first != null || decor.second.getValue().getExpressionTag() != LogicalExpressionTag.VARIABLE) {
- continue;
- }
- VariableReferenceExpression varRefExpr = (VariableReferenceExpression) decor.second.getValue();
- LogicalVariable var = varRefExpr.getVariableReference();
- if (vars.contains(var)) {
- iter.remove();
- modified = true;
- } else {
- vars.add(var);
- }
- }
- if (modified) {
- context.addToDontApplySet(this, op);
- }
- return modified;
- }
-
- @Override
- public boolean rewritePre(Mutable<ILogicalOperator> opRef, IOptimizationContext context) throws AlgebricksException {
- 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/RemoveRedundantProjectionRule.java
----------------------------------------------------------------------
diff --git a/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/RemoveRedundantProjectionRule.java b/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/RemoveRedundantProjectionRule.java
deleted file mode 100644
index 10091b8..0000000
--- a/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/RemoveRedundantProjectionRule.java
+++ /dev/null
@@ -1,89 +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.AbstractLogicalOperator;
-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;
-
-/*
- * project [var-list1]
- * project [var-list2]
- * P
- *
- * if var-list1.equals(var-list2) becomes
- *
- * project [var-list1]
- * P
- *
- */
-
-public class RemoveRedundantProjectionRule 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 op1 = (AbstractLogicalOperator) opRef.getValue();
- if (op1.getOperatorTag() == LogicalOperatorTag.PROJECT) {
- Mutable<ILogicalOperator> opRef2 = op1.getInputs().get(0);
- AbstractLogicalOperator op2 = (AbstractLogicalOperator) opRef2.getValue();
- if (op2.getOperatorTag() != LogicalOperatorTag.PROJECT) {
- return false;
- }
- ProjectOperator pi2 = (ProjectOperator) op2;
- opRef2.setValue(pi2.getInputs().get(0).getValue());
- } else {
- if (op1.getInputs().size() <= 0)
- return false;
- Mutable<ILogicalOperator> opRef2 = op1.getInputs().get(0);
- AbstractLogicalOperator op2 = (AbstractLogicalOperator) opRef2.getValue();
- if (op2.getOperatorTag() != LogicalOperatorTag.PROJECT) {
- return false;
- }
- if (op2.getInputs().size() <= 0)
- return false;
- Mutable<ILogicalOperator> opRef3 = op2.getInputs().get(0);
- AbstractLogicalOperator op3 = (AbstractLogicalOperator) opRef3.getValue();
-
- List<LogicalVariable> liveVars2 = new ArrayList<LogicalVariable>();
- List<LogicalVariable> liveVars3 = new ArrayList<LogicalVariable>();
-
- VariableUtilities.getLiveVariables(op2, liveVars2);
- VariableUtilities.getLiveVariables(op3, liveVars3);
-
- if (!VariableUtilities.varListEqualUnordered(liveVars2, liveVars3))
- return false;
- opRef2.setValue(op3);
- }
-
- 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/RemoveRedundantVariablesRule.java
----------------------------------------------------------------------
diff --git a/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/RemoveRedundantVariablesRule.java b/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/RemoveRedundantVariablesRule.java
deleted file mode 100644
index 8b1aeb4..0000000
--- a/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/RemoveRedundantVariablesRule.java
+++ /dev/null
@@ -1,299 +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.HashMap;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-
-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.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.AbstractLogicalExpression;
-import edu.uci.ics.hyracks.algebricks.core.algebra.expressions.VariableReferenceExpression;
-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.AssignOperator;
-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.UnionAllOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.visitors.ILogicalExpressionReferenceTransform;
-import edu.uci.ics.hyracks.algebricks.core.rewriter.base.IAlgebraicRewriteRule;
-
-/**
- * Replaces redundant variable references with their bottom-most equivalent representative.
- * Does a DFS sweep over the plan keeping track of variable equivalence classes.
- * For example, this rule would perform the following rewrite.
- * Before Plan:
- * select (function-call: func, Args:[%0->$$11])
- * project [$11]
- * assign [$$11] <- [$$10]
- * assign [$$10] <- [$$9]
- * assign [$$9] <- ...
- * ...
- * After Plan:
- * select (function-call: func, Args:[%0->$$9])
- * project [$9]
- * assign [$$11] <- [$$9]
- * assign [$$10] <- [$$9]
- * assign [$$9] <- ...
- * ...
- */
-public class RemoveRedundantVariablesRule implements IAlgebraicRewriteRule {
-
- private final VariableSubstitutionVisitor substVisitor = new VariableSubstitutionVisitor();
- private final Map<LogicalVariable, List<LogicalVariable>> equivalentVarsMap = new HashMap<LogicalVariable, List<LogicalVariable>>();
-
- @Override
- public boolean rewritePost(Mutable<ILogicalOperator> opRef, IOptimizationContext context)
- throws AlgebricksException {
- if (context.checkIfInDontApplySet(this, opRef.getValue())) {
- return false;
- }
- boolean modified = removeRedundantVariables(opRef, context);
- if (modified) {
- context.computeAndSetTypeEnvironmentForOperator(opRef.getValue());
- }
- return modified;
- }
-
- @Override
- public boolean rewritePre(Mutable<ILogicalOperator> opRef, IOptimizationContext context) throws AlgebricksException {
- return false;
- }
-
- private void updateEquivalenceClassMap(LogicalVariable lhs, LogicalVariable rhs) {
- List<LogicalVariable> equivalentVars = equivalentVarsMap.get(rhs);
- if (equivalentVars == null) {
- equivalentVars = new ArrayList<LogicalVariable>();
- // The first element in the list is the bottom-most representative which will replace all equivalent vars.
- equivalentVars.add(rhs);
- equivalentVars.add(lhs);
- equivalentVarsMap.put(rhs, equivalentVars);
- }
- equivalentVarsMap.put(lhs, equivalentVars);
- equivalentVars.get(0);
- }
-
- private boolean removeRedundantVariables(Mutable<ILogicalOperator> opRef, IOptimizationContext context)
- throws AlgebricksException {
- AbstractLogicalOperator op = (AbstractLogicalOperator) opRef.getValue();
- boolean modified = false;
-
- // Update equivalence class map.
- if (op.getOperatorTag() == LogicalOperatorTag.ASSIGN) {
- AssignOperator assignOp = (AssignOperator) op;
- int numVars = assignOp.getVariables().size();
- for (int i = 0; i < numVars; i++) {
- ILogicalExpression expr = assignOp.getExpressions().get(i).getValue();
- if (expr.getExpressionTag() != LogicalExpressionTag.VARIABLE) {
- continue;
- }
- VariableReferenceExpression rhsVarRefExpr = (VariableReferenceExpression) expr;
- // Update equivalence class map.
- LogicalVariable lhs = assignOp.getVariables().get(i);
- LogicalVariable rhs = rhsVarRefExpr.getVariableReference();
- updateEquivalenceClassMap(lhs, rhs);
- }
- }
-
- // Replace variable references with their first representative.
- if (op.getOperatorTag() == LogicalOperatorTag.PROJECT) {
- // The project operator does not use expressions, so we need to replace it's variables manually.
- if (replaceProjectVars((ProjectOperator) op)) {
- modified = true;
- }
- } else if (op.getOperatorTag() == LogicalOperatorTag.UNIONALL) {
- // Replace redundant variables manually in the UnionAll operator.
- if (replaceUnionAllVars((UnionAllOperator) op)) {
- modified = true;
- }
- } else {
- if (op.acceptExpressionTransform(substVisitor)) {
- modified = true;
- }
- }
-
- // Perform variable replacement in nested plans.
- if (op.hasNestedPlans()) {
- AbstractOperatorWithNestedPlans opWithNestedPlan = (AbstractOperatorWithNestedPlans) op;
- for (ILogicalPlan nestedPlan : opWithNestedPlan.getNestedPlans()) {
- for (Mutable<ILogicalOperator> rootRef : nestedPlan.getRoots()) {
- if (removeRedundantVariables(rootRef, context)) {
- modified = true;
- }
- }
- }
- }
-
- // Deal with re-mapping of variables in group by.
- if (op.getOperatorTag() == LogicalOperatorTag.GROUP) {
- if (handleGroupByVarRemapping((GroupByOperator) op)) {
- modified = true;
- }
- }
-
- if (modified) {
- context.computeAndSetTypeEnvironmentForOperator(op);
- context.addToDontApplySet(this, op);
- }
- return modified;
- }
-
- private boolean handleGroupByVarRemapping(GroupByOperator groupOp) {
- boolean modified = false;
- for (Pair<LogicalVariable, Mutable<ILogicalExpression>> gp : groupOp.getGroupByList()) {
- if (gp.first == null || gp.second.getValue().getExpressionTag() != LogicalExpressionTag.VARIABLE) {
- continue;
- }
- LogicalVariable groupByVar = ((VariableReferenceExpression) gp.second.getValue()).getVariableReference();
- Iterator<Pair<LogicalVariable, Mutable<ILogicalExpression>>> iter = groupOp.getDecorList().iterator();
- while (iter.hasNext()) {
- Pair<LogicalVariable, Mutable<ILogicalExpression>> dp = iter.next();
- if (dp.first != null || dp.second.getValue().getExpressionTag() != LogicalExpressionTag.VARIABLE) {
- continue;
- }
- LogicalVariable dv = ((VariableReferenceExpression) dp.second.getValue()).getVariableReference();
- if (dv == groupByVar) {
- // The decor variable is redundant, since it is propagated as a grouping variable.
- List<LogicalVariable> equivalentVars = equivalentVarsMap.get(groupByVar);
- if (equivalentVars != null) {
- // Change representative of this equivalence class.
- equivalentVars.set(0, gp.first);
- equivalentVarsMap.put(gp.first, equivalentVars);
- } else {
- updateEquivalenceClassMap(gp.first, groupByVar);
- }
- iter.remove();
- modified = true;
- break;
- }
- }
- }
- // find the redundant variables within the decor list
- Map<LogicalVariable, LogicalVariable> variableToFirstDecorMap = new HashMap<LogicalVariable, LogicalVariable>();
- Iterator<Pair<LogicalVariable, Mutable<ILogicalExpression>>> iter = groupOp.getDecorList().iterator();
- while (iter.hasNext()) {
- Pair<LogicalVariable, Mutable<ILogicalExpression>> dp = iter.next();
- if (dp.first == null || dp.second.getValue().getExpressionTag() != LogicalExpressionTag.VARIABLE) {
- continue;
- }
- LogicalVariable dv = ((VariableReferenceExpression) dp.second.getValue()).getVariableReference();
- LogicalVariable firstDecor = variableToFirstDecorMap.get(dv);
- if (firstDecor == null) {
- variableToFirstDecorMap.put(dv, dp.first);
- } else {
- // The decor variable dp.first is redundant since firstDecor is exactly the same.
- updateEquivalenceClassMap(dp.first, firstDecor);
- iter.remove();
- modified = true;
- }
- }
- return modified;
- }
-
- /**
- * Replace the projects's variables with their corresponding representative
- * from the equivalence class map (if any).
- * We cannot use the VariableSubstitutionVisitor here because the project ops
- * maintain their variables as a list and not as expressions.
- */
- private boolean replaceProjectVars(ProjectOperator op) throws AlgebricksException {
- List<LogicalVariable> vars = op.getVariables();
- int size = vars.size();
- boolean modified = false;
- for (int i = 0; i < size; i++) {
- LogicalVariable var = vars.get(i);
- List<LogicalVariable> equivalentVars = equivalentVarsMap.get(var);
- if (equivalentVars == null) {
- continue;
- }
- // Replace with equivalence class representative.
- LogicalVariable representative = equivalentVars.get(0);
- if (representative != var) {
- vars.set(i, equivalentVars.get(0));
- modified = true;
- }
- }
- return modified;
- }
-
- private boolean replaceUnionAllVars(UnionAllOperator op) throws AlgebricksException {
- boolean modified = false;
- for (Triple<LogicalVariable, LogicalVariable, LogicalVariable> varMapping : op.getVariableMappings()) {
- List<LogicalVariable> firstEquivalentVars = equivalentVarsMap.get(varMapping.first);
- List<LogicalVariable> secondEquivalentVars = equivalentVarsMap.get(varMapping.second);
- // Replace variables with their representative.
- if (firstEquivalentVars != null) {
- varMapping.first = firstEquivalentVars.get(0);
- modified = true;
- }
- if (secondEquivalentVars != null) {
- varMapping.second = secondEquivalentVars.get(0);
- modified = true;
- }
- }
- return modified;
- }
-
- private class VariableSubstitutionVisitor implements ILogicalExpressionReferenceTransform {
- @Override
- public boolean transform(Mutable<ILogicalExpression> exprRef) {
- ILogicalExpression e = exprRef.getValue();
- switch (((AbstractLogicalExpression) e).getExpressionTag()) {
- case VARIABLE: {
- // Replace variable references with their equivalent representative in the equivalence class map.
- VariableReferenceExpression varRefExpr = (VariableReferenceExpression) e;
- LogicalVariable var = varRefExpr.getVariableReference();
- List<LogicalVariable> equivalentVars = equivalentVarsMap.get(var);
- if (equivalentVars == null) {
- return false;
- }
- LogicalVariable representative = equivalentVars.get(0);
- if (representative != var) {
- varRefExpr.setVariable(representative);
- return true;
- }
- return false;
- }
- case FUNCTION_CALL: {
- AbstractFunctionCallExpression funcExpr = (AbstractFunctionCallExpression) e;
- boolean modified = false;
- for (Mutable<ILogicalExpression> arg : funcExpr.getArguments()) {
- if (transform(arg)) {
- modified = true;
- }
- }
- return modified;
- }
- default: {
- 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/RemoveUnusedAssignAndAggregateRule.java
----------------------------------------------------------------------
diff --git a/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/RemoveUnusedAssignAndAggregateRule.java b/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/RemoveUnusedAssignAndAggregateRule.java
deleted file mode 100644
index de4fbfb..0000000
--- a/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/RemoveUnusedAssignAndAggregateRule.java
+++ /dev/null
@@ -1,240 +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.Iterator;
-import java.util.LinkedList;
-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.common.utils.ListSet;
-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.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.AggregateOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.AssignOperator;
-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;
-
-/**
- * Removes unused variables from Assign, Unnest, Aggregate, and UnionAll operators.
- */
-public class RemoveUnusedAssignAndAggregateRule implements IAlgebraicRewriteRule {
-
- @Override
- public boolean rewritePost(Mutable<ILogicalOperator> opRef, IOptimizationContext context) {
- return false;
- }
-
- @Override
- public boolean rewritePre(Mutable<ILogicalOperator> opRef, IOptimizationContext context) throws AlgebricksException {
- if (context.checkIfInDontApplySet(this, opRef.getValue())) {
- return false;
- }
- Set<LogicalVariable> toRemove = new HashSet<LogicalVariable>();
- collectUnusedAssignedVars((AbstractLogicalOperator) opRef.getValue(), toRemove, true, context);
- boolean smthToRemove = !toRemove.isEmpty();
- if (smthToRemove) {
- removeUnusedAssigns(opRef, toRemove, context);
- }
- return !toRemove.isEmpty();
- }
-
- private void removeUnusedAssigns(Mutable<ILogicalOperator> opRef, Set<LogicalVariable> toRemove,
- IOptimizationContext context) throws AlgebricksException {
- AbstractLogicalOperator op = (AbstractLogicalOperator) opRef.getValue();
- while (removeFromAssigns(op, toRemove, context) == 0) {
- if (op.getOperatorTag() == LogicalOperatorTag.AGGREGATE) {
- break;
- }
- op = (AbstractLogicalOperator) op.getInputs().get(0).getValue();
- opRef.setValue(op);
- }
- Iterator<Mutable<ILogicalOperator>> childIter = op.getInputs().iterator();
- while (childIter.hasNext()) {
- Mutable<ILogicalOperator> cRef = childIter.next();
- removeUnusedAssigns(cRef, toRemove, context);
- }
- if (op.hasNestedPlans()) {
- AbstractOperatorWithNestedPlans opWithNest = (AbstractOperatorWithNestedPlans) op;
- Iterator<ILogicalPlan> planIter = opWithNest.getNestedPlans().iterator();
- while (planIter.hasNext()) {
- ILogicalPlan p = planIter.next();
- for (Mutable<ILogicalOperator> r : p.getRoots()) {
- removeUnusedAssigns(r, toRemove, context);
- }
- }
-
- // Removes redundant nested plans that produces nothing
- for (int i = opWithNest.getNestedPlans().size() - 1; i >= 0; i--) {
- ILogicalPlan nestedPlan = opWithNest.getNestedPlans().get(i);
- List<Mutable<ILogicalOperator>> rootsToBeRemoved = new ArrayList<Mutable<ILogicalOperator>>();
- for (Mutable<ILogicalOperator> r : nestedPlan.getRoots()) {
- ILogicalOperator topOp = r.getValue();
- Set<LogicalVariable> producedVars = new ListSet<LogicalVariable>();
- VariableUtilities.getProducedVariablesInDescendantsAndSelf(topOp, producedVars);
- if (producedVars.size() == 0) {
- rootsToBeRemoved.add(r);
- }
- }
- // Makes sure the operator should have at least ONE nested plan even it is empty
- // (because a lot of places uses this assumption, TODO(yingyib): clean them up).
- if (nestedPlan.getRoots().size() == rootsToBeRemoved.size() && opWithNest.getNestedPlans().size() > 1) {
- nestedPlan.getRoots().removeAll(rootsToBeRemoved);
- opWithNest.getNestedPlans().remove(nestedPlan);
- }
- }
- }
- }
-
- private int removeFromAssigns(AbstractLogicalOperator op, Set<LogicalVariable> toRemove,
- IOptimizationContext context) throws AlgebricksException {
- switch (op.getOperatorTag()) {
- case ASSIGN: {
- AssignOperator assign = (AssignOperator) op;
- if (removeUnusedVarsAndExprs(toRemove, assign.getVariables(), assign.getExpressions())) {
- context.computeAndSetTypeEnvironmentForOperator(assign);
- }
- return assign.getVariables().size();
- }
- case AGGREGATE: {
- AggregateOperator agg = (AggregateOperator) op;
- if (removeUnusedVarsAndExprs(toRemove, agg.getVariables(), agg.getExpressions())) {
- context.computeAndSetTypeEnvironmentForOperator(agg);
- }
- return agg.getVariables().size();
- }
- case UNNEST: {
- UnnestOperator uOp = (UnnestOperator) op;
- LogicalVariable pVar = uOp.getPositionalVariable();
- if (pVar != null && toRemove.contains(pVar)) {
- uOp.setPositionalVariable(null);
- }
- break;
- }
- case UNIONALL: {
- UnionAllOperator unionOp = (UnionAllOperator) op;
- if (removeUnusedVarsFromUnionAll(unionOp, toRemove)) {
- context.computeAndSetTypeEnvironmentForOperator(unionOp);
- }
- return unionOp.getVariableMappings().size();
- }
- }
- return -1;
- }
-
- private boolean removeUnusedVarsFromUnionAll(UnionAllOperator unionOp, Set<LogicalVariable> toRemove) {
- Iterator<Triple<LogicalVariable, LogicalVariable, LogicalVariable>> iter = unionOp.getVariableMappings()
- .iterator();
- boolean modified = false;
- Set<LogicalVariable> removeFromRemoveSet = new HashSet<LogicalVariable>();
- while (iter.hasNext()) {
- Triple<LogicalVariable, LogicalVariable, LogicalVariable> varMapping = iter.next();
- if (toRemove.contains(varMapping.third)) {
- iter.remove();
- modified = true;
- }
- // In any case, make sure we do not removing these variables.
- removeFromRemoveSet.add(varMapping.first);
- removeFromRemoveSet.add(varMapping.second);
- }
- toRemove.removeAll(removeFromRemoveSet);
- return modified;
- }
-
- private boolean removeUnusedVarsAndExprs(Set<LogicalVariable> toRemove, List<LogicalVariable> varList,
- List<Mutable<ILogicalExpression>> exprList) {
- boolean changed = false;
- Iterator<LogicalVariable> varIter = varList.iterator();
- Iterator<Mutable<ILogicalExpression>> exprIter = exprList.iterator();
- while (varIter.hasNext()) {
- LogicalVariable v = varIter.next();
- exprIter.next();
- if (toRemove.contains(v)) {
- varIter.remove();
- exprIter.remove();
- changed = true;
- }
- }
- return changed;
- }
-
- private void collectUnusedAssignedVars(AbstractLogicalOperator op, Set<LogicalVariable> toRemove, boolean first,
- IOptimizationContext context) throws AlgebricksException {
- if (!first) {
- context.addToDontApplySet(this, op);
- }
- for (Mutable<ILogicalOperator> c : op.getInputs()) {
- collectUnusedAssignedVars((AbstractLogicalOperator) c.getValue(), toRemove, false, context);
- }
- if (op.hasNestedPlans()) {
- AbstractOperatorWithNestedPlans opWithNested = (AbstractOperatorWithNestedPlans) op;
- for (ILogicalPlan plan : opWithNested.getNestedPlans()) {
- for (Mutable<ILogicalOperator> r : plan.getRoots()) {
- collectUnusedAssignedVars((AbstractLogicalOperator) r.getValue(), toRemove, false, context);
- }
- }
- }
- boolean removeUsedVars = true;
- switch (op.getOperatorTag()) {
- case ASSIGN: {
- AssignOperator assign = (AssignOperator) op;
- toRemove.addAll(assign.getVariables());
- break;
- }
- case AGGREGATE: {
- AggregateOperator agg = (AggregateOperator) op;
- toRemove.addAll(agg.getVariables());
- break;
- }
- case UNNEST: {
- UnnestOperator uOp = (UnnestOperator) op;
- LogicalVariable pVar = uOp.getPositionalVariable();
- if (pVar != null) {
- toRemove.add(pVar);
- }
- break;
- }
- case UNIONALL: {
- UnionAllOperator unionOp = (UnionAllOperator) op;
- for (Triple<LogicalVariable, LogicalVariable, LogicalVariable> varMapping : unionOp
- .getVariableMappings()) {
- toRemove.add(varMapping.third);
- }
- removeUsedVars = false;
- break;
- }
- }
- if (removeUsedVars) {
- List<LogicalVariable> used = new LinkedList<LogicalVariable>();
- VariableUtilities.getUsedVariables(op, used);
- toRemove.removeAll(used);
- }
- }
-
-}
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/SetAlgebricksPhysicalOperatorsRule.java
----------------------------------------------------------------------
diff --git a/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/SetAlgebricksPhysicalOperatorsRule.java b/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/SetAlgebricksPhysicalOperatorsRule.java
deleted file mode 100644
index bc7255b..0000000
--- a/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/SetAlgebricksPhysicalOperatorsRule.java
+++ /dev/null
@@ -1,424 +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.exceptions.NotImplementedException;
-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.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.base.OperatorAnnotations;
-import edu.uci.ics.hyracks.algebricks.core.algebra.expressions.IMergeAggregationExpressionFactory;
-import edu.uci.ics.hyracks.algebricks.core.algebra.expressions.VariableReferenceExpression;
-import edu.uci.ics.hyracks.algebricks.core.algebra.metadata.IDataSource;
-import edu.uci.ics.hyracks.algebricks.core.algebra.metadata.IMetadataProvider;
-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.AggregateOperator;
-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.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.OrderOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.OrderOperator.IOrder;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.TokenizeOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.WriteResultOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.physical.AggregatePOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.physical.AssignPOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.physical.BulkloadPOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.physical.DataSourceScanPOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.physical.DistributeResultPOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.physical.EmptyTupleSourcePOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.physical.ExternalGroupByPOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.physical.InMemoryStableSortPOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.physical.IndexBulkloadPOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.physical.IndexInsertDeletePOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.physical.InsertDeletePOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.physical.MicroPreclusteredGroupByPOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.physical.NestedTupleSourcePOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.physical.PreSortedDistinctByPOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.physical.PreclusteredGroupByPOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.physical.ReplicatePOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.physical.RunningAggregatePOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.physical.SinkPOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.physical.SinkWritePOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.physical.StableSortPOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.physical.StreamLimitPOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.physical.StreamProjectPOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.physical.StreamSelectPOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.physical.StringStreamingScriptPOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.physical.SubplanPOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.physical.TokenizePOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.physical.UnionAllPOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.physical.UnnestPOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.physical.WriteResultPOperator;
-import edu.uci.ics.hyracks.algebricks.core.rewriter.base.IAlgebraicRewriteRule;
-import edu.uci.ics.hyracks.algebricks.core.rewriter.base.PhysicalOptimizationConfig;
-import edu.uci.ics.hyracks.algebricks.rewriter.util.JoinUtils;
-
-public class SetAlgebricksPhysicalOperatorsRule 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 {
- AbstractLogicalOperator op = (AbstractLogicalOperator) opRef.getValue();
- // if (context.checkIfInDontApplySet(this, op)) {
- // return false;
- // }
- if (op.getPhysicalOperator() != null) {
- return false;
- }
-
- computeDefaultPhysicalOp(op, true, context);
- // context.addToDontApplySet(this, op);
- return true;
- }
-
- private static void setPhysicalOperators(ILogicalPlan plan, boolean topLevelOp, IOptimizationContext context)
- throws AlgebricksException {
- for (Mutable<ILogicalOperator> root : plan.getRoots()) {
- computeDefaultPhysicalOp((AbstractLogicalOperator) root.getValue(), topLevelOp, context);
- }
- }
-
- @SuppressWarnings("unchecked")
- private static void computeDefaultPhysicalOp(AbstractLogicalOperator op, boolean topLevelOp,
- IOptimizationContext context) throws AlgebricksException {
- PhysicalOptimizationConfig physicalOptimizationConfig = context.getPhysicalOptimizationConfig();
- if (op.getPhysicalOperator() == null) {
- switch (op.getOperatorTag()) {
- case AGGREGATE: {
- op.setPhysicalOperator(new AggregatePOperator());
- break;
- }
- case ASSIGN: {
- op.setPhysicalOperator(new AssignPOperator());
- break;
- }
- case DISTINCT: {
- DistinctOperator distinct = (DistinctOperator) op;
- distinct.setPhysicalOperator(new PreSortedDistinctByPOperator(distinct.getDistinctByVarList()));
- break;
- }
- case EMPTYTUPLESOURCE: {
- op.setPhysicalOperator(new EmptyTupleSourcePOperator());
- break;
- }
- case EXCHANGE: {
- if (op.getPhysicalOperator() == null) {
- throw new AlgebricksException("Implementation for EXCHANGE operator was not set.");
- }
- // implem. choice for exchange should be set by a parent op.
- break;
- }
- case GROUP: {
- GroupByOperator gby = (GroupByOperator) op;
-
- if (gby.getNestedPlans().size() == 1) {
- ILogicalPlan p0 = gby.getNestedPlans().get(0);
- if (p0.getRoots().size() == 1) {
- if (gby.getAnnotations().get(OperatorAnnotations.USE_HASH_GROUP_BY) == Boolean.TRUE
- || gby.getAnnotations().get(OperatorAnnotations.USE_EXTERNAL_GROUP_BY) == Boolean.TRUE) {
- if (!topLevelOp) {
- throw new NotImplementedException(
- "External hash group-by for nested grouping is not implemented.");
- }
-
- boolean hasIntermediateAgg = generateMergeAggregationExpressions(gby, context);
- if (hasIntermediateAgg) {
- ExternalGroupByPOperator externalGby = new ExternalGroupByPOperator(
- gby.getGroupByList(),
- physicalOptimizationConfig.getMaxFramesExternalGroupBy(),
- physicalOptimizationConfig.getExternalGroupByTableSize());
- op.setPhysicalOperator(externalGby);
- break;
- }
- }
- }
- }
-
- List<Pair<LogicalVariable, Mutable<ILogicalExpression>>> gbyList = gby.getGroupByList();
- List<LogicalVariable> columnList = new ArrayList<LogicalVariable>(gbyList.size());
- for (Pair<LogicalVariable, Mutable<ILogicalExpression>> p : gbyList) {
- ILogicalExpression expr = p.second.getValue();
- if (expr.getExpressionTag() == LogicalExpressionTag.VARIABLE) {
- VariableReferenceExpression varRef = (VariableReferenceExpression) expr;
- columnList.add(varRef.getVariableReference());
- }
- }
- if (topLevelOp) {
- op.setPhysicalOperator(new PreclusteredGroupByPOperator(columnList));
- } else {
- op.setPhysicalOperator(new MicroPreclusteredGroupByPOperator(columnList));
- }
- break;
- }
- case INNERJOIN: {
- JoinUtils.setJoinAlgorithmAndExchangeAlgo((InnerJoinOperator) op, context);
- break;
- }
- case LEFTOUTERJOIN: {
- JoinUtils.setJoinAlgorithmAndExchangeAlgo((LeftOuterJoinOperator) op, context);
- break;
- }
- case LIMIT: {
- op.setPhysicalOperator(new StreamLimitPOperator());
- break;
- }
- case NESTEDTUPLESOURCE: {
- op.setPhysicalOperator(new NestedTupleSourcePOperator());
- break;
- }
- case ORDER: {
- OrderOperator oo = (OrderOperator) op;
- for (Pair<IOrder, Mutable<ILogicalExpression>> p : oo.getOrderExpressions()) {
- ILogicalExpression e = p.second.getValue();
- if (e.getExpressionTag() != LogicalExpressionTag.VARIABLE) {
- throw new AlgebricksException("Order expression " + e + " has not been normalized.");
- }
- }
- if (topLevelOp) {
- op.setPhysicalOperator(new StableSortPOperator(physicalOptimizationConfig
- .getMaxFramesExternalSort()));
- } else {
- op.setPhysicalOperator(new InMemoryStableSortPOperator());
- }
- break;
- }
- case PROJECT: {
- op.setPhysicalOperator(new StreamProjectPOperator());
- break;
- }
- case RUNNINGAGGREGATE: {
- op.setPhysicalOperator(new RunningAggregatePOperator());
- break;
- }
- case REPLICATE: {
- op.setPhysicalOperator(new ReplicatePOperator());
- break;
- }
- case SCRIPT: {
- op.setPhysicalOperator(new StringStreamingScriptPOperator());
- break;
- }
- case SELECT: {
- op.setPhysicalOperator(new StreamSelectPOperator());
- break;
- }
- case SUBPLAN: {
- op.setPhysicalOperator(new SubplanPOperator());
- break;
- }
- case UNIONALL: {
- op.setPhysicalOperator(new UnionAllPOperator());
- break;
- }
-
- case UNNEST: {
- op.setPhysicalOperator(new UnnestPOperator());
- break;
- }
- case DATASOURCESCAN: {
- DataSourceScanOperator scan = (DataSourceScanOperator) op;
- IDataSource dataSource = scan.getDataSource();
- DataSourceScanPOperator dss = new DataSourceScanPOperator(dataSource);
- IMetadataProvider mp = context.getMetadataProvider();
- if (mp.scannerOperatorIsLeaf(dataSource)) {
- dss.disableJobGenBelowMe();
- }
- op.setPhysicalOperator(dss);
- break;
- }
- case WRITE: {
- op.setPhysicalOperator(new SinkWritePOperator());
- break;
- }
- case DISTRIBUTE_RESULT: {
- op.setPhysicalOperator(new DistributeResultPOperator());
- break;
- }
- case WRITE_RESULT: {
- WriteResultOperator opLoad = (WriteResultOperator) op;
- LogicalVariable payload;
- List<LogicalVariable> keys = new ArrayList<LogicalVariable>();
- List<LogicalVariable> additionalFilteringKeys = null;
- payload = getKeysAndLoad(opLoad.getPayloadExpression(), opLoad.getKeyExpressions(), keys);
- if (opLoad.getAdditionalFilteringExpressions() != null) {
- additionalFilteringKeys = new ArrayList<LogicalVariable>();
- getKeys(opLoad.getAdditionalFilteringExpressions(), additionalFilteringKeys);
- }
- op.setPhysicalOperator(new WriteResultPOperator(opLoad.getDataSource(), payload, keys,
- additionalFilteringKeys));
- break;
- }
- case INSERT_DELETE: {
- InsertDeleteOperator opLoad = (InsertDeleteOperator) op;
- LogicalVariable payload;
- List<LogicalVariable> keys = new ArrayList<LogicalVariable>();
- List<LogicalVariable> additionalFilteringKeys = null;
- payload = getKeysAndLoad(opLoad.getPayloadExpression(), opLoad.getPrimaryKeyExpressions(), keys);
- if (opLoad.getAdditionalFilteringExpressions() != null) {
- additionalFilteringKeys = new ArrayList<LogicalVariable>();
- getKeys(opLoad.getAdditionalFilteringExpressions(), additionalFilteringKeys);
- }
- if (opLoad.isBulkload()) {
- op.setPhysicalOperator(new BulkloadPOperator(payload, keys, additionalFilteringKeys, opLoad
- .getDataSource()));
- } else {
- op.setPhysicalOperator(new InsertDeletePOperator(payload, keys, additionalFilteringKeys, opLoad
- .getDataSource()));
- }
- break;
- }
- case INDEX_INSERT_DELETE: {
- IndexInsertDeleteOperator opInsDel = (IndexInsertDeleteOperator) op;
- List<LogicalVariable> primaryKeys = new ArrayList<LogicalVariable>();
- List<LogicalVariable> secondaryKeys = new ArrayList<LogicalVariable>();
- List<LogicalVariable> additionalFilteringKeys = null;
- getKeys(opInsDel.getPrimaryKeyExpressions(), primaryKeys);
- getKeys(opInsDel.getSecondaryKeyExpressions(), secondaryKeys);
- if (opInsDel.getAdditionalFilteringExpressions() != null) {
- additionalFilteringKeys = new ArrayList<LogicalVariable>();
- getKeys(opInsDel.getAdditionalFilteringExpressions(), additionalFilteringKeys);
- }
- if (opInsDel.isBulkload()) {
- op.setPhysicalOperator(new IndexBulkloadPOperator(primaryKeys, secondaryKeys,
- additionalFilteringKeys, opInsDel.getFilterExpression(), opInsDel.getDataSourceIndex()));
- } else {
- op.setPhysicalOperator(new IndexInsertDeletePOperator(primaryKeys, secondaryKeys,
- additionalFilteringKeys, opInsDel.getFilterExpression(), opInsDel.getDataSourceIndex()));
- }
-
- break;
-
- }
- case TOKENIZE: {
- TokenizeOperator opTokenize = (TokenizeOperator) op;
- List<LogicalVariable> primaryKeys = new ArrayList<LogicalVariable>();
- List<LogicalVariable> secondaryKeys = new ArrayList<LogicalVariable>();
- getKeys(opTokenize.getPrimaryKeyExpressions(), primaryKeys);
- getKeys(opTokenize.getSecondaryKeyExpressions(), secondaryKeys);
- // Tokenize Operator only operates with a bulk load on a data set with an index
- if (opTokenize.isBulkload()) {
- op.setPhysicalOperator(new TokenizePOperator(primaryKeys, secondaryKeys, opTokenize
- .getDataSourceIndex()));
- }
- break;
- }
- case SINK: {
- op.setPhysicalOperator(new SinkPOperator());
- break;
- }
- }
- }
- if (op.hasNestedPlans()) {
- AbstractOperatorWithNestedPlans nested = (AbstractOperatorWithNestedPlans) op;
- for (ILogicalPlan p : nested.getNestedPlans()) {
- setPhysicalOperators(p, false, context);
- }
- }
- for (Mutable<ILogicalOperator> opRef : op.getInputs()) {
- computeDefaultPhysicalOp((AbstractLogicalOperator) opRef.getValue(), topLevelOp, context);
- }
- }
-
- private static void getKeys(List<Mutable<ILogicalExpression>> keyExpressions, List<LogicalVariable> keys) {
- for (Mutable<ILogicalExpression> kExpr : keyExpressions) {
- ILogicalExpression e = kExpr.getValue();
- if (e.getExpressionTag() != LogicalExpressionTag.VARIABLE) {
- throw new NotImplementedException();
- }
- keys.add(((VariableReferenceExpression) e).getVariableReference());
- }
- }
-
- private static LogicalVariable getKeysAndLoad(Mutable<ILogicalExpression> payloadExpr,
- List<Mutable<ILogicalExpression>> keyExpressions, List<LogicalVariable> keys) {
- LogicalVariable payload;
- if (payloadExpr.getValue().getExpressionTag() != LogicalExpressionTag.VARIABLE) {
- throw new NotImplementedException();
- }
- payload = ((VariableReferenceExpression) payloadExpr.getValue()).getVariableReference();
-
- for (Mutable<ILogicalExpression> kExpr : keyExpressions) {
- ILogicalExpression e = kExpr.getValue();
- if (e.getExpressionTag() != LogicalExpressionTag.VARIABLE) {
- throw new NotImplementedException();
- }
- keys.add(((VariableReferenceExpression) e).getVariableReference());
- }
- return payload;
- }
-
- private static boolean generateMergeAggregationExpressions(GroupByOperator gby, IOptimizationContext context)
- throws AlgebricksException {
- if (gby.getNestedPlans().size() != 1) {
- //External/Sort group-by currently works only for one nested plan with one root containing
- //an aggregate and a nested-tuple-source.
- throw new AlgebricksException(
- "External 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) {
- //External/Sort group-by currently works only for one nested plan with one root containing
- //an aggregate and a nested-tuple-source.
- throw new AlgebricksException(
- "External 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);
- AbstractLogicalOperator r0Logical = (AbstractLogicalOperator) r0.getValue();
- if (r0Logical.getOperatorTag() != LogicalOperatorTag.AGGREGATE) {
- return false;
- }
- 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/SetExecutionModeRule.java
----------------------------------------------------------------------
diff --git a/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/SetExecutionModeRule.java b/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/SetExecutionModeRule.java
deleted file mode 100644
index d938f73..0000000
--- a/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/SetExecutionModeRule.java
+++ /dev/null
@@ -1,70 +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.NotImplementedException;
-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.operators.logical.AbstractLogicalOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.util.OperatorManipulationUtil;
-import edu.uci.ics.hyracks.algebricks.core.rewriter.base.IAlgebraicRewriteRule;
-
-/**
- * This rule sets the executionMode property of an operator, w/o introducing
- * EXCHANGE operators in the plan. Previously, i.e. before having physical
- * optimizations in place, we were using the IntroduceExchangeRule, which was
- * doing both, to both set excutionMode and introduce data exchange ops.
- *
- * @author Nicola
- */
-public class SetExecutionModeRule implements IAlgebraicRewriteRule {
-
- @Override
- public boolean rewritePost(Mutable<ILogicalOperator> opRef, IOptimizationContext context) {
- AbstractLogicalOperator op = (AbstractLogicalOperator) opRef.getValue();
- boolean changed = OperatorManipulationUtil.setOperatorMode(op);
- if (op.getExecutionMode() == AbstractLogicalOperator.ExecutionMode.UNPARTITIONED
- || op.getExecutionMode() == AbstractLogicalOperator.ExecutionMode.LOCAL) {
- return changed;
- }
- switch (op.getOperatorTag()) {
- // case DISTINCT:
- // case AGGREGATE:
- // case GROUP:
- // case ORDER:
- // case INNERJOIN:
- // case LEFTOUTERJOIN: {
- // op.setExecutionMode(ExecutionMode.GLOBAL);
- // return true;
- // }
-
- case PARTITIONINGSPLIT: {
- throw new NotImplementedException();
- }
- default: {
- return changed;
- }
- }
-
- }
-
- @Override
- public boolean rewritePre(Mutable<ILogicalOperator> opRef, IOptimizationContext context) {
- 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/SimpleUnnestToProductRule.java
----------------------------------------------------------------------
diff --git a/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/SimpleUnnestToProductRule.java b/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/SimpleUnnestToProductRule.java
deleted file mode 100644
index f6c6ad8..0000000
--- a/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/SimpleUnnestToProductRule.java
+++ /dev/null
@@ -1,144 +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.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.expressions.ConstantExpression;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.AbstractLogicalOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.AbstractScanOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.EmptyTupleSourceOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.InnerJoinOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.NestedTupleSourceOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.visitors.VariableUtilities;
-import edu.uci.ics.hyracks.algebricks.core.rewriter.base.IAlgebraicRewriteRule;
-
-public class SimpleUnnestToProductRule 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 op = (AbstractLogicalOperator) opRef.getValue();
- if (op.getOperatorTag() != LogicalOperatorTag.DATASOURCESCAN
- && op.getOperatorTag() != LogicalOperatorTag.UNNEST) {
- return false;
- }
-
- Mutable<ILogicalOperator> opRef2 = op.getInputs().get(0);
- AbstractLogicalOperator op2 = (AbstractLogicalOperator) opRef2.getValue();
-
- if (!(op2 instanceof AbstractScanOperator) && !descOrSelfIsSourceScan(op2)) {
- return false;
- }
- // Make sure that op does not use any variables produced by op2.
- if (!opsAreIndependent(op, op2)) {
- return false;
- }
-
- /**
- * finding the boundary between left branch and right branch
- * operator pipeline on-top-of boundaryOpRef (exclusive) is the inner branch
- * operator pipeline under boundaryOpRef (inclusive) is the outer branch
- */
- Mutable<ILogicalOperator> currentOpRef = opRef;
- Mutable<ILogicalOperator> boundaryOpRef = currentOpRef.getValue().getInputs().get(0);
- while (currentOpRef.getValue().getInputs().size() == 1) {
- currentOpRef = currentOpRef.getValue().getInputs().get(0);
- }
- Mutable<ILogicalOperator> tupleSourceOpRef = currentOpRef;
- currentOpRef = opRef;
- if (tupleSourceOpRef.getValue().getOperatorTag() == LogicalOperatorTag.NESTEDTUPLESOURCE) {
- NestedTupleSourceOperator nts = (NestedTupleSourceOperator) tupleSourceOpRef.getValue();
- // If the subplan input is a trivial plan, do not do the rewriting.
- if (nts.getSourceOperator().getOperatorTag() != LogicalOperatorTag.EMPTYTUPLESOURCE) {
- while (currentOpRef.getValue().getInputs().size() == 1
- && currentOpRef.getValue() instanceof AbstractScanOperator
- && descOrSelfIsSourceScan((AbstractLogicalOperator) currentOpRef.getValue())) {
- if (opsAreIndependent(currentOpRef.getValue(), tupleSourceOpRef.getValue())) {
- /** move down the boundary if the operator is independent of the tuple source */
- boundaryOpRef = currentOpRef.getValue().getInputs().get(0);
- } else {
- break;
- }
- currentOpRef = currentOpRef.getValue().getInputs().get(0);
- }
- }
- }
-
- /** join the two independent branches */
- InnerJoinOperator join = new InnerJoinOperator(new MutableObject<ILogicalExpression>(ConstantExpression.TRUE),
- new MutableObject<ILogicalOperator>(boundaryOpRef.getValue()), new MutableObject<ILogicalOperator>(
- opRef.getValue()));
- opRef.setValue(join);
- ILogicalOperator ets = new EmptyTupleSourceOperator();
- boundaryOpRef.setValue(ets);
- context.computeAndSetTypeEnvironmentForOperator(boundaryOpRef.getValue());
- context.computeAndSetTypeEnvironmentForOperator(opRef.getValue());
- context.computeAndSetTypeEnvironmentForOperator(join);
- return true;
- }
-
- private boolean descOrSelfIsSourceScan(AbstractLogicalOperator op2) {
- // Disregard data source scans in a subplan.
- if (op2.getOperatorTag() == LogicalOperatorTag.SUBPLAN) {
- return false;
- }
- if (op2.getOperatorTag() == LogicalOperatorTag.DATASOURCESCAN
- && op2.getOperatorTag() != LogicalOperatorTag.UNNEST) {
- return true;
- }
- for (Mutable<ILogicalOperator> cRef : op2.getInputs()) {
- AbstractLogicalOperator alo = (AbstractLogicalOperator) cRef.getValue();
- if (descOrSelfIsSourceScan(alo)) {
- return true;
- }
- }
- return false;
- }
-
- private boolean opsAreIndependent(ILogicalOperator unnestOp, ILogicalOperator outer) throws AlgebricksException {
- if (unnestOp.equals(outer)) {
- return false;
- }
- List<LogicalVariable> opUsedVars = new ArrayList<LogicalVariable>();
- VariableUtilities.getUsedVariables(unnestOp, opUsedVars);
- Set<LogicalVariable> op2LiveVars = new HashSet<LogicalVariable>();
- VariableUtilities.getLiveVariables(outer, op2LiveVars);
- for (LogicalVariable usedVar : opUsedVars) {
- if (op2LiveVars.contains(usedVar)) {
- return false;
- }
- }
- 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/SubplanOutOfGroupRule.java
----------------------------------------------------------------------
diff --git a/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/SubplanOutOfGroupRule.java b/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/SubplanOutOfGroupRule.java
deleted file mode 100644
index f249122..0000000
--- a/algebricks/algebricks-rewriter/src/main/java/edu/uci/ics/hyracks/algebricks/rewriter/rules/SubplanOutOfGroupRule.java
+++ /dev/null
@@ -1,121 +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.Iterator;
-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.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.GroupByOperator;
-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;
-
-/**
- * Looks for a nested group-by plan ending in
- * subplan {
- * ...
- * }
- * select (function-call: algebricks:not, Args:[function-call:
- * algebricks:is-null, Args:[...]])
- * nested tuple source -- |UNPARTITIONED|
- */
-
-public class SubplanOutOfGroupRule 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 op0 = (AbstractLogicalOperator) opRef.getValue();
- if (op0.getOperatorTag() != LogicalOperatorTag.GROUP) {
- return false;
- }
- GroupByOperator gby = (GroupByOperator) op0;
-
- Iterator<ILogicalPlan> plansIter = gby.getNestedPlans().iterator();
- ILogicalPlan p = null;
- while (plansIter.hasNext()) {
- p = plansIter.next();
- }
- if (p == null) {
- return false;
- }
- if (p.getRoots().size() != 1) {
- return false;
- }
- Mutable<ILogicalOperator> op1Ref = p.getRoots().get(0);
- AbstractLogicalOperator op1 = (AbstractLogicalOperator) op1Ref.getValue();
- boolean found = false;
- while (op1.getInputs().size() == 1) {
- if (op1.getOperatorTag() == LogicalOperatorTag.SUBPLAN) {
- SubplanOperator subplan = (SubplanOperator) op1;
- AbstractLogicalOperator op2 = (AbstractLogicalOperator) subplan.getInputs().get(0).getValue();
- if (OperatorPropertiesUtil.isNullTest(op2)) {
- if (subplan.getNestedPlans().size() == 1) {
- ILogicalPlan p1 = subplan.getNestedPlans().get(0);
- if (p1.getRoots().size() == 1) {
- AbstractLogicalOperator r1 = (AbstractLogicalOperator) p1.getRoots().get(0).getValue();
- if (r1.getOperatorTag() == LogicalOperatorTag.INNERJOIN
- || r1.getOperatorTag() == LogicalOperatorTag.LEFTOUTERJOIN) {
- // now, check that it propagates all variables,
- // so it can be pushed
- List<LogicalVariable> op2Vars = new ArrayList<LogicalVariable>();
- VariableUtilities.getLiveVariables(op2, op2Vars);
- List<LogicalVariable> op1Vars = new ArrayList<LogicalVariable>();
- VariableUtilities.getLiveVariables(subplan, op1Vars);
- if (op1Vars.containsAll(op2Vars)) {
- found = true;
- break;
- }
- }
- }
- }
- }
- }
- op1Ref = op1.getInputs().get(0);
- op1 = (AbstractLogicalOperator) op1Ref.getValue();
- }
- if (!found) {
- return false;
- }
-
- ILogicalOperator subplan = op1;
- ILogicalOperator op2 = op1.getInputs().get(0).getValue();
- op1Ref.setValue(op2);
- Mutable<ILogicalOperator> opUnderRef = gby.getInputs().get(0);
- ILogicalOperator opUnder = opUnderRef.getValue();
- subplan.getInputs().clear();
- subplan.getInputs().add(new MutableObject<ILogicalOperator>(opUnder));
- opUnderRef.setValue(subplan);
-
- return true;
- }
-}