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:58 UTC
[45/51] [partial] incubator-asterixdb-hyracks git commit: Change
folder structure for Java repackage
http://git-wip-us.apache.org/repos/asf/incubator-asterixdb-hyracks/blob/9939b48e/algebricks/algebricks-core/src/main/java/edu/uci/ics/hyracks/algebricks/core/algebra/operators/logical/UnnestMapOperator.java
----------------------------------------------------------------------
diff --git a/algebricks/algebricks-core/src/main/java/edu/uci/ics/hyracks/algebricks/core/algebra/operators/logical/UnnestMapOperator.java b/algebricks/algebricks-core/src/main/java/edu/uci/ics/hyracks/algebricks/core/algebra/operators/logical/UnnestMapOperator.java
deleted file mode 100644
index b7a56be..0000000
--- a/algebricks/algebricks-core/src/main/java/edu/uci/ics/hyracks/algebricks/core/algebra/operators/logical/UnnestMapOperator.java
+++ /dev/null
@@ -1,134 +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.core.algebra.operators.logical;
-
-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.ILogicalExpression;
-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.IVariableTypeEnvironment;
-import edu.uci.ics.hyracks.algebricks.core.algebra.properties.VariablePropagationPolicy;
-import edu.uci.ics.hyracks.algebricks.core.algebra.typing.ITypingContext;
-import edu.uci.ics.hyracks.algebricks.core.algebra.typing.NonPropagatingTypeEnvironment;
-import edu.uci.ics.hyracks.algebricks.core.algebra.visitors.ILogicalOperatorVisitor;
-
-/**
- * This operator may go away after we add indexes to Algebricks.
- */
-public class UnnestMapOperator extends AbstractUnnestOperator {
-
- private final List<Object> variableTypes; // TODO: get rid of this and deprecate UnnestMap
- private boolean propagateInput;
-
- private List<Mutable<ILogicalExpression>> additionalFilteringExpressions;
- private List<LogicalVariable> minFilterVars;
- private List<LogicalVariable> maxFilterVars;
-
- public UnnestMapOperator(List<LogicalVariable> variables, Mutable<ILogicalExpression> expression,
- List<Object> variableTypes, boolean propagateInput) {
- super(variables, expression);
- this.variableTypes = variableTypes;
- this.propagateInput = propagateInput;
- }
-
- @Override
- public LogicalOperatorTag getOperatorTag() {
- return LogicalOperatorTag.UNNEST_MAP;
- }
-
- @Override
- public <R, T> R accept(ILogicalOperatorVisitor<R, T> visitor, T arg) throws AlgebricksException {
- return visitor.visitUnnestMapOperator(this, arg);
- }
-
- /**
- * UnnestMap doesn't propagate input variables, because currently it is only
- * used to search indexes. In the future, it would be nice to have the
- * choice to propagate input variables or not.
- */
- @Override
- public VariablePropagationPolicy getVariablePropagationPolicy() {
- return new VariablePropagationPolicy() {
- @Override
- public void propagateVariables(IOperatorSchema target, IOperatorSchema... sources)
- throws AlgebricksException {
- if (propagateInput) {
- target.addAllVariables(sources[0]);
- }
- for (LogicalVariable v : variables) {
- target.addVariable(v);
- }
- }
- };
- }
-
- public List<Object> getVariableTypes() {
- return variableTypes;
- }
-
- @Override
- public IVariableTypeEnvironment computeOutputTypeEnvironment(ITypingContext ctx) throws AlgebricksException {
- IVariableTypeEnvironment env = null;
- if (propagateInput) {
- env = createPropagatingAllInputsTypeEnvironment(ctx);
- } else {
- env = new NonPropagatingTypeEnvironment(ctx.getExpressionTypeComputer(), ctx.getMetadataProvider());
- }
- int n = variables.size();
- for (int i = 0; i < n; i++) {
- env.setVarType(variables.get(i), variableTypes.get(i));
- }
- return env;
- }
-
- public boolean propagatesInput() {
- return propagateInput;
- }
-
- public List<LogicalVariable> getMinFilterVars() {
- return minFilterVars;
- }
-
- public void setMinFilterVars(List<LogicalVariable> minFilterVars) {
- this.minFilterVars = minFilterVars;
- }
-
- public List<LogicalVariable> getMaxFilterVars() {
- return maxFilterVars;
- }
-
- public void setMaxFilterVars(List<LogicalVariable> maxFilterVars) {
- this.maxFilterVars = maxFilterVars;
- }
-
- public void setAdditionalFilteringExpressions(List<Mutable<ILogicalExpression>> additionalFilteringExpressions) {
- this.additionalFilteringExpressions = additionalFilteringExpressions;
- }
-
- public List<Mutable<ILogicalExpression>> getAdditionalFilteringExpressions() {
- return additionalFilteringExpressions;
- }
-
- /*
- @Override
- public boolean isMap() {
- return !propagateInput;
- }
- */
-}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/incubator-asterixdb-hyracks/blob/9939b48e/algebricks/algebricks-core/src/main/java/edu/uci/ics/hyracks/algebricks/core/algebra/operators/logical/UnnestOperator.java
----------------------------------------------------------------------
diff --git a/algebricks/algebricks-core/src/main/java/edu/uci/ics/hyracks/algebricks/core/algebra/operators/logical/UnnestOperator.java b/algebricks/algebricks-core/src/main/java/edu/uci/ics/hyracks/algebricks/core/algebra/operators/logical/UnnestOperator.java
deleted file mode 100644
index dba9e19..0000000
--- a/algebricks/algebricks-core/src/main/java/edu/uci/ics/hyracks/algebricks/core/algebra/operators/logical/UnnestOperator.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.core.algebra.operators.logical;
-
-import java.util.ArrayList;
-
-import org.apache.commons.lang3.mutable.Mutable;
-
-import edu.uci.ics.hyracks.algebricks.common.exceptions.AlgebricksException;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.ILogicalExpression;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.LogicalOperatorTag;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.LogicalVariable;
-import edu.uci.ics.hyracks.algebricks.core.algebra.expressions.IVariableTypeEnvironment;
-import edu.uci.ics.hyracks.algebricks.core.algebra.properties.VariablePropagationPolicy;
-import edu.uci.ics.hyracks.algebricks.core.algebra.typing.ITypingContext;
-import edu.uci.ics.hyracks.algebricks.core.algebra.visitors.ILogicalOperatorVisitor;
-import edu.uci.ics.hyracks.algebricks.runtime.base.IUnnestingPositionWriter;
-
-public class UnnestOperator extends AbstractUnnestOperator {
-
- private LogicalVariable positionalVariable;
-
- /**
- * Used to set the position offset for positional variable
- */
- private ILogicalExpression positionOffsetExpr;
-
- /**
- * Specify the writer of the positional variable
- */
- private IUnnestingPositionWriter positionWriter;
-
- /**
- * Specify the type of the positional variable
- */
- private Object positionalVariableType;
-
- public UnnestOperator(LogicalVariable variable, Mutable<ILogicalExpression> expression) {
- super(makeSingletonList(variable), expression);
- }
-
- public UnnestOperator(LogicalVariable variable, Mutable<ILogicalExpression> expression,
- LogicalVariable positionalVariable, Object positionalVariableType, IUnnestingPositionWriter positionWriter) {
- this(variable, expression);
- this.setPositionalVariable(positionalVariable);
- this.setPositionalVariableType(positionalVariableType);
- this.setPositionWriter(positionWriter);
- }
-
- @Override
- public LogicalOperatorTag getOperatorTag() {
- return LogicalOperatorTag.UNNEST;
- }
-
- public LogicalVariable getVariable() {
- return variables.get(0);
- }
-
- public void setPositionalVariable(LogicalVariable positionalVariable) {
- this.positionalVariable = positionalVariable;
- }
-
- public LogicalVariable getPositionalVariable() {
- return positionalVariable;
- }
-
- public void setPositionWriter(IUnnestingPositionWriter positionWriter) {
- this.positionWriter = positionWriter;
- }
-
- public IUnnestingPositionWriter getPositionWriter() {
- return positionalVariable != null ? positionWriter : null;
- }
-
- public void setPositionalVariableType(Object positionalVariableType) {
- this.positionalVariableType = positionalVariableType;
- }
-
- public Object getPositionalVariableType() {
- return positionalVariableType;
- }
-
- public void setPositionOffsetExpr(ILogicalExpression posOffsetExpr) {
- this.positionOffsetExpr = posOffsetExpr;
- }
-
- public ILogicalExpression getPositionOffsetExpr() {
- return this.positionOffsetExpr;
- }
-
- @Override
- public <R, T> R accept(ILogicalOperatorVisitor<R, T> visitor, T arg) throws AlgebricksException {
- return visitor.visitUnnestOperator(this, arg);
- }
-
- private static <E> ArrayList<E> makeSingletonList(E item) {
- ArrayList<E> array = new ArrayList<E>(1);
- array.add(item);
- return array;
- }
-
- @Override
- public IVariableTypeEnvironment computeOutputTypeEnvironment(ITypingContext ctx) throws AlgebricksException {
- IVariableTypeEnvironment env = createPropagatingAllInputsTypeEnvironment(ctx);
- Object t = env.getType(expression.getValue());
- env.setVarType(variables.get(0), t);
- if (positionalVariable != null) {
- env.setVarType(positionalVariable, positionalVariableType);
- }
- return env;
- }
-
- @Override
- public VariablePropagationPolicy getVariablePropagationPolicy() {
- return new VariablePropagationPolicy() {
-
- @Override
- public void propagateVariables(IOperatorSchema target, IOperatorSchema... sources)
- throws AlgebricksException {
- if (sources.length > 0) {
- target.addAllVariables(sources[0]);
- }
- for (LogicalVariable v : variables) {
- target.addVariable(v);
- }
- if (positionalVariable != null) {
- target.addVariable(positionalVariable);
- }
- }
- };
- }
-}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/incubator-asterixdb-hyracks/blob/9939b48e/algebricks/algebricks-core/src/main/java/edu/uci/ics/hyracks/algebricks/core/algebra/operators/logical/UpdateOperator.java
----------------------------------------------------------------------
diff --git a/algebricks/algebricks-core/src/main/java/edu/uci/ics/hyracks/algebricks/core/algebra/operators/logical/UpdateOperator.java b/algebricks/algebricks-core/src/main/java/edu/uci/ics/hyracks/algebricks/core/algebra/operators/logical/UpdateOperator.java
deleted file mode 100644
index 841f9c6..0000000
--- a/algebricks/algebricks-core/src/main/java/edu/uci/ics/hyracks/algebricks/core/algebra/operators/logical/UpdateOperator.java
+++ /dev/null
@@ -1,69 +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.core.algebra.operators.logical;
-
-import edu.uci.ics.hyracks.algebricks.common.exceptions.AlgebricksException;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.LogicalOperatorTag;
-import edu.uci.ics.hyracks.algebricks.core.algebra.expressions.IVariableTypeEnvironment;
-import edu.uci.ics.hyracks.algebricks.core.algebra.properties.VariablePropagationPolicy;
-import edu.uci.ics.hyracks.algebricks.core.algebra.typing.ITypingContext;
-import edu.uci.ics.hyracks.algebricks.core.algebra.visitors.ILogicalExpressionReferenceTransform;
-import edu.uci.ics.hyracks.algebricks.core.algebra.visitors.ILogicalOperatorVisitor;
-
-public class UpdateOperator extends AbstractLogicalOperator {
-
- @Override
- public void recomputeSchema() throws AlgebricksException {
- // TODO Auto-generated method stub
-
- }
-
- @Override
- public boolean acceptExpressionTransform(ILogicalExpressionReferenceTransform transform) throws AlgebricksException {
- // TODO Auto-generated method stub
- return false;
- }
-
- @Override
- public <R, T> R accept(ILogicalOperatorVisitor<R, T> visitor, T arg) throws AlgebricksException {
- // TODO Auto-generated method stub
- return null;
- }
-
- @Override
- public boolean isMap() {
- // TODO Auto-generated method stub
- return false;
- }
-
- @Override
- public VariablePropagationPolicy getVariablePropagationPolicy() {
- // TODO Auto-generated method stub
- return null;
- }
-
- @Override
- public LogicalOperatorTag getOperatorTag() {
- // TODO Auto-generated method stub
- return null;
- }
-
- @Override
- public IVariableTypeEnvironment computeOutputTypeEnvironment(ITypingContext ctx) throws AlgebricksException {
- // TODO Auto-generated method stub
- return null;
- }
-
-}
http://git-wip-us.apache.org/repos/asf/incubator-asterixdb-hyracks/blob/9939b48e/algebricks/algebricks-core/src/main/java/edu/uci/ics/hyracks/algebricks/core/algebra/operators/logical/WriteOperator.java
----------------------------------------------------------------------
diff --git a/algebricks/algebricks-core/src/main/java/edu/uci/ics/hyracks/algebricks/core/algebra/operators/logical/WriteOperator.java b/algebricks/algebricks-core/src/main/java/edu/uci/ics/hyracks/algebricks/core/algebra/operators/logical/WriteOperator.java
deleted file mode 100644
index e1c1640..0000000
--- a/algebricks/algebricks-core/src/main/java/edu/uci/ics/hyracks/algebricks/core/algebra/operators/logical/WriteOperator.java
+++ /dev/null
@@ -1,93 +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.core.algebra.operators.logical;
-
-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.ILogicalExpression;
-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.IVariableTypeEnvironment;
-import edu.uci.ics.hyracks.algebricks.core.algebra.metadata.IDataSink;
-import edu.uci.ics.hyracks.algebricks.core.algebra.properties.VariablePropagationPolicy;
-import edu.uci.ics.hyracks.algebricks.core.algebra.typing.ITypingContext;
-import edu.uci.ics.hyracks.algebricks.core.algebra.visitors.ILogicalExpressionReferenceTransform;
-import edu.uci.ics.hyracks.algebricks.core.algebra.visitors.ILogicalOperatorVisitor;
-
-public class WriteOperator extends AbstractLogicalOperator {
- private List<Mutable<ILogicalExpression>> expressions;
- private IDataSink dataSink;
-
- public WriteOperator(List<Mutable<ILogicalExpression>> expressions, IDataSink dataSink) {
- this.expressions = expressions;
- this.dataSink = dataSink;
- }
-
- public List<Mutable<ILogicalExpression>> getExpressions() {
- return expressions;
- }
-
- public IDataSink getDataSink() {
- return dataSink;
- }
-
- @Override
- public LogicalOperatorTag getOperatorTag() {
- return LogicalOperatorTag.WRITE;
- }
-
- @Override
- public <R, T> R accept(ILogicalOperatorVisitor<R, T> visitor, T arg) throws AlgebricksException {
- return visitor.visitWriteOperator(this, arg);
- }
-
- @Override
- public boolean acceptExpressionTransform(ILogicalExpressionReferenceTransform visitor) throws AlgebricksException {
- boolean modif = false;
- for (int i = 0; i < expressions.size(); i++) {
- boolean b = visitor.transform(expressions.get(i));
- if (b) {
- modif = true;
- }
- }
- return modif;
- }
-
- @Override
- public VariablePropagationPolicy getVariablePropagationPolicy() {
- return VariablePropagationPolicy.ALL;
- }
-
- @Override
- public boolean isMap() {
- return false; // actually depends on the physical op.
- }
-
- @Override
- public void recomputeSchema() {
- schema = new ArrayList<LogicalVariable>();
- schema.addAll(inputs.get(0).getValue().getSchema());
- }
-
- @Override
- public IVariableTypeEnvironment computeOutputTypeEnvironment(ITypingContext ctx) throws AlgebricksException {
- return createPropagatingAllInputsTypeEnvironment(ctx);
- }
-
-}
http://git-wip-us.apache.org/repos/asf/incubator-asterixdb-hyracks/blob/9939b48e/algebricks/algebricks-core/src/main/java/edu/uci/ics/hyracks/algebricks/core/algebra/operators/logical/WriteResultOperator.java
----------------------------------------------------------------------
diff --git a/algebricks/algebricks-core/src/main/java/edu/uci/ics/hyracks/algebricks/core/algebra/operators/logical/WriteResultOperator.java b/algebricks/algebricks-core/src/main/java/edu/uci/ics/hyracks/algebricks/core/algebra/operators/logical/WriteResultOperator.java
deleted file mode 100644
index ba402bc..0000000
--- a/algebricks/algebricks-core/src/main/java/edu/uci/ics/hyracks/algebricks/core/algebra/operators/logical/WriteResultOperator.java
+++ /dev/null
@@ -1,109 +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.core.algebra.operators.logical;
-
-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.ILogicalExpression;
-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.IVariableTypeEnvironment;
-import edu.uci.ics.hyracks.algebricks.core.algebra.metadata.IDataSource;
-import edu.uci.ics.hyracks.algebricks.core.algebra.properties.VariablePropagationPolicy;
-import edu.uci.ics.hyracks.algebricks.core.algebra.typing.ITypingContext;
-import edu.uci.ics.hyracks.algebricks.core.algebra.visitors.ILogicalExpressionReferenceTransform;
-import edu.uci.ics.hyracks.algebricks.core.algebra.visitors.ILogicalOperatorVisitor;
-
-public class WriteResultOperator extends AbstractLogicalOperator {
-
- private IDataSource<?> dataSource;
- private Mutable<ILogicalExpression> payloadExpr;
- private List<Mutable<ILogicalExpression>> keyExprs;
- private List<Mutable<ILogicalExpression>> additionalFilteringExpressions;
-
- public WriteResultOperator(IDataSource<?> dataSource, Mutable<ILogicalExpression> payload,
- List<Mutable<ILogicalExpression>> keyExprs) {
- this.dataSource = dataSource;
- this.payloadExpr = payload;
- this.keyExprs = keyExprs;
- }
-
- public IDataSource<?> getDataSource() {
- return dataSource;
- }
-
- public Mutable<ILogicalExpression> getPayloadExpression() {
- return payloadExpr;
- }
-
- public List<Mutable<ILogicalExpression>> getKeyExpressions() {
- return keyExprs;
- }
-
- @Override
- public LogicalOperatorTag getOperatorTag() {
- return LogicalOperatorTag.WRITE_RESULT;
- }
-
- @Override
- public <R, T> R accept(ILogicalOperatorVisitor<R, T> visitor, T arg) throws AlgebricksException {
- return visitor.visitWriteResultOperator(this, arg);
- }
-
- @Override
- public boolean acceptExpressionTransform(ILogicalExpressionReferenceTransform visitor) throws AlgebricksException {
- boolean b = visitor.transform(payloadExpr);
- for (int i = 0; i < keyExprs.size(); i++) {
- if (visitor.transform(keyExprs.get(i))) {
- b = true;
- }
- }
- return b;
- }
-
- @Override
- public VariablePropagationPolicy getVariablePropagationPolicy() {
- return VariablePropagationPolicy.ALL;
- }
-
- @Override
- public boolean isMap() {
- return false;
- }
-
- @Override
- public void recomputeSchema() {
- schema = new ArrayList<LogicalVariable>();
- schema.addAll(inputs.get(0).getValue().getSchema());
- }
-
- @Override
- public IVariableTypeEnvironment computeOutputTypeEnvironment(ITypingContext ctx) throws AlgebricksException {
- return createPropagatingAllInputsTypeEnvironment(ctx);
- }
-
- public void setAdditionalFilteringExpressions(List<Mutable<ILogicalExpression>> additionalFilteringExpressions) {
- this.additionalFilteringExpressions = additionalFilteringExpressions;
- }
-
- public List<Mutable<ILogicalExpression>> getAdditionalFilteringExpressions() {
- return additionalFilteringExpressions;
- }
-
-}
http://git-wip-us.apache.org/repos/asf/incubator-asterixdb-hyracks/blob/9939b48e/algebricks/algebricks-core/src/main/java/edu/uci/ics/hyracks/algebricks/core/algebra/operators/logical/visitors/FDsAndEquivClassesVisitor.java
----------------------------------------------------------------------
diff --git a/algebricks/algebricks-core/src/main/java/edu/uci/ics/hyracks/algebricks/core/algebra/operators/logical/visitors/FDsAndEquivClassesVisitor.java b/algebricks/algebricks-core/src/main/java/edu/uci/ics/hyracks/algebricks/core/algebra/operators/logical/visitors/FDsAndEquivClassesVisitor.java
deleted file mode 100644
index 1d7f134..0000000
--- a/algebricks/algebricks-core/src/main/java/edu/uci/ics/hyracks/algebricks/core/algebra/operators/logical/visitors/FDsAndEquivClassesVisitor.java
+++ /dev/null
@@ -1,763 +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.core.algebra.operators.logical.visitors;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-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.exceptions.NotImplementedException;
-import edu.uci.ics.hyracks.algebricks.common.utils.Pair;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.EquivalenceClass;
-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.AbstractFunctionCallExpression.FunctionKind;
-import edu.uci.ics.hyracks.algebricks.core.algebra.expressions.UnnestingFunctionCallExpression;
-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.AbstractUnnestOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.AggregateOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.AssignOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.DataSourceScanOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.DistinctOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.DistributeResultOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.EmptyTupleSourceOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.ExchangeOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.ExtensionOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.ExternalDataLookupOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.GroupByOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.IndexInsertDeleteOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.InnerJoinOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.InsertDeleteOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.LeftOuterJoinOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.LimitOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.MaterializeOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.NestedTupleSourceOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.OrderOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.PartitioningSplitOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.ProjectOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.ReplicateOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.RunningAggregateOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.ScriptOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.SelectOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.SinkOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.SubplanOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.TokenizeOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.UnionAllOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.UnnestMapOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.UnnestOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.WriteOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.WriteResultOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.properties.FunctionalDependency;
-import edu.uci.ics.hyracks.algebricks.core.algebra.properties.LocalGroupingProperty;
-import edu.uci.ics.hyracks.algebricks.core.algebra.visitors.ILogicalOperatorVisitor;
-import edu.uci.ics.hyracks.algebricks.core.config.AlgebricksConfig;
-
-public class FDsAndEquivClassesVisitor implements ILogicalOperatorVisitor<Void, IOptimizationContext> {
-
- @Override
- public Void visitAggregateOperator(AggregateOperator op, IOptimizationContext ctx) throws AlgebricksException {
- ctx.putEquivalenceClassMap(op, new HashMap<LogicalVariable, EquivalenceClass>());
- ctx.putFDList(op, new ArrayList<FunctionalDependency>());
- return null;
- }
-
- @Override
- public Void visitAssignOperator(AssignOperator op, IOptimizationContext ctx) throws AlgebricksException {
- ILogicalOperator inp1 = op.getInputs().get(0).getValue();
- Map<LogicalVariable, EquivalenceClass> eqClasses = getOrComputeEqClasses(inp1, ctx);
- ctx.putEquivalenceClassMap(op, eqClasses);
-
- // Propagates equivalence classes that from expressions.
- // Note that an equivalence class can also contain expression members.
- propagateEquivalenceFromExpressionsToVariables(eqClasses, op.getExpressions(), op.getVariables());
-
- // Generates FDs.
- List<LogicalVariable> used = new ArrayList<LogicalVariable>();
- VariableUtilities.getUsedVariables(op, used);
- List<FunctionalDependency> fds1 = getOrComputeFDs(inp1, ctx);
- List<FunctionalDependency> eFds = new ArrayList<FunctionalDependency>(fds1.size());
- for (FunctionalDependency fd : fds1) {
- if (fd.getTail().containsAll(used)) {
- List<LogicalVariable> hd = new ArrayList<LogicalVariable>(fd.getHead());
- List<LogicalVariable> tl = new ArrayList<LogicalVariable>(fd.getTail());
- tl.addAll(op.getVariables());
- FunctionalDependency fd2 = new FunctionalDependency(hd, tl);
- eFds.add(fd2);
- } else {
- eFds.add(fd);
- }
- }
- ctx.putFDList(op, eFds);
- return null;
- }
-
- @Override
- public Void visitDataScanOperator(DataSourceScanOperator op, IOptimizationContext ctx) throws AlgebricksException {
- ILogicalOperator inp1 = op.getInputs().get(0).getValue();
- Map<LogicalVariable, EquivalenceClass> eqClasses = getOrCreateEqClasses(op, ctx);
- Map<LogicalVariable, EquivalenceClass> propagatedEqClasses = getOrComputeEqClasses(inp1, ctx);
- eqClasses.putAll(propagatedEqClasses);
- ctx.putEquivalenceClassMap(op, eqClasses);
- List<FunctionalDependency> fds = new ArrayList<FunctionalDependency>(getOrComputeFDs(inp1, ctx));
- ctx.putFDList(op, fds);
- op.getDataSource().computeFDs(op.getVariables(), fds);
- return null;
- }
-
- @Override
- public Void visitDistinctOperator(DistinctOperator op, IOptimizationContext ctx) throws AlgebricksException {
- ILogicalOperator op0 = op.getInputs().get(0).getValue();
- List<FunctionalDependency> functionalDependencies = new ArrayList<FunctionalDependency>();
- ctx.putFDList(op, functionalDependencies);
- for (FunctionalDependency inherited : getOrComputeFDs(op0, ctx)) {
- boolean isCoveredByDistinctByVars = true;
- for (LogicalVariable v : inherited.getHead()) {
- if (!op.isDistinctByVar(v)) {
- isCoveredByDistinctByVars = false;
- }
- }
- if (isCoveredByDistinctByVars) {
- List<LogicalVariable> newTail = new ArrayList<LogicalVariable>();
- for (LogicalVariable v2 : inherited.getTail()) {
- if (op.isDistinctByVar(v2)) {
- newTail.add(v2);
- }
- }
- if (!newTail.isEmpty()) {
- List<LogicalVariable> newHead = new ArrayList<LogicalVariable>(inherited.getHead());
- FunctionalDependency newFd = new FunctionalDependency(newHead, newTail);
- functionalDependencies.add(newFd);
- }
- }
- }
- Set<LogicalVariable> gbySet = new HashSet<LogicalVariable>();
- List<Mutable<ILogicalExpression>> expressions = op.getExpressions();
- for (Mutable<ILogicalExpression> pRef : expressions) {
- ILogicalExpression p = pRef.getValue();
- if (p.getExpressionTag() == LogicalExpressionTag.VARIABLE) {
- VariableReferenceExpression v = (VariableReferenceExpression) p;
- gbySet.add(v.getVariableReference());
- }
- }
- LocalGroupingProperty lgp = new LocalGroupingProperty(gbySet);
-
- Map<LogicalVariable, EquivalenceClass> equivalenceClasses = getOrComputeEqClasses(op0, ctx);
- ctx.putEquivalenceClassMap(op, equivalenceClasses);
-
- lgp.normalizeGroupingColumns(equivalenceClasses, functionalDependencies);
- Set<LogicalVariable> normSet = lgp.getColumnSet();
- List<Mutable<ILogicalExpression>> newDistinctByList = new ArrayList<Mutable<ILogicalExpression>>();
- for (Mutable<ILogicalExpression> p2Ref : expressions) {
- ILogicalExpression p2 = p2Ref.getValue();
- if (p2.getExpressionTag() == LogicalExpressionTag.VARIABLE) {
- VariableReferenceExpression var2 = (VariableReferenceExpression) p2;
- LogicalVariable v2 = var2.getVariableReference();
- if (normSet.contains(v2)) {
- newDistinctByList.add(p2Ref);
- }
- } else {
- newDistinctByList.add(p2Ref);
- }
- }
- expressions.clear();
- expressions.addAll(newDistinctByList);
- return null;
- }
-
- @Override
- public Void visitEmptyTupleSourceOperator(EmptyTupleSourceOperator op, IOptimizationContext ctx)
- throws AlgebricksException {
- ctx.putEquivalenceClassMap(op, new HashMap<LogicalVariable, EquivalenceClass>());
- ctx.putFDList(op, new ArrayList<FunctionalDependency>());
- return null;
- }
-
- @Override
- public Void visitExchangeOperator(ExchangeOperator op, IOptimizationContext ctx) throws AlgebricksException {
- propagateFDsAndEquivClasses(op, ctx);
- return null;
- }
-
- @Override
- public Void visitGroupByOperator(GroupByOperator op, IOptimizationContext ctx) throws AlgebricksException {
- Map<LogicalVariable, EquivalenceClass> equivalenceClasses = new HashMap<LogicalVariable, EquivalenceClass>();
- List<FunctionalDependency> functionalDependencies = new ArrayList<FunctionalDependency>();
- ctx.putEquivalenceClassMap(op, equivalenceClasses);
- ctx.putFDList(op, functionalDependencies);
-
- List<FunctionalDependency> inheritedFDs = new ArrayList<FunctionalDependency>();
- for (ILogicalPlan p : op.getNestedPlans()) {
- for (Mutable<ILogicalOperator> r : p.getRoots()) {
- ILogicalOperator op2 = r.getValue();
- equivalenceClasses.putAll(getOrComputeEqClasses(op2, ctx));
- inheritedFDs.addAll(getOrComputeFDs(op2, ctx));
- }
- }
-
- ILogicalOperator op0 = op.getInputs().get(0).getValue();
- inheritedFDs.addAll(getOrComputeFDs(op0, ctx));
- Map<LogicalVariable, EquivalenceClass> inheritedEcs = getOrComputeEqClasses(op0, ctx);
- for (FunctionalDependency inherited : inheritedFDs) {
- boolean isCoveredByGbyOrDecorVars = true;
- List<LogicalVariable> newHead = new ArrayList<LogicalVariable>(inherited.getHead().size());
- for (LogicalVariable v : inherited.getHead()) {
- LogicalVariable vnew = getNewGbyVar(op, v);
- if (vnew == null) {
- vnew = getNewDecorVar(op, v);
- if (vnew == null) {
- isCoveredByGbyOrDecorVars = false;
- }
- break;
- }
- newHead.add(vnew);
- }
-
- if (isCoveredByGbyOrDecorVars) {
- List<LogicalVariable> newTail = new ArrayList<LogicalVariable>();
- for (LogicalVariable v2 : inherited.getTail()) {
- LogicalVariable v3 = getNewGbyVar(op, v2);
- if (v3 != null) {
- newTail.add(v3);
- }
- }
- if (!newTail.isEmpty()) {
- FunctionalDependency newFd = new FunctionalDependency(newHead, newTail);
- functionalDependencies.add(newFd);
- }
- }
- }
-
- List<LogicalVariable> premiseGby = new LinkedList<LogicalVariable>();
- List<Pair<LogicalVariable, Mutable<ILogicalExpression>>> gByList = op.getGroupByList();
- for (Pair<LogicalVariable, Mutable<ILogicalExpression>> p : gByList) {
- premiseGby.add(p.first);
- }
-
- List<Pair<LogicalVariable, Mutable<ILogicalExpression>>> decorList = op.getDecorList();
-
- LinkedList<LogicalVariable> conclDecor = new LinkedList<LogicalVariable>();
- for (Pair<LogicalVariable, Mutable<ILogicalExpression>> p : decorList) {
- conclDecor.add(GroupByOperator.getDecorVariable(p));
- }
- if (!conclDecor.isEmpty()) {
- functionalDependencies.add(new FunctionalDependency(premiseGby, conclDecor));
- }
-
- Set<LogicalVariable> gbySet = new HashSet<LogicalVariable>();
- for (Pair<LogicalVariable, Mutable<ILogicalExpression>> p : gByList) {
- ILogicalExpression expr = p.second.getValue();
- if (expr.getExpressionTag() == LogicalExpressionTag.VARIABLE) {
- VariableReferenceExpression v = (VariableReferenceExpression) expr;
- gbySet.add(v.getVariableReference());
- }
- }
- LocalGroupingProperty lgp = new LocalGroupingProperty(gbySet);
- lgp.normalizeGroupingColumns(inheritedEcs, inheritedFDs);
- Set<LogicalVariable> normSet = lgp.getColumnSet();
- List<Pair<LogicalVariable, Mutable<ILogicalExpression>>> newGbyList = new ArrayList<Pair<LogicalVariable, Mutable<ILogicalExpression>>>();
- boolean changed = false;
- for (Pair<LogicalVariable, Mutable<ILogicalExpression>> p : gByList) {
- ILogicalExpression expr = p.second.getValue();
- if (expr.getExpressionTag() == LogicalExpressionTag.VARIABLE) {
- VariableReferenceExpression varRef = (VariableReferenceExpression) expr;
- LogicalVariable v2 = varRef.getVariableReference();
- EquivalenceClass ec2 = inheritedEcs.get(v2);
- LogicalVariable v3;
- if (ec2 != null && !ec2.representativeIsConst()) {
- v3 = ec2.getVariableRepresentative();
- } else {
- v3 = v2;
- }
- if (normSet.contains(v3)) {
- newGbyList.add(p);
- } else {
- changed = true;
- decorList.add(p);
- }
- } else {
- newGbyList.add(p);
- }
- }
- if (changed) {
- AlgebricksConfig.ALGEBRICKS_LOGGER.fine(">>>> Group-by list changed from "
- + GroupByOperator.veListToString(gByList) + " to " + GroupByOperator.veListToString(newGbyList)
- + ".\n");
- }
- gByList.clear();
- gByList.addAll(newGbyList);
- return null;
- }
-
- @Override
- public Void visitInnerJoinOperator(InnerJoinOperator op, IOptimizationContext ctx) throws AlgebricksException {
- Map<LogicalVariable, EquivalenceClass> equivalenceClasses = new HashMap<LogicalVariable, EquivalenceClass>();
- List<FunctionalDependency> functionalDependencies = new ArrayList<FunctionalDependency>();
- ctx.putEquivalenceClassMap(op, equivalenceClasses);
- ctx.putFDList(op, functionalDependencies);
- ILogicalOperator op0 = op.getInputs().get(0).getValue();
- ILogicalOperator op1 = op.getInputs().get(1).getValue();
- functionalDependencies.addAll(getOrComputeFDs(op0, ctx));
- functionalDependencies.addAll(getOrComputeFDs(op1, ctx));
- equivalenceClasses.putAll(getOrComputeEqClasses(op0, ctx));
- equivalenceClasses.putAll(getOrComputeEqClasses(op1, ctx));
- ILogicalExpression expr = op.getCondition().getValue();
- expr.getConstraintsAndEquivClasses(functionalDependencies, equivalenceClasses);
- return null;
- }
-
- @Override
- public Void visitLeftOuterJoinOperator(LeftOuterJoinOperator op, IOptimizationContext ctx)
- throws AlgebricksException {
- Map<LogicalVariable, EquivalenceClass> equivalenceClasses = new HashMap<LogicalVariable, EquivalenceClass>();
- List<FunctionalDependency> functionalDependencies = new ArrayList<FunctionalDependency>();
- ctx.putEquivalenceClassMap(op, equivalenceClasses);
- ctx.putFDList(op, functionalDependencies);
- ILogicalOperator opLeft = op.getInputs().get(0).getValue();
- ILogicalOperator opRight = op.getInputs().get(1).getValue();
- functionalDependencies.addAll(getOrComputeFDs(opLeft, ctx));
- functionalDependencies.addAll(getOrComputeFDs(opRight, ctx));
- equivalenceClasses.putAll(getOrComputeEqClasses(opLeft, ctx));
- equivalenceClasses.putAll(getOrComputeEqClasses(opRight, ctx));
-
- Collection<LogicalVariable> leftSideVars;
- if (opLeft.getSchema() == null) {
- leftSideVars = new LinkedList<LogicalVariable>();
- VariableUtilities.getLiveVariables(opLeft, leftSideVars);
- // actually, not all produced vars. are visible (due to projection)
- // so using cached schema is better and faster
- } else {
- leftSideVars = opLeft.getSchema();
- }
- ILogicalExpression expr = op.getCondition().getValue();
- expr.getConstraintsForOuterJoin(functionalDependencies, leftSideVars);
- return null;
- }
-
- @Override
- public Void visitLimitOperator(LimitOperator op, IOptimizationContext ctx) throws AlgebricksException {
- propagateFDsAndEquivClasses(op, ctx);
- return null;
- }
-
- @Override
- public Void visitNestedTupleSourceOperator(NestedTupleSourceOperator op, IOptimizationContext ctx)
- throws AlgebricksException {
- AbstractLogicalOperator op1 = (AbstractLogicalOperator) op.getDataSourceReference().getValue();
- ILogicalOperator inp1 = op1.getInputs().get(0).getValue();
- Map<LogicalVariable, EquivalenceClass> eqClasses = getOrComputeEqClasses(inp1, ctx);
- ctx.putEquivalenceClassMap(op, eqClasses);
- List<FunctionalDependency> fds = new ArrayList<FunctionalDependency>(getOrComputeFDs(inp1, ctx));
- if (op1.getOperatorTag() == LogicalOperatorTag.GROUP) {
- GroupByOperator gby = (GroupByOperator) op1;
- LinkedList<LogicalVariable> tail = new LinkedList<LogicalVariable>();
- for (LogicalVariable v : gby.getGbyVarList()) {
- tail.add(v);
- // all values for gby vars. are the same
- }
- FunctionalDependency gbyfd = new FunctionalDependency(new LinkedList<LogicalVariable>(), tail);
- fds.add(gbyfd);
- }
- ctx.putFDList(op, fds);
- return null;
- }
-
- @Override
- public Void visitOrderOperator(OrderOperator op, IOptimizationContext ctx) throws AlgebricksException {
- propagateFDsAndEquivClasses(op, ctx);
- return null;
- }
-
- @Override
- public Void visitPartitioningSplitOperator(PartitioningSplitOperator op, IOptimizationContext ctx)
- throws AlgebricksException {
- throw new NotImplementedException();
- }
-
- @Override
- public Void visitProjectOperator(ProjectOperator op, IOptimizationContext ctx) throws AlgebricksException {
- propagateFDsAndEquivClassesForUsedVars(op, ctx, op.getVariables());
- return null;
- }
-
- @Override
- public Void visitReplicateOperator(ReplicateOperator op, IOptimizationContext ctx) throws AlgebricksException {
- propagateFDsAndEquivClasses(op, ctx);
- return null;
- }
-
- @Override
- public Void visitMaterializeOperator(MaterializeOperator op, IOptimizationContext ctx) throws AlgebricksException {
- propagateFDsAndEquivClasses(op, ctx);
- return null;
- }
-
- @Override
- public Void visitRunningAggregateOperator(RunningAggregateOperator op, IOptimizationContext ctx)
- throws AlgebricksException {
- ctx.putEquivalenceClassMap(op, new HashMap<LogicalVariable, EquivalenceClass>());
- ctx.putFDList(op, new ArrayList<FunctionalDependency>());
- return null;
- }
-
- @Override
- public Void visitScriptOperator(ScriptOperator op, IOptimizationContext ctx) throws AlgebricksException {
- propagateFDsAndEquivClassesForUsedVars(op, ctx, op.getInputVariables());
- return null;
- }
-
- @Override
- public Void visitSelectOperator(SelectOperator op, IOptimizationContext ctx) throws AlgebricksException {
- ILogicalOperator childOp = op.getInputs().get(0).getValue();
- Map<LogicalVariable, EquivalenceClass> equivalenceClasses = getOrComputeEqClasses(childOp, ctx);
- ctx.putEquivalenceClassMap(op, equivalenceClasses);
-
- List<FunctionalDependency> functionalDependencies = new ArrayList<FunctionalDependency>();
- ctx.putFDList(op, functionalDependencies);
- functionalDependencies.addAll(getOrComputeFDs(childOp, ctx));
- equivalenceClasses.putAll(getOrComputeEqClasses(childOp, ctx));
- ILogicalExpression expr = op.getCondition().getValue();
- expr.getConstraintsAndEquivClasses(functionalDependencies, equivalenceClasses);
- return null;
- }
-
- @Override
- public Void visitSubplanOperator(SubplanOperator op, IOptimizationContext ctx) throws AlgebricksException {
- Map<LogicalVariable, EquivalenceClass> equivalenceClasses = new HashMap<LogicalVariable, EquivalenceClass>();
- List<FunctionalDependency> functionalDependencies = new ArrayList<FunctionalDependency>();
- ctx.putEquivalenceClassMap(op, equivalenceClasses);
- ctx.putFDList(op, functionalDependencies);
- for (ILogicalPlan p : op.getNestedPlans()) {
- for (Mutable<ILogicalOperator> r : p.getRoots()) {
- ILogicalOperator op2 = r.getValue();
- equivalenceClasses.putAll(getOrComputeEqClasses(op2, ctx));
- functionalDependencies.addAll(getOrComputeFDs(op2, ctx));
- }
- }
- return null;
- }
-
- @Override
- public Void visitUnionOperator(UnionAllOperator op, IOptimizationContext ctx) throws AlgebricksException {
- setEmptyFDsEqClasses(op, ctx);
- return null;
- }
-
- @Override
- public Void visitUnnestMapOperator(UnnestMapOperator op, IOptimizationContext ctx) throws AlgebricksException {
- fdsEqClassesForAbstractUnnestOperator(op, ctx);
- return null;
- }
-
- @Override
- public Void visitUnnestOperator(UnnestOperator op, IOptimizationContext ctx) throws AlgebricksException {
- fdsEqClassesForAbstractUnnestOperator(op, ctx);
- return null;
- }
-
- @Override
- public Void visitWriteOperator(WriteOperator op, IOptimizationContext ctx) throws AlgebricksException {
- // propagateFDsAndEquivClasses(op, ctx);
- setEmptyFDsEqClasses(op, ctx);
- return null;
- }
-
- @Override
- public Void visitDistributeResultOperator(DistributeResultOperator op, IOptimizationContext ctx)
- throws AlgebricksException {
- // propagateFDsAndEquivClasses(op, ctx);
- setEmptyFDsEqClasses(op, ctx);
- return null;
- }
-
- @Override
- public Void visitWriteResultOperator(WriteResultOperator op, IOptimizationContext ctx) throws AlgebricksException {
- // propagateFDsAndEquivClasses(op, ctx);
- setEmptyFDsEqClasses(op, ctx);
- return null;
- }
-
- @Override
- public Void visitInsertDeleteOperator(InsertDeleteOperator op, IOptimizationContext ctx) throws AlgebricksException {
- propagateFDsAndEquivClasses(op, ctx);
- return null;
- }
-
- @Override
- public Void visitIndexInsertDeleteOperator(IndexInsertDeleteOperator op, IOptimizationContext ctx)
- throws AlgebricksException {
- propagateFDsAndEquivClasses(op, ctx);
- return null;
- }
-
- @Override
- public Void visitTokenizeOperator(TokenizeOperator op, IOptimizationContext ctx) throws AlgebricksException {
- setEmptyFDsEqClasses(op, ctx);
- return null;
- }
-
- @Override
- public Void visitSinkOperator(SinkOperator op, IOptimizationContext ctx) throws AlgebricksException {
- setEmptyFDsEqClasses(op, ctx);
- return null;
- }
-
- private void propagateFDsAndEquivClasses(ILogicalOperator op, IOptimizationContext ctx) throws AlgebricksException {
- ILogicalOperator inp1 = op.getInputs().get(0).getValue();
- Map<LogicalVariable, EquivalenceClass> eqClasses = getOrComputeEqClasses(inp1, ctx);
- ctx.putEquivalenceClassMap(op, eqClasses);
- List<FunctionalDependency> fds = getOrComputeFDs(inp1, ctx);
- ctx.putFDList(op, fds);
- }
-
- private Map<LogicalVariable, EquivalenceClass> getOrComputeEqClasses(ILogicalOperator op, IOptimizationContext ctx)
- throws AlgebricksException {
- Map<LogicalVariable, EquivalenceClass> eqClasses = ctx.getEquivalenceClassMap(op);
- if (eqClasses == null) {
- op.accept(this, ctx);
- eqClasses = ctx.getEquivalenceClassMap(op);
- }
- return eqClasses;
- }
-
- private Map<LogicalVariable, EquivalenceClass> getOrCreateEqClasses(ILogicalOperator op, IOptimizationContext ctx)
- throws AlgebricksException {
- Map<LogicalVariable, EquivalenceClass> eqClasses = ctx.getEquivalenceClassMap(op);
- if (eqClasses == null) {
- eqClasses = new HashMap<LogicalVariable, EquivalenceClass>();
- ctx.putEquivalenceClassMap(op, eqClasses);
- }
- return eqClasses;
- }
-
- private List<FunctionalDependency> getOrComputeFDs(ILogicalOperator op, IOptimizationContext ctx)
- throws AlgebricksException {
- List<FunctionalDependency> fds = ctx.getFDList(op);
- if (fds == null) {
- op.accept(this, ctx);
- fds = ctx.getFDList(op);
- }
- return fds;
- }
-
- /***
- * Propagated equivalent classes from the child to the current operator, based
- * on the used variables of the current operator.
- *
- * @param op
- * , the current operator
- * @param ctx
- * , the optimization context which keeps track of all equivalent classes.
- * @param usedVariables
- * , used variables.
- * @throws AlgebricksException
- */
- private void propagateFDsAndEquivClassesForUsedVars(ILogicalOperator op, IOptimizationContext ctx,
- List<LogicalVariable> usedVariables) throws AlgebricksException {
- ILogicalOperator op2 = op.getInputs().get(0).getValue();
- Map<LogicalVariable, EquivalenceClass> eqClasses = getOrCreateEqClasses(op, ctx);
- List<FunctionalDependency> fds = new ArrayList<FunctionalDependency>();
- ctx.putFDList(op, fds);
-
- Map<LogicalVariable, EquivalenceClass> chldClasses = getOrComputeEqClasses(op2, ctx);
-
- // Propagate equivalent classes that contain the used variables.
- for (LogicalVariable v : usedVariables) {
- EquivalenceClass ec = eqClasses.get(v);
- if (ec == null) {
- EquivalenceClass oc = chldClasses.get(v);
- if (oc == null) {
- continue;
- }
- List<LogicalVariable> m = new LinkedList<LogicalVariable>();
- for (LogicalVariable v2 : oc.getMembers()) {
- if (usedVariables.contains(v2)) {
- m.add(v2);
- }
- }
- EquivalenceClass nc;
- if (oc.representativeIsConst()) {
- nc = new EquivalenceClass(m, oc.getConstRepresentative());
- } else if (m.contains(oc.getVariableRepresentative())) {
- nc = new EquivalenceClass(m, oc.getVariableRepresentative());
- } else {
- nc = new EquivalenceClass(m, v);
- }
- for (LogicalVariable v3 : m) {
- eqClasses.put(v3, nc);
- }
- }
- }
-
- // Propagates equivalent classes that contain expressions that use the used variables.
- // Note that for the case variable $v is not in the used variables but it is
- // equivalent to field-access($t, i) and $t is a used variable, the equivalent
- // class should still be propagated (kept).
- Set<LogicalVariable> usedVarSet = new HashSet<LogicalVariable>(usedVariables);
- for (Entry<LogicalVariable, EquivalenceClass> entry : chldClasses.entrySet()) {
- EquivalenceClass ec = entry.getValue();
- for (ILogicalExpression expr : ec.getExpressionMembers()) {
- Set<LogicalVariable> exprUsedVars = new HashSet<LogicalVariable>();
- expr.getUsedVariables(exprUsedVars);
- exprUsedVars.retainAll(usedVarSet);
- // Check if the expression member uses a used variable.
- if (!exprUsedVars.isEmpty()) {
- for (LogicalVariable v : ec.getMembers()) {
- eqClasses.put(v, ec);
- // If variable members contain a used variable, the representative
- // variable should be a used variable.
- if (usedVarSet.contains(v)) {
- ec.setVariableRepresentative(v);
- }
- }
- }
- }
- }
-
- List<FunctionalDependency> chldFds = getOrComputeFDs(op2, ctx);
- for (FunctionalDependency fd : chldFds) {
- if (!usedVariables.containsAll(fd.getHead())) {
- continue;
- }
- List<LogicalVariable> tl = new LinkedList<LogicalVariable>();
- for (LogicalVariable v : fd.getTail()) {
- if (usedVariables.contains(v)) {
- tl.add(v);
- }
- }
- if (!tl.isEmpty()) {
- FunctionalDependency newFd = new FunctionalDependency(fd.getHead(), tl);
- fds.add(newFd);
- }
- }
- }
-
- private void fdsEqClassesForAbstractUnnestOperator(AbstractUnnestOperator op, IOptimizationContext ctx)
- throws AlgebricksException {
- ILogicalOperator inp1 = op.getInputs().get(0).getValue();
- Map<LogicalVariable, EquivalenceClass> eqClasses = getOrCreateEqClasses(op, ctx);
- Map<LogicalVariable, EquivalenceClass> propagatedEqClasses = getOrComputeEqClasses(inp1, ctx);
- /**
- * The original eq classes of unnest-map are only for produced variables, therefore
- * eqClasses and propagatedEqClasses do not have overlaps.
- */
- eqClasses.putAll(propagatedEqClasses);
- ctx.putEquivalenceClassMap(op, eqClasses);
- List<FunctionalDependency> fds = getOrComputeFDs(inp1, ctx);
- ctx.putFDList(op, fds);
-
- ILogicalExpression expr = op.getExpressionRef().getValue();
- if (expr.getExpressionTag() == LogicalExpressionTag.FUNCTION_CALL) {
- AbstractFunctionCallExpression afe = (AbstractFunctionCallExpression) expr;
- if (afe.getKind() == FunctionKind.UNNEST && ((UnnestingFunctionCallExpression) afe).returnsUniqueValues()) {
- List<LogicalVariable> vars = new ArrayList<LogicalVariable>();
- VariableUtilities.getLiveVariables(op, vars);
- ArrayList<LogicalVariable> h = new ArrayList<LogicalVariable>();
- h.addAll(op.getVariables());
- FunctionalDependency fd = new FunctionalDependency(h, vars);
- fds.add(fd);
- }
- }
- }
-
- public static void setEmptyFDsEqClasses(ILogicalOperator op, IOptimizationContext ctx) {
- Map<LogicalVariable, EquivalenceClass> eqClasses = new HashMap<LogicalVariable, EquivalenceClass>();
- ctx.putEquivalenceClassMap(op, eqClasses);
- List<FunctionalDependency> fds = new ArrayList<FunctionalDependency>();
- ctx.putFDList(op, fds);
- }
-
- private LogicalVariable getNewGbyVar(GroupByOperator g, LogicalVariable v) {
- for (Pair<LogicalVariable, Mutable<ILogicalExpression>> p : g.getGroupByList()) {
- ILogicalExpression e = p.second.getValue();
- if (e.getExpressionTag() == LogicalExpressionTag.VARIABLE) {
- LogicalVariable v2 = ((VariableReferenceExpression) e).getVariableReference();
- if (v2 == v) {
- return p.first;
- }
- }
- }
- return null;
- }
-
- private LogicalVariable getNewDecorVar(GroupByOperator g, LogicalVariable v) {
- for (Pair<LogicalVariable, Mutable<ILogicalExpression>> p : g.getDecorList()) {
- ILogicalExpression e = p.second.getValue();
- if (e.getExpressionTag() == LogicalExpressionTag.VARIABLE) {
- LogicalVariable v2 = ((VariableReferenceExpression) e).getVariableReference();
- if (v2 == v) {
- return (p.first != null) ? p.first : v2;
- }
- }
- }
- return null;
- }
-
- @Override
- public Void visitExtensionOperator(ExtensionOperator op, IOptimizationContext ctx) throws AlgebricksException {
- propagateFDsAndEquivClasses(op, ctx);
- return null;
- }
-
- @Override
- public Void visitExternalDataLookupOperator(ExternalDataLookupOperator op, IOptimizationContext ctx)
- throws AlgebricksException {
- propagateFDsAndEquivClasses(op, ctx);
- return null;
- }
-
- /**
- * Propagate equivalences that carried in expressions to the variables that
- * they are assigned to.
- *
- * @param eqClasses
- * an equivalent class map
- * @param assignExprs
- * expressions on the right-hand-side of assignments
- * @param assignVars
- * variables on the left-hand-side of assignments
- */
- private void propagateEquivalenceFromExpressionsToVariables(Map<LogicalVariable, EquivalenceClass> eqClasses,
- List<Mutable<ILogicalExpression>> assignExprs, List<LogicalVariable> assignVars) {
- for (int assignVarIndex = 0; assignVarIndex < assignVars.size(); ++assignVarIndex) {
- LogicalVariable var = assignVars.get(assignVarIndex);
- ILogicalExpression expr = assignExprs.get(assignVarIndex).getValue();
- for (Entry<LogicalVariable, EquivalenceClass> entry : eqClasses.entrySet()) {
- EquivalenceClass eqc = entry.getValue();
- // If the equivalence class contains the right-hand-side expression,
- // the left-hand-side variable is added into the equivalence class.
- if (eqc.contains(expr)) {
- eqc.addMember(var);
- }
- }
- }
- }
-
-}
\ No newline at end of file