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:44:36 UTC
[48/51] [partial] incubator-asterixdb git commit: Change folder
structure for Java repackage
http://git-wip-us.apache.org/repos/asf/incubator-asterixdb/blob/34d81630/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/AsterixInlineVariablesRule.java
----------------------------------------------------------------------
diff --git a/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/AsterixInlineVariablesRule.java b/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/AsterixInlineVariablesRule.java
deleted file mode 100644
index 296bbb2..0000000
--- a/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/AsterixInlineVariablesRule.java
+++ /dev/null
@@ -1,38 +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.asterix.optimizer.rules;
-
-import edu.uci.ics.asterix.om.functions.AsterixBuiltinFunctions;
-import edu.uci.ics.hyracks.algebricks.rewriter.rules.InlineVariablesRule;
-
-public class AsterixInlineVariablesRule extends InlineVariablesRule {
-
- public AsterixInlineVariablesRule() {
- // Do not inline field accesses and spatial functions because doing so would interfere with our access method rewrites.
- // TODO: For now we must also exclude record constructor functions to avoid breaking our type casting rules
- // IntroduceStaticTypeCastRule and IntroduceDynamicTypeCastRule.
- doNotInlineFuncs.add(AsterixBuiltinFunctions.FIELD_ACCESS_BY_NAME);
- doNotInlineFuncs.add(AsterixBuiltinFunctions.FIELD_ACCESS_BY_INDEX);
- doNotInlineFuncs.add(AsterixBuiltinFunctions.CLOSED_RECORD_CONSTRUCTOR);
- doNotInlineFuncs.add(AsterixBuiltinFunctions.OPEN_RECORD_CONSTRUCTOR);
- doNotInlineFuncs.add(AsterixBuiltinFunctions.CAST_RECORD);
- doNotInlineFuncs.add(AsterixBuiltinFunctions.CREATE_CIRCLE);
- doNotInlineFuncs.add(AsterixBuiltinFunctions.CREATE_LINE);
- doNotInlineFuncs.add(AsterixBuiltinFunctions.CREATE_MBR);
- doNotInlineFuncs.add(AsterixBuiltinFunctions.CREATE_POINT);
- doNotInlineFuncs.add(AsterixBuiltinFunctions.CREATE_POLYGON);
- doNotInlineFuncs.add(AsterixBuiltinFunctions.CREATE_RECTANGLE);
- }
-}
http://git-wip-us.apache.org/repos/asf/incubator-asterixdb/blob/34d81630/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/AsterixIntroduceGroupByCombinerRule.java
----------------------------------------------------------------------
diff --git a/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/AsterixIntroduceGroupByCombinerRule.java b/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/AsterixIntroduceGroupByCombinerRule.java
deleted file mode 100644
index b71ffab..0000000
--- a/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/AsterixIntroduceGroupByCombinerRule.java
+++ /dev/null
@@ -1,74 +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.asterix.optimizer.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.asterix.om.functions.AsterixBuiltinFunctions;
-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.LogicalVariable;
-import edu.uci.ics.hyracks.algebricks.core.algebra.expressions.ScalarFunctionCallExpression;
-import edu.uci.ics.hyracks.algebricks.core.algebra.expressions.VariableReferenceExpression;
-import edu.uci.ics.hyracks.algebricks.core.algebra.functions.AlgebricksBuiltinFunctions;
-import edu.uci.ics.hyracks.algebricks.core.algebra.functions.IFunctionInfo;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.GroupByOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.SelectOperator;
-import edu.uci.ics.hyracks.algebricks.rewriter.rules.AbstractIntroduceGroupByCombinerRule;
-
-public class AsterixIntroduceGroupByCombinerRule extends AbstractIntroduceGroupByCombinerRule {
-
- @SuppressWarnings("unchecked")
- @Override
- protected void processNullTest(IOptimizationContext context, GroupByOperator nestedGby,
- List<LogicalVariable> aggregateVarsProducedByCombiner) {
- IFunctionInfo finfoEq = context.getMetadataProvider().lookupFunction(AsterixBuiltinFunctions.IS_SYSTEM_NULL);
- SelectOperator selectNonSystemNull;
-
- if (aggregateVarsProducedByCombiner.size() == 1) {
- ILogicalExpression isSystemNullTest = new ScalarFunctionCallExpression(finfoEq,
- new MutableObject<ILogicalExpression>(new VariableReferenceExpression(
- aggregateVarsProducedByCombiner.get(0))));
- IFunctionInfo finfoNot = context.getMetadataProvider().lookupFunction(AlgebricksBuiltinFunctions.NOT);
- ScalarFunctionCallExpression nonSystemNullTest = new ScalarFunctionCallExpression(finfoNot,
- new MutableObject<ILogicalExpression>(isSystemNullTest));
- selectNonSystemNull = new SelectOperator(new MutableObject<ILogicalExpression>(nonSystemNullTest), false,
- null);
- } else {
- List<Mutable<ILogicalExpression>> isSystemNullTestList = new ArrayList<Mutable<ILogicalExpression>>();
- for (LogicalVariable aggVar : aggregateVarsProducedByCombiner) {
- ILogicalExpression isSystemNullTest = new ScalarFunctionCallExpression(finfoEq,
- new MutableObject<ILogicalExpression>(new VariableReferenceExpression(aggVar)));
- IFunctionInfo finfoNot = context.getMetadataProvider().lookupFunction(AlgebricksBuiltinFunctions.NOT);
- ScalarFunctionCallExpression nonSystemNullTest = new ScalarFunctionCallExpression(finfoNot,
- new MutableObject<ILogicalExpression>(isSystemNullTest));
- isSystemNullTestList.add(new MutableObject<ILogicalExpression>(nonSystemNullTest));
- }
- IFunctionInfo finfoAnd = context.getMetadataProvider().lookupFunction(AlgebricksBuiltinFunctions.AND);
- selectNonSystemNull = new SelectOperator(new MutableObject<ILogicalExpression>(
- new ScalarFunctionCallExpression(finfoAnd, isSystemNullTestList)), false, null);
- }
-
- //add the not-system-null check into the nested pipeline
- Mutable<ILogicalOperator> ntsBeforeNestedGby = nestedGby.getInputs().get(0);
- nestedGby.getInputs().set(0, new MutableObject<ILogicalOperator>(selectNonSystemNull));
- selectNonSystemNull.getInputs().add(ntsBeforeNestedGby);
- }
-}
http://git-wip-us.apache.org/repos/asf/incubator-asterixdb/blob/34d81630/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/AsterixMoveFreeVariableOperatorOutOfSubplanRule.java
----------------------------------------------------------------------
diff --git a/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/AsterixMoveFreeVariableOperatorOutOfSubplanRule.java b/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/AsterixMoveFreeVariableOperatorOutOfSubplanRule.java
deleted file mode 100644
index c42fa15..0000000
--- a/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/AsterixMoveFreeVariableOperatorOutOfSubplanRule.java
+++ /dev/null
@@ -1,26 +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.asterix.optimizer.rules;
-
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.LogicalOperatorTag;
-import edu.uci.ics.hyracks.algebricks.rewriter.rules.MoveFreeVariableOperatorOutOfSubplanRule;
-
-public class AsterixMoveFreeVariableOperatorOutOfSubplanRule extends MoveFreeVariableOperatorOutOfSubplanRule {
-
- @Override
- protected boolean movableOperator(LogicalOperatorTag operatorTag) {
- return (operatorTag == LogicalOperatorTag.ASSIGN);
- }
-}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/incubator-asterixdb/blob/34d81630/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/ByNameToByHandleFieldAccessRule.java
----------------------------------------------------------------------
diff --git a/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/ByNameToByHandleFieldAccessRule.java b/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/ByNameToByHandleFieldAccessRule.java
deleted file mode 100644
index 9c04564..0000000
--- a/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/ByNameToByHandleFieldAccessRule.java
+++ /dev/null
@@ -1,116 +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.asterix.optimizer.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.asterix.algebra.base.AsterixOperatorAnnotations;
-import edu.uci.ics.asterix.aql.util.FunctionUtils;
-import edu.uci.ics.asterix.om.functions.AsterixBuiltinFunctions;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.ILogicalExpression;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.ILogicalOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.IOptimizationContext;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.LogicalExpressionTag;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.LogicalOperatorTag;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.LogicalVariable;
-import edu.uci.ics.hyracks.algebricks.core.algebra.expressions.AbstractFunctionCallExpression;
-import edu.uci.ics.hyracks.algebricks.core.algebra.expressions.ScalarFunctionCallExpression;
-import edu.uci.ics.hyracks.algebricks.core.algebra.expressions.VariableReferenceExpression;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.AbstractLogicalOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.AssignOperator;
-import edu.uci.ics.hyracks.algebricks.core.rewriter.base.IAlgebraicRewriteRule;
-
-public class ByNameToByHandleFieldAccessRule implements IAlgebraicRewriteRule {
-
- @Override
- public boolean rewritePre(Mutable<ILogicalOperator> opRef, IOptimizationContext context) {
- return false;
- }
-
- @Override
- public boolean rewritePost(Mutable<ILogicalOperator> opRef, IOptimizationContext context) {
- AbstractLogicalOperator op = (AbstractLogicalOperator) opRef.getValue();
- if (op.getOperatorTag() != LogicalOperatorTag.ASSIGN) {
- return false;
- }
- AssignOperator assign = (AssignOperator) op;
- if (assign.getAnnotations().get(AsterixOperatorAnnotations.PUSHED_FIELD_ACCESS) == null) {
- return false;
- }
- byNameToByHandle(assign, context);
- return true;
- }
-
- private static void byNameToByHandle(AssignOperator fieldAccessOp, IOptimizationContext context) {
- Mutable<ILogicalOperator> opUnder = fieldAccessOp.getInputs().get(0);
- AbstractFunctionCallExpression fce = (AbstractFunctionCallExpression) fieldAccessOp.getExpressions().get(0)
- .getValue();
- ILogicalExpression a1 = fce.getArguments().get(0).getValue();
-
- VariableReferenceExpression x;
- if (a1.getExpressionTag() == LogicalExpressionTag.VARIABLE) {
- x = (VariableReferenceExpression) a1;
- } else {
- LogicalVariable var1 = context.newVar();
- ArrayList<LogicalVariable> varArray = new ArrayList<LogicalVariable>(1);
- varArray.add(var1);
- ArrayList<Mutable<ILogicalExpression>> exprArray = new ArrayList<Mutable<ILogicalExpression>>(1);
- exprArray.add(new MutableObject<ILogicalExpression>(a1));
- AssignOperator assignVar = new AssignOperator(varArray, exprArray);
- x = new VariableReferenceExpression(var1);
- assignVar.getInputs().add(opUnder);
- opUnder = new MutableObject<ILogicalOperator>(assignVar);
- }
-
- // let $t := type-of(x)
- LogicalVariable t = context.newVar();
-
- AbstractFunctionCallExpression typeOf = new ScalarFunctionCallExpression(
- FunctionUtils.getFunctionInfo(AsterixBuiltinFunctions.TYPE_OF));
- typeOf.getArguments().add(new MutableObject<ILogicalExpression>(x));
- AssignOperator typAssign = new AssignOperator(t, new MutableObject<ILogicalExpression>(typeOf));
- typAssign.getInputs().add(opUnder);
-
- // let $w := get-handle($t, path-expression)
- LogicalVariable w = context.newVar();
- AbstractFunctionCallExpression getHandle = new ScalarFunctionCallExpression(
- FunctionUtils.getFunctionInfo(AsterixBuiltinFunctions.GET_HANDLE));
- getHandle.getArguments().add(new MutableObject<ILogicalExpression>(new VariableReferenceExpression(t)));
- // the accessed field
- getHandle.getArguments().add(new MutableObject<ILogicalExpression>(fce.getArguments().get(1).getValue()));
- AssignOperator handleAssign = new AssignOperator(w, new MutableObject<ILogicalExpression>(getHandle));
- handleAssign.getInputs().add(new MutableObject<ILogicalOperator>(typAssign));
-
- // let $y := get-data(x, $w)
- AbstractFunctionCallExpression getData = new ScalarFunctionCallExpression(
- FunctionUtils.getFunctionInfo(AsterixBuiltinFunctions.GET_DATA));
- VariableReferenceExpression ref2 = new VariableReferenceExpression(x.getVariableReference());
- getData.getArguments().add(new MutableObject<ILogicalExpression>(ref2));
- getData.getArguments().add(new MutableObject<ILogicalExpression>(new VariableReferenceExpression(w)));
- fieldAccessOp.getExpressions().get(0).setValue(getData);
- List<Mutable<ILogicalOperator>> faInputs = fieldAccessOp.getInputs();
- faInputs.clear();
- faInputs.add(new MutableObject<ILogicalOperator>(handleAssign));
-
- // fieldAccess.setAnnotation(OperatorAnnotation.FIELD_ACCESS,
- // fce.getArguments().get(0));
- fieldAccessOp.removeAnnotation(AsterixOperatorAnnotations.PUSHED_FIELD_ACCESS);
- }
-
-}
http://git-wip-us.apache.org/repos/asf/incubator-asterixdb/blob/34d81630/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/ByNameToByIndexFieldAccessRule.java
----------------------------------------------------------------------
diff --git a/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/ByNameToByIndexFieldAccessRule.java b/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/ByNameToByIndexFieldAccessRule.java
deleted file mode 100644
index 0dee2be..0000000
--- a/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/ByNameToByIndexFieldAccessRule.java
+++ /dev/null
@@ -1,175 +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.asterix.optimizer.rules;
-
-import java.io.IOException;
-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.asterix.algebra.base.AsterixOperatorAnnotations;
-import edu.uci.ics.asterix.aql.util.FunctionUtils;
-import edu.uci.ics.asterix.om.base.AInt32;
-import edu.uci.ics.asterix.om.base.AString;
-import edu.uci.ics.asterix.om.base.IAObject;
-import edu.uci.ics.asterix.om.constants.AsterixConstantValue;
-import edu.uci.ics.asterix.om.functions.AsterixBuiltinFunctions;
-import edu.uci.ics.asterix.om.types.ARecordType;
-import edu.uci.ics.asterix.om.types.ATypeTag;
-import edu.uci.ics.asterix.om.types.AUnionType;
-import edu.uci.ics.asterix.om.types.IAType;
-import edu.uci.ics.hyracks.algebricks.common.exceptions.AlgebricksException;
-import edu.uci.ics.hyracks.algebricks.common.exceptions.NotImplementedException;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.ILogicalExpression;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.ILogicalOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.IOptimizationContext;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.LogicalExpressionTag;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.LogicalOperatorTag;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.LogicalVariable;
-import edu.uci.ics.hyracks.algebricks.core.algebra.expressions.AbstractFunctionCallExpression;
-import edu.uci.ics.hyracks.algebricks.core.algebra.expressions.ConstantExpression;
-import edu.uci.ics.hyracks.algebricks.core.algebra.expressions.IVariableTypeEnvironment;
-import edu.uci.ics.hyracks.algebricks.core.algebra.expressions.ScalarFunctionCallExpression;
-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.AssignOperator;
-import edu.uci.ics.hyracks.algebricks.core.rewriter.base.IAlgebraicRewriteRule;
-
-public class ByNameToByIndexFieldAccessRule implements IAlgebraicRewriteRule {
-
- @Override
- public boolean rewritePre(Mutable<ILogicalOperator> opRef, IOptimizationContext context) throws AlgebricksException {
- return false;
- }
-
- @Override
- public boolean rewritePost(Mutable<ILogicalOperator> opRef, IOptimizationContext context)
- throws AlgebricksException {
- AbstractLogicalOperator op = (AbstractLogicalOperator) opRef.getValue();
- if (op.getOperatorTag() != LogicalOperatorTag.ASSIGN) {
- return false;
- }
- AssignOperator assign = (AssignOperator) op;
- if (assign.getExpressions().get(0).getValue().getExpressionTag() != LogicalExpressionTag.FUNCTION_CALL) {
- return false;
- }
-
- List<Mutable<ILogicalExpression>> expressions = assign.getExpressions();
- boolean changed = false;
- for (int i = 0; i < expressions.size(); i++) {
- AbstractFunctionCallExpression fce = (AbstractFunctionCallExpression) expressions.get(i).getValue();
- if (fce.getFunctionIdentifier() != AsterixBuiltinFunctions.FIELD_ACCESS_BY_NAME) {
- continue;
- }
- IVariableTypeEnvironment env = context.getOutputTypeEnvironment(op);
-
- ILogicalExpression a0 = fce.getArguments().get(0).getValue();
- if (a0.getExpressionTag() == LogicalExpressionTag.FUNCTION_CALL) {
- LogicalVariable var1 = context.newVar();
- ArrayList<LogicalVariable> varArray = new ArrayList<LogicalVariable>(1);
- varArray.add(var1);
- ArrayList<Mutable<ILogicalExpression>> exprArray = new ArrayList<Mutable<ILogicalExpression>>(1);
- exprArray.add(new MutableObject<ILogicalExpression>(a0));
- AssignOperator assignVar = new AssignOperator(varArray, exprArray);
- fce.getArguments().get(0).setValue(new VariableReferenceExpression(var1));
- assignVar.getInputs().add(new MutableObject<ILogicalOperator>(assign.getInputs().get(0).getValue()));
- assign.getInputs().get(0).setValue(assignVar);
- context.computeAndSetTypeEnvironmentForOperator(assignVar);
- context.computeAndSetTypeEnvironmentForOperator(assign);
- //access by name was not replaced to access by index, but the plan was altered, hence changed is true
- changed = true;
- }
-
- IAType t = (IAType) env.getType(fce.getArguments().get(0).getValue());
- try {
- switch (t.getTypeTag()) {
- case ANY: {
- return false || changed;
- }
- case RECORD: {
- ARecordType recType = (ARecordType) t;
- ILogicalExpression fai = createFieldAccessByIndex(recType, fce);
- if (fai == null) {
- return false || changed;
- }
- expressions.get(i).setValue(fai);
- changed = true;
- break;
- }
- case UNION: {
- AUnionType unionT = (AUnionType) t;
- if (unionT.isNullableType()) {
- IAType t2 = unionT.getNullableType();
- if (t2.getTypeTag() == ATypeTag.RECORD) {
- ARecordType recType = (ARecordType) t2;
- ILogicalExpression fai = createFieldAccessByIndex(recType, fce);
- if (fai == null) {
- return false || changed;
- }
- expressions.get(i).setValue(fai);
- changed = true;
- break;
- }
- }
- throw new NotImplementedException("Union " + unionT);
- }
- default: {
- throw new AlgebricksException("Cannot call field-access on data of type " + t);
- }
- }
- } catch (IOException e) {
- throw new AlgebricksException(e);
- }
- }
- assign.removeAnnotation(AsterixOperatorAnnotations.PUSHED_FIELD_ACCESS);
- return changed;
- }
-
- @SuppressWarnings("unchecked")
- private static ILogicalExpression createFieldAccessByIndex(ARecordType recType, AbstractFunctionCallExpression fce)
- throws IOException {
- String s = getStringSecondArgument(fce);
- if (s == null) {
- return null;
- }
- int k = recType.findFieldPosition(s);
- if (k < 0) {
- return null;
- }
- return new ScalarFunctionCallExpression(
- FunctionUtils.getFunctionInfo(AsterixBuiltinFunctions.FIELD_ACCESS_BY_INDEX),
- fce.getArguments().get(0), new MutableObject<ILogicalExpression>(new ConstantExpression(
- new AsterixConstantValue(new AInt32(k)))));
- }
-
- private static String getStringSecondArgument(AbstractFunctionCallExpression expr) {
- ILogicalExpression e2 = expr.getArguments().get(1).getValue();
- if (e2.getExpressionTag() != LogicalExpressionTag.CONSTANT) {
- return null;
- }
- ConstantExpression c = (ConstantExpression) e2;
- if (!(c.getValue() instanceof AsterixConstantValue)) {
- return null;
- }
- IAObject v = ((AsterixConstantValue) c.getValue()).getObject();
- if (v.getType().getTypeTag() != ATypeTag.STRING) {
- return null;
- }
- return ((AString) v).getStringValue();
- }
-}
http://git-wip-us.apache.org/repos/asf/incubator-asterixdb/blob/34d81630/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/CancelUnnestWithNestedListifyRule.java
----------------------------------------------------------------------
diff --git a/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/CancelUnnestWithNestedListifyRule.java b/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/CancelUnnestWithNestedListifyRule.java
deleted file mode 100644
index 73b0de7..0000000
--- a/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/CancelUnnestWithNestedListifyRule.java
+++ /dev/null
@@ -1,282 +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.asterix.optimizer.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.asterix.aql.util.FunctionUtils;
-import edu.uci.ics.asterix.om.functions.AsterixBuiltinFunctions;
-import edu.uci.ics.hyracks.algebricks.common.exceptions.AlgebricksException;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.ILogicalExpression;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.ILogicalOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.ILogicalPlan;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.IOptimizationContext;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.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.StatefulFunctionCallExpression;
-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.AggregateOperator;
-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.RunningAggregateOperator;
-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.algebra.operators.physical.RunningAggregatePOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.properties.UnpartitionedPropertyComputer;
-import edu.uci.ics.hyracks.algebricks.core.rewriter.base.IAlgebraicRewriteRule;
-
-/**
- * This rule cancels the unnest with the nested listify. Formally, the following plan<br/>
- *
- * <pre>
- * unnset $x <- $y
- * group-by($k){
- * aggregate $y <- listify($z)
- * ...
- * }
- * </pre>
- *
- * will be converted into<br/>
- *
- * <pre>
- * assign $x <- $z
- * sort($k)
- * </pre>
- *
- * When the positional variable exists, for example the original plan is like<br/>
- *
- * <pre>
- * unnset $x at $p <- $y
- * group-by($k){
- * aggregate $y <- listify($z)
- * ...
- * }
- * </pre>
- *
- * will be converted into<br/>
- *
- * <pre>
- * group-by($k){
- * running-aggregate $p <- tid()
- * }
- * </pre>
- */
-public class CancelUnnestWithNestedListifyRule implements IAlgebraicRewriteRule {
-
- /* (non-Javadoc)
- * @see edu.uci.ics.hyracks.algebricks.core.rewriter.base.IAlgebraicRewriteRule#rewritePost(org.apache.commons.lang3.mutable.Mutable, edu.uci.ics.hyracks.algebricks.core.algebra.base.IOptimizationContext)
- */
- @Override
- public boolean rewritePost(Mutable<ILogicalOperator> opRef, IOptimizationContext context)
- throws AlgebricksException {
- return false;
- }
-
- @Override
- public boolean rewritePre(Mutable<ILogicalOperator> opRef, IOptimizationContext context) throws AlgebricksException {
- // apply it only at the top of the plan
- ILogicalOperator op = opRef.getValue();
- if (context.checkIfInDontApplySet(this, op)) {
- return false;
- }
- Set<LogicalVariable> varSet = new HashSet<LogicalVariable>();
- return applyRuleDown(opRef, varSet, context);
- }
-
- private boolean applyRuleDown(Mutable<ILogicalOperator> opRef, Set<LogicalVariable> varSet,
- IOptimizationContext context) throws AlgebricksException {
- boolean changed = applies(opRef, varSet, context);
- AbstractLogicalOperator op = (AbstractLogicalOperator) opRef.getValue();
- VariableUtilities.getUsedVariables(op, varSet);
- if (op.hasNestedPlans()) {
- AbstractOperatorWithNestedPlans aonp = (AbstractOperatorWithNestedPlans) op;
- for (ILogicalPlan p : aonp.getNestedPlans()) {
- for (Mutable<ILogicalOperator> r : p.getRoots()) {
- if (applyRuleDown(r, varSet, context)) {
- changed = true;
- }
- context.addToDontApplySet(this, r.getValue());
- }
- }
- }
- for (Mutable<ILogicalOperator> i : op.getInputs()) {
- if (applyRuleDown(i, varSet, context)) {
- changed = true;
- }
- context.addToDontApplySet(this, i.getValue());
- }
- return changed;
- }
-
- private boolean applies(Mutable<ILogicalOperator> opRef, Set<LogicalVariable> varUsedAbove,
- IOptimizationContext context) throws AlgebricksException {
- AbstractLogicalOperator op1 = (AbstractLogicalOperator) opRef.getValue();
- if (op1.getOperatorTag() != LogicalOperatorTag.UNNEST) {
- return false;
- }
- UnnestOperator unnest1 = (UnnestOperator) op1;
- ILogicalExpression expr = unnest1.getExpressionRef().getValue();
- LogicalVariable unnestedVar;
- switch (expr.getExpressionTag()) {
- case VARIABLE:
- unnestedVar = ((VariableReferenceExpression) expr).getVariableReference();
- break;
- case FUNCTION_CALL:
- if (((AbstractFunctionCallExpression) expr).getFunctionIdentifier() != AsterixBuiltinFunctions.SCAN_COLLECTION) {
- return false;
- }
- AbstractFunctionCallExpression functionCall = (AbstractFunctionCallExpression) expr;
- ILogicalExpression functionCallArgExpr = functionCall.getArguments().get(0).getValue();
- if (functionCallArgExpr.getExpressionTag() != LogicalExpressionTag.VARIABLE) {
- return false;
- }
- unnestedVar = ((VariableReferenceExpression) functionCallArgExpr).getVariableReference();
- break;
- default:
- return false;
- }
- if (varUsedAbove.contains(unnestedVar)) {
- return false;
- }
-
- Mutable<ILogicalOperator> opRef2 = op1.getInputs().get(0);
- AbstractLogicalOperator r = (AbstractLogicalOperator) opRef2.getValue();
-
- if (r.getOperatorTag() != LogicalOperatorTag.GROUP) {
- return false;
- }
-
- // go inside of a group-by plan
- GroupByOperator gby = (GroupByOperator) r;
- if (gby.getNestedPlans().size() != 1) {
- return false;
- }
- if (gby.getNestedPlans().get(0).getRoots().size() != 1) {
- return false;
- }
-
- AbstractLogicalOperator nestedPlanRoot = (AbstractLogicalOperator) gby.getNestedPlans().get(0).getRoots()
- .get(0).getValue();
- if (nestedPlanRoot.getOperatorTag() != LogicalOperatorTag.AGGREGATE) {
- return false;
- }
- AggregateOperator agg = (AggregateOperator) nestedPlanRoot;
- Mutable<ILogicalOperator> aggInputOpRef = agg.getInputs().get(0);
-
- if (agg.getVariables().size() > 1) {
- return false;
- }
-
- LogicalVariable aggVar = agg.getVariables().get(0);
- ILogicalExpression aggFun = agg.getExpressions().get(0).getValue();
- if (!aggVar.equals(unnestedVar)
- || ((AbstractLogicalExpression) aggFun).getExpressionTag() != LogicalExpressionTag.FUNCTION_CALL) {
- return false;
- }
- AbstractFunctionCallExpression f = (AbstractFunctionCallExpression) aggFun;
- if (!AsterixBuiltinFunctions.LISTIFY.equals(f.getFunctionIdentifier())) {
- return false;
- }
- if (f.getArguments().size() != 1) {
- return false;
- }
- ILogicalExpression arg0 = f.getArguments().get(0).getValue();
- if (((AbstractLogicalExpression) arg0).getExpressionTag() != LogicalExpressionTag.VARIABLE) {
- return false;
- }
- LogicalVariable paramVar = ((VariableReferenceExpression) arg0).getVariableReference();
-
- ArrayList<LogicalVariable> assgnVars = new ArrayList<LogicalVariable>(1);
- assgnVars.add(unnest1.getVariable());
- ArrayList<Mutable<ILogicalExpression>> assgnExprs = new ArrayList<Mutable<ILogicalExpression>>(1);
- assgnExprs.add(new MutableObject<ILogicalExpression>(new VariableReferenceExpression(paramVar)));
- AssignOperator assign = new AssignOperator(assgnVars, assgnExprs);
-
- LogicalVariable posVar = unnest1.getPositionalVariable();
- if (posVar == null) {
- // Creates assignment for group-by keys.
- ArrayList<LogicalVariable> gbyKeyAssgnVars = new ArrayList<LogicalVariable>();
- ArrayList<Mutable<ILogicalExpression>> gbyKeyAssgnExprs = new ArrayList<Mutable<ILogicalExpression>>();
- for (int i = 0; i < gby.getGroupByList().size(); i++) {
- if (gby.getGroupByList().get(i).first != null) {
- gbyKeyAssgnVars.add(gby.getGroupByList().get(i).first);
- gbyKeyAssgnExprs.add(gby.getGroupByList().get(i).second);
- }
- }
-
- // Moves the nested pipeline before aggregation out of the group-by op.
- Mutable<ILogicalOperator> bottomOpRef = aggInputOpRef;
- AbstractLogicalOperator bottomOp = (AbstractLogicalOperator) bottomOpRef.getValue();
- while (bottomOp.getOperatorTag() != LogicalOperatorTag.NESTEDTUPLESOURCE) {
- bottomOpRef = bottomOp.getInputs().get(0);
- bottomOp = (AbstractLogicalOperator) bottomOpRef.getValue();
- }
-
- // Removes the group-by operator.
- opRef.setValue(assign);
- assign.getInputs().add(aggInputOpRef);
- AssignOperator gbyKeyAssign = new AssignOperator(gbyKeyAssgnVars, gbyKeyAssgnExprs);
- gbyKeyAssign.getInputs().add(gby.getInputs().get(0));
- bottomOpRef.setValue(gbyKeyAssign);
-
- context.computeAndSetTypeEnvironmentForOperator(gbyKeyAssign);
- context.computeAndSetTypeEnvironmentForOperator(assign);
- } else {
- // if positional variable is used in unnest, the unnest will be pushed into the group-by as a running-aggregate
-
- // First create assign for the unnest variable
- List<LogicalVariable> nestedAssignVars = new ArrayList<LogicalVariable>();
- List<Mutable<ILogicalExpression>> nestedAssignExprs = new ArrayList<Mutable<ILogicalExpression>>();
- nestedAssignVars.add(unnest1.getVariable());
- nestedAssignExprs.add(new MutableObject<ILogicalExpression>(arg0));
- AssignOperator nestedAssign = new AssignOperator(nestedAssignVars, nestedAssignExprs);
- nestedAssign.getInputs().add(opRef2);
-
- // Then create running aggregation for the positional variable
- List<LogicalVariable> raggVars = new ArrayList<LogicalVariable>();
- List<Mutable<ILogicalExpression>> raggExprs = new ArrayList<Mutable<ILogicalExpression>>();
- raggVars.add(posVar);
- StatefulFunctionCallExpression fce = new StatefulFunctionCallExpression(
- FunctionUtils.getFunctionInfo(AsterixBuiltinFunctions.TID), UnpartitionedPropertyComputer.INSTANCE);
- raggExprs.add(new MutableObject<ILogicalExpression>(fce));
- RunningAggregateOperator raggOp = new RunningAggregateOperator(raggVars, raggExprs);
- raggOp.setExecutionMode(unnest1.getExecutionMode());
- RunningAggregatePOperator raggPOp = new RunningAggregatePOperator();
- raggOp.setPhysicalOperator(raggPOp);
- raggOp.getInputs().add(nestedPlanRoot.getInputs().get(0));
- gby.getNestedPlans().get(0).getRoots().set(0, new MutableObject<ILogicalOperator>(raggOp));
-
- opRef.setValue(nestedAssign);
-
- context.computeAndSetTypeEnvironmentForOperator(nestedAssign);
- context.computeAndSetTypeEnvironmentForOperator(raggOp);
- context.computeAndSetTypeEnvironmentForOperator(gby);
-
- }
-
- return true;
- }
-}
http://git-wip-us.apache.org/repos/asf/incubator-asterixdb/blob/34d81630/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/CheckFilterExpressionTypeRule.java
----------------------------------------------------------------------
diff --git a/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/CheckFilterExpressionTypeRule.java b/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/CheckFilterExpressionTypeRule.java
deleted file mode 100644
index 7e9ebcc..0000000
--- a/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/CheckFilterExpressionTypeRule.java
+++ /dev/null
@@ -1,83 +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.asterix.optimizer.rules;
-
-import org.apache.commons.lang3.mutable.Mutable;
-
-import edu.uci.ics.asterix.om.types.ATypeTag;
-import edu.uci.ics.asterix.om.types.AUnionType;
-import edu.uci.ics.asterix.om.types.IAType;
-import edu.uci.ics.asterix.om.util.NonTaggedFormatUtil;
-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.expressions.IVariableTypeEnvironment;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.AbstractLogicalOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.SelectOperator;
-import edu.uci.ics.hyracks.algebricks.core.rewriter.base.IAlgebraicRewriteRule;
-
-/**
- * This rule is to check if all the filter expression are of the boolean type or a possible (determined
- * at the runtime) boolean type.
- * If that is not the case, an exception should be thrown.
- *
- * @author yingyib
- */
-public class CheckFilterExpressionTypeRule implements IAlgebraicRewriteRule {
-
- @Override
- public boolean rewritePre(Mutable<ILogicalOperator> opRef, IOptimizationContext context) throws AlgebricksException {
- return false;
- }
-
- @Override
- public boolean rewritePost(Mutable<ILogicalOperator> opRef, IOptimizationContext context)
- throws AlgebricksException {
- AbstractLogicalOperator op = (AbstractLogicalOperator) opRef.getValue();
- if (op.getOperatorTag() != LogicalOperatorTag.SELECT) {
- return false;
- }
- SelectOperator select = (SelectOperator) op;
- ILogicalExpression condition = select.getCondition().getValue();
- IVariableTypeEnvironment env = select.computeOutputTypeEnvironment(context);
- IAType condType = (IAType) env.getType(condition);
- if (condType.getTypeTag() != ATypeTag.BOOLEAN && condType.getTypeTag() != ATypeTag.ANY
- && !isPossibleBoolean(condType)) {
- throw new AlgebricksException("The select condition " + condition.toString()
- + " should be of the boolean type.");
- }
- return false;
- }
-
- /**
- * Check if the type is optional boolean or not
- *
- * @param type
- * @return true if it is; false otherwise.
- */
- private boolean isPossibleBoolean(IAType type) {
- while (NonTaggedFormatUtil.isOptional(type)) {
- type = ((AUnionType) type).getNullableType();
- if (type.getTypeTag() == ATypeTag.BOOLEAN || type.getTypeTag() == ATypeTag.ANY) {
- return true;
- }
- }
- return false;
- }
-
-}
http://git-wip-us.apache.org/repos/asf/incubator-asterixdb/blob/34d81630/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/ConstantFoldingRule.java
----------------------------------------------------------------------
diff --git a/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/ConstantFoldingRule.java b/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/ConstantFoldingRule.java
deleted file mode 100644
index be1653d..0000000
--- a/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/ConstantFoldingRule.java
+++ /dev/null
@@ -1,264 +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.asterix.optimizer.rules;
-
-import java.io.DataInputStream;
-import java.io.IOException;
-import java.nio.ByteBuffer;
-import java.util.List;
-
-import org.apache.commons.lang3.mutable.Mutable;
-
-import edu.uci.ics.asterix.common.config.GlobalConfig;
-import edu.uci.ics.asterix.dataflow.data.common.AqlExpressionTypeComputer;
-import edu.uci.ics.asterix.dataflow.data.common.AqlNullableTypeComputer;
-import edu.uci.ics.asterix.dataflow.data.nontagged.AqlNullWriterFactory;
-import edu.uci.ics.asterix.formats.nontagged.AqlBinaryBooleanInspectorImpl;
-import edu.uci.ics.asterix.formats.nontagged.AqlBinaryComparatorFactoryProvider;
-import edu.uci.ics.asterix.formats.nontagged.AqlBinaryHashFunctionFactoryProvider;
-import edu.uci.ics.asterix.formats.nontagged.AqlBinaryHashFunctionFamilyProvider;
-import edu.uci.ics.asterix.formats.nontagged.AqlBinaryIntegerInspector;
-import edu.uci.ics.asterix.formats.nontagged.AqlPrinterFactoryProvider;
-import edu.uci.ics.asterix.formats.nontagged.AqlSerializerDeserializerProvider;
-import edu.uci.ics.asterix.formats.nontagged.AqlTypeTraitProvider;
-import edu.uci.ics.asterix.jobgen.AqlLogicalExpressionJobGen;
-import edu.uci.ics.asterix.om.base.AString;
-import edu.uci.ics.asterix.om.base.IAObject;
-import edu.uci.ics.asterix.om.constants.AsterixConstantValue;
-import edu.uci.ics.asterix.om.functions.AsterixBuiltinFunctions;
-import edu.uci.ics.asterix.om.typecomputer.base.TypeComputerUtilities;
-import edu.uci.ics.asterix.om.types.ARecordType;
-import edu.uci.ics.asterix.om.types.ATypeTag;
-import edu.uci.ics.asterix.om.types.AbstractCollectionType;
-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.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.AggregateFunctionCallExpression;
-import edu.uci.ics.hyracks.algebricks.core.algebra.expressions.ConstantExpression;
-import edu.uci.ics.hyracks.algebricks.core.algebra.expressions.IVariableTypeEnvironment;
-import edu.uci.ics.hyracks.algebricks.core.algebra.expressions.LogicalExpressionJobGenToExpressionRuntimeProviderAdapter;
-import edu.uci.ics.hyracks.algebricks.core.algebra.expressions.ScalarFunctionCallExpression;
-import edu.uci.ics.hyracks.algebricks.core.algebra.expressions.StatefulFunctionCallExpression;
-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.IOperatorSchema;
-import edu.uci.ics.hyracks.algebricks.core.algebra.visitors.ILogicalExpressionReferenceTransform;
-import edu.uci.ics.hyracks.algebricks.core.algebra.visitors.ILogicalExpressionVisitor;
-import edu.uci.ics.hyracks.algebricks.core.jobgen.impl.JobGenContext;
-import edu.uci.ics.hyracks.algebricks.core.rewriter.base.IAlgebraicRewriteRule;
-import edu.uci.ics.hyracks.algebricks.runtime.base.IScalarEvaluator;
-import edu.uci.ics.hyracks.algebricks.runtime.base.IScalarEvaluatorFactory;
-import edu.uci.ics.hyracks.api.dataflow.value.ISerializerDeserializer;
-import edu.uci.ics.hyracks.api.exceptions.HyracksDataException;
-import edu.uci.ics.hyracks.data.std.api.IPointable;
-import edu.uci.ics.hyracks.data.std.primitive.VoidPointable;
-import edu.uci.ics.hyracks.dataflow.common.comm.util.ByteBufferInputStream;
-
-public class ConstantFoldingRule implements IAlgebraicRewriteRule {
-
- private final ConstantFoldingVisitor cfv = new ConstantFoldingVisitor();
-
- /** Throws exceptions in substituiteProducedVariable, setVarType, and one getVarType method. */
- private static final IVariableTypeEnvironment _emptyTypeEnv = new IVariableTypeEnvironment() {
-
- @Override
- public boolean substituteProducedVariable(LogicalVariable v1, LogicalVariable v2) throws AlgebricksException {
- throw new IllegalStateException();
- }
-
- @Override
- public void setVarType(LogicalVariable var, Object type) {
- throw new IllegalStateException();
- }
-
- @Override
- public Object getVarType(LogicalVariable var, List<LogicalVariable> nonNullVariables,
- List<List<LogicalVariable>> correlatedNullableVariableLists) throws AlgebricksException {
- throw new IllegalStateException();
- }
-
- @Override
- public Object getVarType(LogicalVariable var) throws AlgebricksException {
- throw new IllegalStateException();
- }
-
- @Override
- public Object getType(ILogicalExpression expr) throws AlgebricksException {
- return AqlExpressionTypeComputer.INSTANCE.getType(expr, null, this);
- }
- };
-
- private static final JobGenContext _jobGenCtx = new JobGenContext(null, null, null,
- AqlSerializerDeserializerProvider.INSTANCE, AqlBinaryHashFunctionFactoryProvider.INSTANCE,
- AqlBinaryHashFunctionFamilyProvider.INSTANCE, AqlBinaryComparatorFactoryProvider.INSTANCE,
- AqlTypeTraitProvider.INSTANCE, AqlBinaryBooleanInspectorImpl.FACTORY, AqlBinaryIntegerInspector.FACTORY,
- AqlPrinterFactoryProvider.INSTANCE, AqlNullWriterFactory.INSTANCE, null,
- new LogicalExpressionJobGenToExpressionRuntimeProviderAdapter(AqlLogicalExpressionJobGen.INSTANCE),
- AqlExpressionTypeComputer.INSTANCE, AqlNullableTypeComputer.INSTANCE, null, null, null, null,
- GlobalConfig.DEFAULT_FRAME_SIZE, null);
-
- private static final IOperatorSchema[] _emptySchemas = new IOperatorSchema[] {};
-
- @Override
- public boolean rewritePre(Mutable<ILogicalOperator> opRef, IOptimizationContext context) throws AlgebricksException {
- return false;
- }
-
- @Override
- public boolean rewritePost(Mutable<ILogicalOperator> opRef, IOptimizationContext context)
- throws AlgebricksException {
- ILogicalOperator op = opRef.getValue();
- if (context.checkIfInDontApplySet(this, op)) {
- return false;
- }
- return op.acceptExpressionTransform(cfv);
- }
-
- private class ConstantFoldingVisitor implements ILogicalExpressionVisitor<Pair<Boolean, ILogicalExpression>, Void>,
- ILogicalExpressionReferenceTransform {
-
- private final IPointable p = VoidPointable.FACTORY.createPointable();
- private final ByteBufferInputStream bbis = new ByteBufferInputStream();
- private final DataInputStream dis = new DataInputStream(bbis);
-
- @Override
- public boolean transform(Mutable<ILogicalExpression> exprRef) throws AlgebricksException {
- AbstractLogicalExpression expr = (AbstractLogicalExpression) exprRef.getValue();
- Pair<Boolean, ILogicalExpression> p = expr.accept(this, null);
- if (p.first) {
- exprRef.setValue(p.second);
- }
- return p.first;
- }
-
- @Override
- public Pair<Boolean, ILogicalExpression> visitConstantExpression(ConstantExpression expr, Void arg)
- throws AlgebricksException {
- return new Pair<Boolean, ILogicalExpression>(false, expr);
- }
-
- @Override
- public Pair<Boolean, ILogicalExpression> visitVariableReferenceExpression(VariableReferenceExpression expr,
- Void arg) throws AlgebricksException {
- return new Pair<Boolean, ILogicalExpression>(false, expr);
- }
-
- @Override
- public Pair<Boolean, ILogicalExpression> visitScalarFunctionCallExpression(ScalarFunctionCallExpression expr,
- Void arg) throws AlgebricksException {
- boolean changed = changeRec(expr, arg);
- if (!checkArgs(expr) || !expr.isFunctional()) {
- return new Pair<Boolean, ILogicalExpression>(changed, expr);
- }
- //Current ARecord SerDe assumes a closed record, so we do not constant fold open record constructors
- if (expr.getFunctionIdentifier().equals(AsterixBuiltinFunctions.OPEN_RECORD_CONSTRUCTOR)
- || expr.getFunctionIdentifier().equals(AsterixBuiltinFunctions.CAST_RECORD)) {
- return new Pair<Boolean, ILogicalExpression>(false, null);
- }
- //Current List SerDe assumes a strongly typed list, so we do not constant fold the list constructors if they are not strongly typed
- if (expr.getFunctionIdentifier().equals(AsterixBuiltinFunctions.UNORDERED_LIST_CONSTRUCTOR)
- || expr.getFunctionIdentifier().equals(AsterixBuiltinFunctions.ORDERED_LIST_CONSTRUCTOR)) {
- AbstractCollectionType listType = (AbstractCollectionType) TypeComputerUtilities.getRequiredType(expr);
- if (listType != null
- && (listType.getItemType().getTypeTag() == ATypeTag.ANY || listType.getItemType() instanceof AbstractCollectionType)) {
- //case1: listType == null, could be a nested list inside a list<ANY>
- //case2: itemType = ANY
- //case3: itemType = a nested list
- return new Pair<Boolean, ILogicalExpression>(false, null);
- }
- }
- if (expr.getFunctionIdentifier().equals(AsterixBuiltinFunctions.FIELD_ACCESS_BY_NAME)) {
- ARecordType rt = (ARecordType) _emptyTypeEnv.getType(expr.getArguments().get(0).getValue());
- String str = ((AString) ((AsterixConstantValue) ((ConstantExpression) expr.getArguments().get(1)
- .getValue()).getValue()).getObject()).getStringValue();
- int k;
- try {
- k = rt.findFieldPosition(str);
- } catch (IOException e) {
- throw new AlgebricksException(e);
- }
- if (k >= 0) {
- // wait for the ByNameToByIndex rule to apply
- return new Pair<Boolean, ILogicalExpression>(changed, expr);
- }
- }
- IScalarEvaluatorFactory fact = _jobGenCtx.getExpressionRuntimeProvider().createEvaluatorFactory(expr,
- _emptyTypeEnv, _emptySchemas, _jobGenCtx);
- IScalarEvaluator eval = fact.createScalarEvaluator(null);
- eval.evaluate(null, p);
- Object t = _emptyTypeEnv.getType(expr);
-
- @SuppressWarnings("rawtypes")
- ISerializerDeserializer serde = _jobGenCtx.getSerializerDeserializerProvider().getSerializerDeserializer(t);
- bbis.setByteBuffer(ByteBuffer.wrap(p.getByteArray(), p.getStartOffset(), p.getLength()), 0);
- IAObject o;
- try {
- o = (IAObject) serde.deserialize(dis);
- } catch (HyracksDataException e) {
- throw new AlgebricksException(e);
- }
- return new Pair<Boolean, ILogicalExpression>(true, new ConstantExpression(new AsterixConstantValue(o)));
- }
-
- @Override
- public Pair<Boolean, ILogicalExpression> visitAggregateFunctionCallExpression(
- AggregateFunctionCallExpression expr, Void arg) throws AlgebricksException {
- boolean changed = changeRec(expr, arg);
- return new Pair<Boolean, ILogicalExpression>(changed, expr);
- }
-
- @Override
- public Pair<Boolean, ILogicalExpression> visitStatefulFunctionCallExpression(
- StatefulFunctionCallExpression expr, Void arg) throws AlgebricksException {
- boolean changed = changeRec(expr, arg);
- return new Pair<Boolean, ILogicalExpression>(changed, expr);
- }
-
- @Override
- public Pair<Boolean, ILogicalExpression> visitUnnestingFunctionCallExpression(
- UnnestingFunctionCallExpression expr, Void arg) throws AlgebricksException {
- boolean changed = changeRec(expr, arg);
- return new Pair<Boolean, ILogicalExpression>(changed, expr);
- }
-
- private boolean changeRec(AbstractFunctionCallExpression expr, Void arg) throws AlgebricksException {
- boolean changed = false;
- for (Mutable<ILogicalExpression> r : expr.getArguments()) {
- Pair<Boolean, ILogicalExpression> p2 = r.getValue().accept(this, arg);
- if (p2.first) {
- r.setValue(p2.second);
- changed = true;
- }
- }
- return changed;
- }
-
- private boolean checkArgs(AbstractFunctionCallExpression expr) throws AlgebricksException {
- for (Mutable<ILogicalExpression> r : expr.getArguments()) {
- if (r.getValue().getExpressionTag() != LogicalExpressionTag.CONSTANT) {
- return false;
- }
- }
- return true;
- }
- }
-}
http://git-wip-us.apache.org/repos/asf/incubator-asterixdb/blob/34d81630/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/CountVarToCountOneRule.java
----------------------------------------------------------------------
diff --git a/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/CountVarToCountOneRule.java b/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/CountVarToCountOneRule.java
deleted file mode 100644
index 218cd4b..0000000
--- a/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/CountVarToCountOneRule.java
+++ /dev/null
@@ -1,86 +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.asterix.optimizer.rules;
-
-import org.apache.commons.lang3.mutable.Mutable;
-
-import edu.uci.ics.asterix.om.base.AInt64;
-import edu.uci.ics.asterix.om.constants.AsterixConstantValue;
-import edu.uci.ics.asterix.om.functions.AsterixBuiltinFunctions;
-import edu.uci.ics.hyracks.algebricks.common.exceptions.AlgebricksException;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.ILogicalExpression;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.ILogicalOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.ILogicalPlan;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.IOptimizationContext;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.LogicalExpressionTag;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.LogicalOperatorTag;
-import edu.uci.ics.hyracks.algebricks.core.algebra.expressions.AbstractFunctionCallExpression;
-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.AggregateOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.GroupByOperator;
-import edu.uci.ics.hyracks.algebricks.core.rewriter.base.IAlgebraicRewriteRule;
-
-public class CountVarToCountOneRule implements IAlgebraicRewriteRule {
-
- @Override
- public boolean rewritePre(Mutable<ILogicalOperator> opRef, IOptimizationContext context) throws AlgebricksException {
- return false;
- }
-
- // It is only for a group-by having just one aggregate which is a count.
- @Override
- public boolean rewritePost(Mutable<ILogicalOperator> opRef, IOptimizationContext context)
- throws AlgebricksException {
- AbstractLogicalOperator op1 = (AbstractLogicalOperator) opRef.getValue();
- if (op1.getOperatorTag() != LogicalOperatorTag.GROUP) {
- return false;
- }
- GroupByOperator g = (GroupByOperator) op1;
- if (g.getNestedPlans().size() != 1) {
- return false;
- }
- ILogicalPlan p = g.getNestedPlans().get(0);
- if (p.getRoots().size() != 1) {
- return false;
- }
- AbstractLogicalOperator op2 = (AbstractLogicalOperator) p.getRoots().get(0).getValue();
- if (op2.getOperatorTag() != LogicalOperatorTag.AGGREGATE) {
- return false;
- }
- AggregateOperator agg = (AggregateOperator) op2;
- if (agg.getExpressions().size() != 1) {
- return false;
- }
- ILogicalExpression exp2 = agg.getExpressions().get(0).getValue();
- if (exp2.getExpressionTag() != LogicalExpressionTag.FUNCTION_CALL) {
- return false;
- }
- AbstractFunctionCallExpression fun = (AbstractFunctionCallExpression) exp2;
- if (fun.getFunctionIdentifier() != AsterixBuiltinFunctions.COUNT) {
- return false;
- }
- ILogicalExpression exp3 = fun.getArguments().get(0).getValue();
- if (exp3.getExpressionTag() != LogicalExpressionTag.VARIABLE) {
- return false;
- }
- if (((AbstractLogicalOperator) agg.getInputs().get(0).getValue()).getOperatorTag() != LogicalOperatorTag.NESTEDTUPLESOURCE) {
- return false;
- }
- fun.getArguments().get(0).setValue(new ConstantExpression(new AsterixConstantValue(new AInt64(1L))));
- return true;
- }
-
-}
http://git-wip-us.apache.org/repos/asf/incubator-asterixdb/blob/34d81630/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/DisjunctivePredicateToJoinRule.java
----------------------------------------------------------------------
diff --git a/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/DisjunctivePredicateToJoinRule.java b/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/DisjunctivePredicateToJoinRule.java
deleted file mode 100644
index 0fb205d..0000000
--- a/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/DisjunctivePredicateToJoinRule.java
+++ /dev/null
@@ -1,191 +0,0 @@
-/*
- * Copyright 2014 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.asterix.optimizer.rules;
-
-import java.util.HashSet;
-import java.util.List;
-
-import org.apache.commons.lang3.mutable.Mutable;
-import org.apache.commons.lang3.mutable.MutableObject;
-
-import edu.uci.ics.asterix.om.base.AOrderedList;
-import edu.uci.ics.asterix.om.constants.AsterixConstantValue;
-import edu.uci.ics.asterix.om.functions.AsterixBuiltinFunctions;
-import edu.uci.ics.asterix.om.types.AOrderedListType;
-import edu.uci.ics.asterix.om.types.IAType;
-import edu.uci.ics.hyracks.algebricks.common.exceptions.AlgebricksException;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.ILogicalExpression;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.ILogicalOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.IOptimizationContext;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.LogicalExpressionTag;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.LogicalOperatorTag;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.LogicalVariable;
-import edu.uci.ics.hyracks.algebricks.core.algebra.expressions.AbstractFunctionCallExpression;
-import edu.uci.ics.hyracks.algebricks.core.algebra.expressions.ConstantExpression;
-import edu.uci.ics.hyracks.algebricks.core.algebra.expressions.IndexedNLJoinExpressionAnnotation;
-import edu.uci.ics.hyracks.algebricks.core.algebra.expressions.ScalarFunctionCallExpression;
-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.functions.AlgebricksBuiltinFunctions;
-import edu.uci.ics.hyracks.algebricks.core.algebra.functions.FunctionIdentifier;
-import edu.uci.ics.hyracks.algebricks.core.algebra.functions.IFunctionInfo;
-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.SelectOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.UnnestOperator;
-import edu.uci.ics.hyracks.algebricks.core.rewriter.base.IAlgebraicRewriteRule;
-
-public class DisjunctivePredicateToJoinRule implements IAlgebraicRewriteRule {
-
- @Override
- public boolean rewritePost(Mutable<ILogicalOperator> opRef, IOptimizationContext context)
- throws AlgebricksException {
-
- SelectOperator select;
- if ((select = asSelectOperator(opRef)) == null) {
- return false;
- }
-
- AbstractFunctionCallExpression condEx;
- if ((condEx = asFunctionCallExpression(select.getCondition(), AlgebricksBuiltinFunctions.OR)) == null) {
- return false;
- }
-
- List<Mutable<ILogicalExpression>> args = condEx.getArguments();
-
- VariableReferenceExpression varEx = null;
- IAType valType = null;
- HashSet<AsterixConstantValue> values = new HashSet<AsterixConstantValue>();
-
- for (Mutable<ILogicalExpression> arg : args) {
- AbstractFunctionCallExpression fctCall;
- if ((fctCall = asFunctionCallExpression(arg, AlgebricksBuiltinFunctions.EQ)) == null) {
- return false;
- }
-
- boolean haveConst = false;
- boolean haveVar = false;
- List<Mutable<ILogicalExpression>> fctArgs = fctCall.getArguments();
- for (Mutable<ILogicalExpression> fctArg : fctArgs) {
- final ILogicalExpression argExpr = fctArg.getValue();
- switch (argExpr.getExpressionTag()) {
- case CONSTANT:
- haveConst = true;
- AsterixConstantValue value = (AsterixConstantValue) ((ConstantExpression) argExpr).getValue();
- if (valType == null) {
- valType = value.getObject().getType();
- } else if (!isCompatible(valType, value.getObject().getType())) {
- return false;
- }
- values.add(value);
- break;
- case VARIABLE:
- haveVar = true;
- final VariableReferenceExpression varArg = (VariableReferenceExpression) argExpr;
- if (varEx == null) {
- varEx = varArg;
- } else if (!varEx.getVariableReference().equals(varArg.getVariableReference())) {
- return false;
- }
- break;
- default:
- return false;
- }
- }
- if (!(haveVar && haveConst)) {
- return false;
- }
- }
-
- AOrderedList list = new AOrderedList(new AOrderedListType(valType, "orderedlist"));
- for (AsterixConstantValue value : values) {
- list.add(value.getObject());
- }
-
- EmptyTupleSourceOperator ets = new EmptyTupleSourceOperator();
- context.computeAndSetTypeEnvironmentForOperator(ets);
-
- ILogicalExpression cExp = new ConstantExpression(new AsterixConstantValue(list));
- Mutable<ILogicalExpression> mutCExp = new MutableObject<ILogicalExpression>(cExp);
- IFunctionInfo scanFctInfo = AsterixBuiltinFunctions
- .getAsterixFunctionInfo(AsterixBuiltinFunctions.SCAN_COLLECTION);
- UnnestingFunctionCallExpression scanExp = new UnnestingFunctionCallExpression(scanFctInfo, mutCExp);
- LogicalVariable scanVar = context.newVar();
- UnnestOperator unn = new UnnestOperator(scanVar, new MutableObject<ILogicalExpression>(scanExp));
- unn.getInputs().add(new MutableObject<ILogicalOperator>(ets));
- context.computeAndSetTypeEnvironmentForOperator(unn);
-
- IFunctionInfo eqFctInfo = AsterixBuiltinFunctions.getAsterixFunctionInfo(AlgebricksBuiltinFunctions.EQ);
- AbstractFunctionCallExpression eqExp = new ScalarFunctionCallExpression(eqFctInfo);
- eqExp.getArguments().add(new MutableObject<ILogicalExpression>(new VariableReferenceExpression(scanVar)));
- eqExp.getArguments().add(new MutableObject<ILogicalExpression>(varEx.cloneExpression()));
- eqExp.getAnnotations().put(IndexedNLJoinExpressionAnnotation.INSTANCE,
- IndexedNLJoinExpressionAnnotation.INSTANCE);
-
- InnerJoinOperator jOp = new InnerJoinOperator(new MutableObject<ILogicalExpression>(eqExp));
- jOp.getInputs().add(new MutableObject<ILogicalOperator>(unn));
- jOp.getInputs().add(select.getInputs().get(0));
-
- opRef.setValue(jOp);
- context.computeAndSetTypeEnvironmentForOperator(jOp);
-
- return true;
- }
-
- @Override
- public boolean rewritePre(Mutable<ILogicalOperator> opRef, IOptimizationContext context) {
- return false;
- }
-
- /**
- * This checks the compatibility the types of the constants to ensure that the comparison behaves as expected
- * when joining. Right now this compatibility is defined as type equality, but it could we relaxed.
- * Once type promotion works correctly in all parts of the system, this check should not be needed anymore.
- * (see https://code.google.com/p/asterixdb/issues/detail?id=716)
- *
- * @param t1
- * one type
- * @param t2
- * another type
- * @return true, if types are equal
- */
- private static boolean isCompatible(IAType t1, IAType t2) {
- return t1.equals(t2);
- }
-
- // some helpers
-
- private static SelectOperator asSelectOperator(ILogicalOperator op) {
- return op.getOperatorTag() == LogicalOperatorTag.SELECT ? (SelectOperator) op : null;
- }
-
- private static SelectOperator asSelectOperator(Mutable<ILogicalOperator> op) {
- return asSelectOperator(op.getValue());
- }
-
- private static AbstractFunctionCallExpression asFunctionCallExpression(ILogicalExpression ex, FunctionIdentifier fi) {
- AbstractFunctionCallExpression fctCall = (ex.getExpressionTag() == LogicalExpressionTag.FUNCTION_CALL ? (AbstractFunctionCallExpression) ex
- : null);
- if (fctCall != null && (fi == null || fctCall.getFunctionIdentifier().equals(fi)))
- return fctCall;
- return null;
- }
-
- private static AbstractFunctionCallExpression asFunctionCallExpression(Mutable<ILogicalExpression> ex,
- FunctionIdentifier fi) {
- return asFunctionCallExpression(ex.getValue(), fi);
- }
-
-}
http://git-wip-us.apache.org/repos/asf/incubator-asterixdb/blob/34d81630/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/ExtractDistinctByExpressionsRule.java
----------------------------------------------------------------------
diff --git a/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/ExtractDistinctByExpressionsRule.java b/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/ExtractDistinctByExpressionsRule.java
deleted file mode 100644
index 7c36cb7..0000000
--- a/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/ExtractDistinctByExpressionsRule.java
+++ /dev/null
@@ -1,80 +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.asterix.optimizer.rules;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import org.apache.commons.lang3.mutable.Mutable;
-import org.apache.commons.lang3.mutable.MutableObject;
-
-import edu.uci.ics.hyracks.algebricks.common.exceptions.AlgebricksException;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.ILogicalExpression;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.ILogicalOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.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.DistinctOperator;
-import edu.uci.ics.hyracks.algebricks.rewriter.rules.AbstractExtractExprRule;
-
-/**
- * Needed only bc. current Hyracks operators require keys to be fields.
- */
-public class ExtractDistinctByExpressionsRule extends AbstractExtractExprRule {
-
- @Override
- public boolean rewritePre(Mutable<ILogicalOperator> opRef, IOptimizationContext context) {
- return false;
- }
-
- @Override
- public boolean rewritePost(Mutable<ILogicalOperator> opRef, IOptimizationContext context)
- throws AlgebricksException {
- AbstractLogicalOperator op1 = (AbstractLogicalOperator) opRef.getValue();
- if (op1.getOperatorTag() != LogicalOperatorTag.DISTINCT) {
- return false;
- }
-
- if (context.checkIfInDontApplySet(this, op1)) {
- return false;
- }
- context.addToDontApplySet(this, op1);
- DistinctOperator d = (DistinctOperator) op1;
- boolean changed = false;
- Mutable<ILogicalOperator> opRef2 = d.getInputs().get(0);
- List<Mutable<ILogicalExpression>> newExprList = new ArrayList<Mutable<ILogicalExpression>>();
- for (Mutable<ILogicalExpression> expr : d.getExpressions()) {
- LogicalExpressionTag tag = expr.getValue().getExpressionTag();
- if (tag == LogicalExpressionTag.VARIABLE || tag == LogicalExpressionTag.CONSTANT) {
- newExprList.add(expr);
- continue;
- }
- LogicalVariable v = extractExprIntoAssignOpRef(expr.getValue(), opRef2, context);
- ILogicalExpression newExpr = new VariableReferenceExpression(v);
- newExprList.add(new MutableObject<ILogicalExpression>(newExpr));
- changed = true;
- }
- if (changed) {
- d.getExpressions().clear();
- d.getExpressions().addAll(newExprList);
- context.computeAndSetTypeEnvironmentForOperator(d);
- }
- return changed;
- }
-
-}
http://git-wip-us.apache.org/repos/asf/incubator-asterixdb/blob/34d81630/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/ExtractOrderExpressionsRule.java
----------------------------------------------------------------------
diff --git a/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/ExtractOrderExpressionsRule.java b/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/ExtractOrderExpressionsRule.java
deleted file mode 100644
index b53c0cc..0000000
--- a/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/ExtractOrderExpressionsRule.java
+++ /dev/null
@@ -1,80 +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.asterix.optimizer.rules;
-
-import org.apache.commons.lang3.mutable.Mutable;
-
-import edu.uci.ics.asterix.optimizer.base.AnalysisUtil;
-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.OrderOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.OrderOperator.IOrder;
-import edu.uci.ics.hyracks.algebricks.rewriter.rules.AbstractExtractExprRule;
-
-public class ExtractOrderExpressionsRule extends AbstractExtractExprRule {
-
- @Override
- public boolean rewritePre(Mutable<ILogicalOperator> opRef, IOptimizationContext context) {
- return false;
- }
-
- @Override
- public boolean rewritePost(Mutable<ILogicalOperator> opRef, IOptimizationContext context)
- throws AlgebricksException {
-
- AbstractLogicalOperator op1 = (AbstractLogicalOperator) opRef.getValue();
- if (op1.getOperatorTag() != LogicalOperatorTag.ORDER) {
- return false;
- }
-
- if (context.checkIfInDontApplySet(this, op1)) {
- return false;
- }
- context.addToDontApplySet(this, op1);
- OrderOperator oo = (OrderOperator) op1;
-
- if (!orderHasComplexExpr(oo)) {
- return false;
- }
- Mutable<ILogicalOperator> opRef2 = oo.getInputs().get(0);
- for (Pair<IOrder, Mutable<ILogicalExpression>> orderPair : oo.getOrderExpressions()) {
- ILogicalExpression expr = orderPair.second.getValue();
- if (expr.getExpressionTag() != LogicalExpressionTag.VARIABLE && !AnalysisUtil.isAccessToFieldRecord(expr)) {
- LogicalVariable v = extractExprIntoAssignOpRef(expr, opRef2, context);
- orderPair.second.setValue(new VariableReferenceExpression(v));
- }
- }
- context.computeAndSetTypeEnvironmentForOperator(oo);
- return true;
- }
-
- private boolean orderHasComplexExpr(OrderOperator oo) {
- for (Pair<IOrder, Mutable<ILogicalExpression>> orderPair : oo.getOrderExpressions()) {
- if (orderPair.second.getValue().getExpressionTag() != LogicalExpressionTag.VARIABLE) {
- return true;
- }
- }
- return false;
- }
-
-}
http://git-wip-us.apache.org/repos/asf/incubator-asterixdb/blob/34d81630/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/FeedScanCollectionToUnnest.java
----------------------------------------------------------------------
diff --git a/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/FeedScanCollectionToUnnest.java b/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/FeedScanCollectionToUnnest.java
deleted file mode 100644
index fa7c7f4..0000000
--- a/asterix-algebra/src/main/java/edu/uci/ics/asterix/optimizer/rules/FeedScanCollectionToUnnest.java
+++ /dev/null
@@ -1,135 +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.asterix.optimizer.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.asterix.aql.util.FunctionUtils;
-import edu.uci.ics.asterix.om.functions.AsterixBuiltinFunctions;
-import edu.uci.ics.hyracks.algebricks.common.exceptions.AlgebricksException;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.ILogicalExpression;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.ILogicalOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.IOptimizationContext;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.LogicalExpressionTag;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.LogicalOperatorTag;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.LogicalVariable;
-import edu.uci.ics.hyracks.algebricks.core.algebra.expressions.AbstractFunctionCallExpression;
-import edu.uci.ics.hyracks.algebricks.core.algebra.expressions.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.AbstractAssignOperator;
-import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.AbstractLogicalOperator;
-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;
-
-public class FeedScanCollectionToUnnest 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 (context.checkIfInDontApplySet(this, op)) {
- return false;
- }
- if (op.getOperatorTag() != LogicalOperatorTag.UNNEST) {
- context.addToDontApplySet(this, op);
- return false;
- }
- UnnestOperator unnest = (UnnestOperator) op;
- ILogicalExpression unnestExpr = unnest.getExpressionRef().getValue();
- if (needsScanCollection(unnestExpr, op)) {
- ILogicalExpression newExpr = new UnnestingFunctionCallExpression(
- FunctionUtils.getFunctionInfo(AsterixBuiltinFunctions.SCAN_COLLECTION),
- new MutableObject<ILogicalExpression>(unnestExpr));
- unnest.getExpressionRef().setValue(newExpr);
- context.addToDontApplySet(this, op);
- return true;
- }
- context.addToDontApplySet(this, op);
- return false;
- }
-
- private ILogicalExpression findVarOriginExpression(LogicalVariable v, ILogicalOperator op)
- throws AlgebricksException {
- boolean searchInputs = false;
- if (!(op instanceof AbstractAssignOperator)) {
- searchInputs = true;
- } else {
- AbstractAssignOperator aao = (AbstractAssignOperator) op;
- List<LogicalVariable> producedVars = new ArrayList<>();
- VariableUtilities.getProducedVariables(op, producedVars);
- int exprIndex = producedVars.indexOf(v);
- if (exprIndex == -1) {
- searchInputs = true;
- } else {
- ILogicalExpression originalCandidate = aao.getExpressions().get(exprIndex).getValue();
- if (originalCandidate.getExpressionTag() == LogicalExpressionTag.VARIABLE) {
- searchInputs = true;
- } else {
- return originalCandidate;
- }
- }
- }
-
- if (searchInputs) {
- for (Mutable<ILogicalOperator> childOp : op.getInputs()) {
- ILogicalExpression ret = findVarOriginExpression(v, childOp.getValue());
- if (ret != null) {
- return ret;
- }
- }
- }
-
- throw new IllegalStateException("Unable to find the original expression that produced variable " + v);
- }
-
- private boolean needsScanCollection(ILogicalExpression unnestExpr, ILogicalOperator op) throws AlgebricksException {
- switch (unnestExpr.getExpressionTag()) {
- case VARIABLE: {
- LogicalVariable v = ((VariableReferenceExpression) unnestExpr).getVariableReference();
- ILogicalExpression originalExpr = findVarOriginExpression(v, op);
- if (originalExpr.getExpressionTag() == LogicalExpressionTag.CONSTANT) {
- return false;
- } else {
- return !isUnnestingFunction(originalExpr);
- }
- }
- case FUNCTION_CALL: {
- return !isUnnestingFunction(unnestExpr);
- }
- default: {
- return false;
- }
- }
- }
-
- private boolean isUnnestingFunction(ILogicalExpression expr) {
- if (expr.getExpressionTag() == LogicalExpressionTag.FUNCTION_CALL) {
- AbstractFunctionCallExpression fce = (AbstractFunctionCallExpression) expr;
- return fce.getKind() == FunctionKind.UNNEST;
- }
- return false;
- }
-}