You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@vxquery.apache.org by pr...@apache.org on 2014/04/02 06:11:54 UTC
[14/50] [abbrv] git commit: Enabling hash based join.
Enabling hash based join.
The changes involve two new rules that allow switching between Algebricks Builtin Identifiers and VXQuery equivalent expressions. One more rewrite rule was included to move expressions out of the inner join to allow for hash join to be enabled on variables. Other changes connect these rules to allow for complete hash join implementation.
Project: http://git-wip-us.apache.org/repos/asf/incubator-vxquery/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-vxquery/commit/5771ac4e
Tree: http://git-wip-us.apache.org/repos/asf/incubator-vxquery/tree/5771ac4e
Diff: http://git-wip-us.apache.org/repos/asf/incubator-vxquery/diff/5771ac4e
Branch: refs/heads/prestonc/hash_join
Commit: 5771ac4e82a05d5668d0d8e348110be9c42fba3b
Parents: 80c9654
Author: Preston Carman <pr...@apache.org>
Authored: Wed Mar 12 13:10:34 2014 -0700
Committer: Preston Carman <pr...@apache.org>
Committed: Tue Apr 1 20:56:24 2014 -0700
----------------------------------------------------------------------
.../VXQueryComparatorFactoryProvider.java | 36 +++++-
.../compiler/rewriter/RewriteRuleset.java | 38 ++++--
.../ConvertFromAlgebricksExpressionsRule.java | 94 ++++++++++++++
.../ConvertToAlgebricksExpressionsRule.java | 101 +++++++++++++++
.../rules/PushFunctionsOntoEqJoinBranches.java | 122 +++++++++++++++++++
.../RemoveRedundantBooleanExpressionsRule.java | 69 +++++++++++
.../rewriter/rules/util/ExpressionToolbox.java | 16 ++-
.../metadata/VXQueryMetadataProvider.java | 12 +-
.../bool/FnBooleanScalarEvaluatorFactory.java | 2 +-
.../runtime/functions/util/FunctionHelper.java | 1 +
...VXQueryBinaryHashFunctionFamilyProvider.java | 36 ++++++
.../xmlquery/query/XMLQueryCompiler.java | 6 +-
12 files changed, 512 insertions(+), 21 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/incubator-vxquery/blob/5771ac4e/vxquery-core/src/main/java/org/apache/vxquery/compiler/algebricks/VXQueryComparatorFactoryProvider.java
----------------------------------------------------------------------
diff --git a/vxquery-core/src/main/java/org/apache/vxquery/compiler/algebricks/VXQueryComparatorFactoryProvider.java b/vxquery-core/src/main/java/org/apache/vxquery/compiler/algebricks/VXQueryComparatorFactoryProvider.java
index 5a0e2df..b473d69 100644
--- a/vxquery-core/src/main/java/org/apache/vxquery/compiler/algebricks/VXQueryComparatorFactoryProvider.java
+++ b/vxquery-core/src/main/java/org/apache/vxquery/compiler/algebricks/VXQueryComparatorFactoryProvider.java
@@ -16,7 +16,9 @@
*/
package org.apache.vxquery.compiler.algebricks;
+import org.apache.vxquery.datamodel.accessors.SequencePointable;
import org.apache.vxquery.datamodel.accessors.TaggedValuePointable;
+import org.apache.vxquery.datamodel.values.ValueTag;
import edu.uci.ics.hyracks.algebricks.common.exceptions.AlgebricksException;
import edu.uci.ics.hyracks.algebricks.data.IBinaryComparatorFactoryProvider;
@@ -43,12 +45,44 @@ public class VXQueryComparatorFactoryProvider implements IBinaryComparatorFactor
public IBinaryComparator createBinaryComparator() {
final TaggedValuePointable tvp1 = (TaggedValuePointable) TaggedValuePointable.FACTORY.createPointable();
final TaggedValuePointable tvp2 = (TaggedValuePointable) TaggedValuePointable.FACTORY.createPointable();
+ final SequencePointable sp1 = (SequencePointable) SequencePointable.FACTORY.createPointable();
+ final SequencePointable sp2 = (SequencePointable) SequencePointable.FACTORY.createPointable();
return new IBinaryComparator() {
@Override
public int compare(byte[] b1, int s1, int l1, byte[] b2, int s2, int l2) {
tvp1.set(b1, s1, l1);
tvp2.set(b2, s2, l2);
- return 0;
+ if (tvp1.getTag() != tvp2.getTag()) {
+ return tvp1.getTag() - tvp2.getTag();
+ }
+ // Empty sequences do not match. Supports hash based join.
+ switch (tvp1.getTag()) {
+ case ValueTag.SEQUENCE_TAG:
+ tvp1.getValue(sp1);
+ if (sp1.getEntryCount() == 0) {
+ return -1;
+ }
+
+ switch (tvp2.getTag()) {
+ case ValueTag.SEQUENCE_TAG:
+ tvp2.getValue(sp2);
+ if (sp2.getEntryCount() == 0) {
+ return 1;
+ }
+ break;
+ default:
+ }
+
+ break;
+ default:
+ }
+ // Do a binary compare between byte arrays.
+ for (int i = 0; i < b1.length && i < b2.length; i++) {
+ if (b1[i] != b2[i]) {
+ return b1[i] - b2[i];
+ }
+ }
+ return b1.length - b2.length;
}
};
}
http://git-wip-us.apache.org/repos/asf/incubator-vxquery/blob/5771ac4e/vxquery-core/src/main/java/org/apache/vxquery/compiler/rewriter/RewriteRuleset.java
----------------------------------------------------------------------
diff --git a/vxquery-core/src/main/java/org/apache/vxquery/compiler/rewriter/RewriteRuleset.java b/vxquery-core/src/main/java/org/apache/vxquery/compiler/rewriter/RewriteRuleset.java
index 16c44b8..ab0d535 100644
--- a/vxquery-core/src/main/java/org/apache/vxquery/compiler/rewriter/RewriteRuleset.java
+++ b/vxquery-core/src/main/java/org/apache/vxquery/compiler/rewriter/RewriteRuleset.java
@@ -20,6 +20,8 @@ import java.util.LinkedList;
import java.util.List;
import org.apache.vxquery.compiler.rewriter.rules.ConsolidateAssignAggregateRule;
+import org.apache.vxquery.compiler.rewriter.rules.ConvertFromAlgebricksExpressionsRule;
+import org.apache.vxquery.compiler.rewriter.rules.ConvertToAlgebricksExpressionsRule;
import org.apache.vxquery.compiler.rewriter.rules.InlineNestedVariablesRule;
import org.apache.vxquery.compiler.rewriter.rules.PushChildIntoDataScanRule;
import org.apache.vxquery.compiler.rewriter.rules.ConsolidateUnnestsRule;
@@ -30,7 +32,9 @@ import org.apache.vxquery.compiler.rewriter.rules.EliminateUnnestAggregateSequen
import org.apache.vxquery.compiler.rewriter.rules.EliminateUnnestAggregateSubplanRule;
import org.apache.vxquery.compiler.rewriter.rules.IntroduceCollectionRule;
import org.apache.vxquery.compiler.rewriter.rules.IntroduceTwoStepAggregateRule;
+import org.apache.vxquery.compiler.rewriter.rules.PushFunctionsOntoEqJoinBranches;
import org.apache.vxquery.compiler.rewriter.rules.PushMapOperatorDownThroughProductRule;
+import org.apache.vxquery.compiler.rewriter.rules.RemoveRedundantBooleanExpressionsRule;
import org.apache.vxquery.compiler.rewriter.rules.RemoveRedundantCastExpressionsRule;
import org.apache.vxquery.compiler.rewriter.rules.RemoveRedundantDataExpressionsRule;
import org.apache.vxquery.compiler.rewriter.rules.RemoveRedundantPromoteExpressionsRule;
@@ -147,14 +151,32 @@ public class RewriteRuleset {
}
/**
+ * Remove expressions known to be redundant.
+ */
+ public final static List<IAlgebraicRewriteRule> buildRedundantExpressionNormalizationRuleCollection() {
+ List<IAlgebraicRewriteRule> normalization = new LinkedList<IAlgebraicRewriteRule>();
+ normalization.add(new InlineNestedVariablesRule());
+ normalization.add(new RemoveRedundantTreatExpressionsRule());
+ normalization.add(new RemoveRedundantDataExpressionsRule());
+ normalization.add(new RemoveRedundantPromoteExpressionsRule());
+ normalization.add(new RemoveRedundantCastExpressionsRule());
+ normalization.add(new ConvertToAlgebricksExpressionsRule());
+ normalization.add(new RemoveRedundantBooleanExpressionsRule());
+ // Clean up
+ normalization.add(new RemoveRedundantVariablesRule());
+ normalization.add(new RemoveUnusedAssignAndAggregateRule());
+ return normalization;
+ }
+
+ /**
* When a nested data sources exist, convert the plan to use the join operator.
*/
public final static List<IAlgebraicRewriteRule> buildNestedDataSourceRuleCollection() {
List<IAlgebraicRewriteRule> xquery = new LinkedList<IAlgebraicRewriteRule>();
+ xquery.add(new BreakSelectIntoConjunctsRule());
xquery.add(new SimpleUnnestToProductRule());
xquery.add(new PushMapOperatorDownThroughProductRule());
xquery.add(new PushSubplanWithAggregateDownThroughProductRule());
- xquery.add(new InlineNestedVariablesRule());
xquery.add(new PushSelectDownRule());
xquery.add(new PushSelectIntoJoinRule());
// Clean up
@@ -163,18 +185,6 @@ public class RewriteRuleset {
return xquery;
}
- public final static List<IAlgebraicRewriteRule> buildRedundantExpressionNormalizationRuleCollection() {
- List<IAlgebraicRewriteRule> normalization = new LinkedList<IAlgebraicRewriteRule>();
- normalization.add(new RemoveRedundantTreatExpressionsRule());
- normalization.add(new RemoveRedundantDataExpressionsRule());
- normalization.add(new RemoveRedundantPromoteExpressionsRule());
- normalization.add(new RemoveRedundantCastExpressionsRule());
- // Clean up
- normalization.add(new RemoveRedundantVariablesRule());
- normalization.add(new RemoveUnusedAssignAndAggregateRule());
- return normalization;
- }
-
public final static List<IAlgebraicRewriteRule> buildTypeInferenceRuleCollection() {
List<IAlgebraicRewriteRule> typeInfer = new LinkedList<IAlgebraicRewriteRule>();
typeInfer.add(new InferTypesRule());
@@ -239,6 +249,7 @@ public class RewriteRuleset {
public final static List<IAlgebraicRewriteRule> buildPhysicalRewritesAllLevelsRuleCollection() {
List<IAlgebraicRewriteRule> physicalPlanRewrites = new LinkedList<IAlgebraicRewriteRule>();
physicalPlanRewrites.add(new PullSelectOutOfEqJoin());
+ physicalPlanRewrites.add(new PushFunctionsOntoEqJoinBranches());
physicalPlanRewrites.add(new SetAlgebricksPhysicalOperatorsRule());
physicalPlanRewrites.add(new EnforceStructuralPropertiesRule());
physicalPlanRewrites.add(new PushProjectDownRule());
@@ -254,6 +265,7 @@ public class RewriteRuleset {
public final static List<IAlgebraicRewriteRule> prepareForJobGenRuleCollection() {
List<IAlgebraicRewriteRule> prepareForJobGenRewrites = new LinkedList<IAlgebraicRewriteRule>();
+ prepareForJobGenRewrites.add(new ConvertFromAlgebricksExpressionsRule());
prepareForJobGenRewrites.add(new IsolateHyracksOperatorsRule(
HeuristicOptimizer.hyraxOperatorsBelowWhichJobGenIsDisabled));
prepareForJobGenRewrites.add(new ExtractCommonOperatorsRule());
http://git-wip-us.apache.org/repos/asf/incubator-vxquery/blob/5771ac4e/vxquery-core/src/main/java/org/apache/vxquery/compiler/rewriter/rules/ConvertFromAlgebricksExpressionsRule.java
----------------------------------------------------------------------
diff --git a/vxquery-core/src/main/java/org/apache/vxquery/compiler/rewriter/rules/ConvertFromAlgebricksExpressionsRule.java b/vxquery-core/src/main/java/org/apache/vxquery/compiler/rewriter/rules/ConvertFromAlgebricksExpressionsRule.java
new file mode 100644
index 0000000..482f05d
--- /dev/null
+++ b/vxquery-core/src/main/java/org/apache/vxquery/compiler/rewriter/rules/ConvertFromAlgebricksExpressionsRule.java
@@ -0,0 +1,94 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 at
+ *
+ * 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 org.apache.vxquery.compiler.rewriter.rules;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.commons.lang3.mutable.Mutable;
+import org.apache.commons.lang3.mutable.MutableObject;
+import org.apache.vxquery.compiler.rewriter.rules.util.ExpressionToolbox;
+import org.apache.vxquery.compiler.rewriter.rules.util.OperatorToolbox;
+import org.apache.vxquery.functions.BuiltinFunctions;
+import org.apache.vxquery.functions.BuiltinOperators;
+
+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.expressions.AbstractFunctionCallExpression;
+import edu.uci.ics.hyracks.algebricks.core.algebra.expressions.ScalarFunctionCallExpression;
+import edu.uci.ics.hyracks.algebricks.core.algebra.functions.AlgebricksBuiltinFunctions;
+import edu.uci.ics.hyracks.algebricks.core.algebra.functions.FunctionIdentifier;
+import edu.uci.ics.hyracks.algebricks.core.algebra.functions.IFunctionInfo;
+import edu.uci.ics.hyracks.algebricks.core.rewriter.base.IAlgebraicRewriteRule;
+
+public class ConvertFromAlgebricksExpressionsRule implements IAlgebraicRewriteRule {
+ final List<Mutable<ILogicalExpression>> functionList = new ArrayList<Mutable<ILogicalExpression>>();
+
+ final Map<FunctionIdentifier, IFunctionInfo> ALGEBRICKS_MAP = new HashMap<FunctionIdentifier, IFunctionInfo>();
+
+ public ConvertFromAlgebricksExpressionsRule() {
+ ALGEBRICKS_MAP.put(AlgebricksBuiltinFunctions.AND, BuiltinOperators.AND);
+ ALGEBRICKS_MAP.put(AlgebricksBuiltinFunctions.OR, BuiltinOperators.OR);
+ ALGEBRICKS_MAP.put(AlgebricksBuiltinFunctions.NOT, BuiltinFunctions.FN_NOT_1);
+ ALGEBRICKS_MAP.put(AlgebricksBuiltinFunctions.EQ, BuiltinOperators.VALUE_EQ);
+ ALGEBRICKS_MAP.put(AlgebricksBuiltinFunctions.NEQ, BuiltinOperators.VALUE_NE);
+ ALGEBRICKS_MAP.put(AlgebricksBuiltinFunctions.LT, BuiltinOperators.VALUE_LT);
+ ALGEBRICKS_MAP.put(AlgebricksBuiltinFunctions.LE, BuiltinOperators.VALUE_LE);
+ ALGEBRICKS_MAP.put(AlgebricksBuiltinFunctions.GT, BuiltinOperators.VALUE_GT);
+ ALGEBRICKS_MAP.put(AlgebricksBuiltinFunctions.GE, BuiltinOperators.VALUE_GE);
+ }
+
+ @Override
+ public boolean rewritePre(Mutable<ILogicalOperator> opRef, IOptimizationContext context) throws AlgebricksException {
+ return false;
+ }
+
+ @Override
+ public boolean rewritePost(Mutable<ILogicalOperator> opRef, IOptimizationContext context)
+ throws AlgebricksException {
+ boolean modified = false;
+ List<Mutable<ILogicalExpression>> expressions = OperatorToolbox.getExpressions(opRef);
+ for (Mutable<ILogicalExpression> expression : expressions) {
+ if (processExpression(opRef, expression)) {
+ modified = true;
+ }
+ }
+ return modified;
+ }
+
+ private boolean processExpression(Mutable<ILogicalOperator> opRef, Mutable<ILogicalExpression> search) {
+ boolean modified = false;
+ for (FunctionIdentifier fid : ALGEBRICKS_MAP.keySet()) {
+ functionList.clear();
+ ExpressionToolbox.findAllFunctionExpressions(search, fid, functionList);
+ for (Mutable<ILogicalExpression> searchM : functionList) {
+ AbstractFunctionCallExpression searchFunction = (AbstractFunctionCallExpression) searchM.getValue();
+ searchFunction.setFunctionInfo(ALGEBRICKS_MAP.get(fid));
+ // Add boolean function before vxquery expression.
+ ScalarFunctionCallExpression booleanExp = new ScalarFunctionCallExpression(BuiltinFunctions.FN_BOOLEAN_1, new MutableObject<ILogicalExpression>(searchM.getValue()));
+ searchM.setValue(booleanExp);
+ modified = true;
+ }
+ }
+ return modified;
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/incubator-vxquery/blob/5771ac4e/vxquery-core/src/main/java/org/apache/vxquery/compiler/rewriter/rules/ConvertToAlgebricksExpressionsRule.java
----------------------------------------------------------------------
diff --git a/vxquery-core/src/main/java/org/apache/vxquery/compiler/rewriter/rules/ConvertToAlgebricksExpressionsRule.java b/vxquery-core/src/main/java/org/apache/vxquery/compiler/rewriter/rules/ConvertToAlgebricksExpressionsRule.java
new file mode 100644
index 0000000..ebe265e
--- /dev/null
+++ b/vxquery-core/src/main/java/org/apache/vxquery/compiler/rewriter/rules/ConvertToAlgebricksExpressionsRule.java
@@ -0,0 +1,101 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 at
+ *
+ * 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 org.apache.vxquery.compiler.rewriter.rules;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.commons.lang3.mutable.Mutable;
+import org.apache.vxquery.compiler.rewriter.rules.util.ExpressionToolbox;
+import org.apache.vxquery.compiler.rewriter.rules.util.OperatorToolbox;
+import org.apache.vxquery.functions.BuiltinFunctions;
+import org.apache.vxquery.functions.BuiltinOperators;
+
+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.expressions.AbstractFunctionCallExpression;
+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.rewriter.base.IAlgebraicRewriteRule;
+
+public class ConvertToAlgebricksExpressionsRule implements IAlgebraicRewriteRule {
+ final List<Mutable<ILogicalExpression>> functionList = new ArrayList<Mutable<ILogicalExpression>>();
+
+ final Map<FunctionIdentifier, FunctionIdentifier> ALGEBRICKS_MAP = new HashMap<FunctionIdentifier, FunctionIdentifier>();
+
+ public ConvertToAlgebricksExpressionsRule() {
+ ALGEBRICKS_MAP.put(BuiltinOperators.AND.getFunctionIdentifier(), AlgebricksBuiltinFunctions.AND);
+ ALGEBRICKS_MAP.put(BuiltinOperators.OR.getFunctionIdentifier(), AlgebricksBuiltinFunctions.OR);
+ ALGEBRICKS_MAP.put(BuiltinFunctions.FN_NOT_1.getFunctionIdentifier(), AlgebricksBuiltinFunctions.NOT);
+ ALGEBRICKS_MAP.put(BuiltinOperators.VALUE_EQ.getFunctionIdentifier(), AlgebricksBuiltinFunctions.EQ);
+ ALGEBRICKS_MAP.put(BuiltinOperators.VALUE_NE.getFunctionIdentifier(), AlgebricksBuiltinFunctions.NEQ);
+ ALGEBRICKS_MAP.put(BuiltinOperators.VALUE_LT.getFunctionIdentifier(), AlgebricksBuiltinFunctions.LT);
+ ALGEBRICKS_MAP.put(BuiltinOperators.VALUE_LE.getFunctionIdentifier(), AlgebricksBuiltinFunctions.LE);
+ ALGEBRICKS_MAP.put(BuiltinOperators.VALUE_GT.getFunctionIdentifier(), AlgebricksBuiltinFunctions.GT);
+ ALGEBRICKS_MAP.put(BuiltinOperators.VALUE_GE.getFunctionIdentifier(), AlgebricksBuiltinFunctions.GE);
+ }
+
+ @Override
+ public boolean rewritePre(Mutable<ILogicalOperator> opRef, IOptimizationContext context) throws AlgebricksException {
+ return false;
+ }
+
+ @Override
+ public boolean rewritePost(Mutable<ILogicalOperator> opRef, IOptimizationContext context)
+ throws AlgebricksException {
+ boolean modified = false;
+ List<Mutable<ILogicalExpression>> expressions = OperatorToolbox.getExpressions(opRef);
+ for (Mutable<ILogicalExpression> expression : expressions) {
+ if (processExpression(opRef, expression, context)) {
+ modified = true;
+ }
+ }
+ return modified;
+ }
+
+ private boolean processExpression(Mutable<ILogicalOperator> opRef, Mutable<ILogicalExpression> search,
+ IOptimizationContext context) {
+ boolean modified = false;
+ functionList.clear();
+ ExpressionToolbox.findAllFunctionExpressions(search, BuiltinFunctions.FN_BOOLEAN_1.getFunctionIdentifier(),
+ functionList);
+ for (Mutable<ILogicalExpression> searchM : functionList) {
+ // Get input function
+ AbstractFunctionCallExpression searchFunction = (AbstractFunctionCallExpression) searchM.getValue();
+ ILogicalExpression argFirst = searchFunction.getArguments().get(0).getValue();
+ if (argFirst.getExpressionTag() != LogicalExpressionTag.FUNCTION_CALL) {
+ continue;
+ }
+ AbstractFunctionCallExpression functionCall = (AbstractFunctionCallExpression) argFirst;
+ if (ALGEBRICKS_MAP.containsKey(functionCall.getFunctionIdentifier())) {
+ FunctionIdentifier algebricksFid = ALGEBRICKS_MAP.get(functionCall.getFunctionIdentifier());
+ IFunctionInfo algebricksFunction = context.getMetadataProvider().lookupFunction(algebricksFid);
+ functionCall.setFunctionInfo(algebricksFunction);
+ searchM.setValue(argFirst);
+ modified = true;
+ }
+ }
+ return modified;
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/incubator-vxquery/blob/5771ac4e/vxquery-core/src/main/java/org/apache/vxquery/compiler/rewriter/rules/PushFunctionsOntoEqJoinBranches.java
----------------------------------------------------------------------
diff --git a/vxquery-core/src/main/java/org/apache/vxquery/compiler/rewriter/rules/PushFunctionsOntoEqJoinBranches.java b/vxquery-core/src/main/java/org/apache/vxquery/compiler/rewriter/rules/PushFunctionsOntoEqJoinBranches.java
new file mode 100644
index 0000000..96b36a5
--- /dev/null
+++ b/vxquery-core/src/main/java/org/apache/vxquery/compiler/rewriter/rules/PushFunctionsOntoEqJoinBranches.java
@@ -0,0 +1,122 @@
+/*
+ * 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 org.apache.vxquery.compiler.rewriter.rules;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+import org.apache.commons.lang3.mutable.Mutable;
+import org.apache.commons.lang3.mutable.MutableObject;
+import org.apache.vxquery.compiler.rewriter.rules.util.ExpressionToolbox;
+
+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.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.operators.logical.AbstractBinaryJoinOperator;
+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.algebra.operators.logical.visitors.VariableUtilities;
+import edu.uci.ics.hyracks.algebricks.core.rewriter.base.IAlgebraicRewriteRule;
+
+public class PushFunctionsOntoEqJoinBranches 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.INNERJOIN) {
+ return false;
+ }
+ AbstractBinaryJoinOperator join = (AbstractBinaryJoinOperator) op;
+
+ ILogicalExpression expr = join.getCondition().getValue();
+ if (expr.getExpressionTag() != LogicalExpressionTag.FUNCTION_CALL) {
+ return false;
+ }
+ AbstractFunctionCallExpression fexp = (AbstractFunctionCallExpression) expr;
+ FunctionIdentifier fi = fexp.getFunctionIdentifier();
+ if (!(fi.equals(AlgebricksBuiltinFunctions.AND) || fi.equals(AlgebricksBuiltinFunctions.EQ))) {
+ return false;
+ }
+ boolean modified = false;
+ List<Mutable<ILogicalExpression>> functionList = new ArrayList<Mutable<ILogicalExpression>>();
+ List<Mutable<ILogicalExpression>> variableList = new ArrayList<Mutable<ILogicalExpression>>();
+ functionList.clear();
+ ExpressionToolbox.findAllFunctionExpressions(join.getCondition(), AlgebricksBuiltinFunctions.EQ, functionList);
+ Collection<LogicalVariable> producedVariables = new ArrayList<LogicalVariable>();
+ for (Mutable<ILogicalExpression> searchM : functionList) {
+ ILogicalExpression search = searchM.getValue();
+ if (search.getExpressionTag() != LogicalExpressionTag.FUNCTION_CALL) {
+ continue;
+ }
+ AbstractFunctionCallExpression searchExp = (AbstractFunctionCallExpression) search;
+ // Go through all argument for EQ.
+ for (Mutable<ILogicalExpression> expressionM : searchExp.getArguments()) {
+ // Push on to branch when possible.
+ for (Mutable<ILogicalOperator> branch : join.getInputs()) {
+ producedVariables.clear();
+ getProducedVariablesInDescendantsAndSelf(branch.getValue(), producedVariables);
+ variableList.clear();
+ ExpressionToolbox.findVariableExpressions(expressionM, variableList);
+ boolean found = true;
+ for (Mutable<ILogicalExpression> searchVariableM : variableList) {
+ VariableReferenceExpression vre = (VariableReferenceExpression) searchVariableM.getValue();
+ if (!producedVariables.contains(vre.getVariableReference())) {
+ found = false;
+ }
+ }
+ if (found) {
+ // push down
+ LogicalVariable assignVariable = context.newVar();
+ AssignOperator aOp = new AssignOperator(assignVariable, new MutableObject<ILogicalExpression>(expressionM.getValue()));
+ aOp.getInputs().add(new MutableObject<ILogicalOperator>(branch.getValue()));
+ branch.setValue(aOp);
+ aOp.recomputeSchema();
+
+ expressionM.setValue(new VariableReferenceExpression(assignVariable));
+ modified = true;
+ }
+ }
+ }
+ }
+ return modified;
+ }
+
+ public static void getProducedVariablesInDescendantsAndSelf(ILogicalOperator op, Collection<LogicalVariable> vars)
+ throws AlgebricksException {
+ // DFS traversal
+ VariableUtilities.getProducedVariables(op, vars);
+ for (Mutable<ILogicalOperator> c : op.getInputs()) {
+ getProducedVariablesInDescendantsAndSelf(c.getValue(), vars);
+ }
+ }
+
+
+}
http://git-wip-us.apache.org/repos/asf/incubator-vxquery/blob/5771ac4e/vxquery-core/src/main/java/org/apache/vxquery/compiler/rewriter/rules/RemoveRedundantBooleanExpressionsRule.java
----------------------------------------------------------------------
diff --git a/vxquery-core/src/main/java/org/apache/vxquery/compiler/rewriter/rules/RemoveRedundantBooleanExpressionsRule.java b/vxquery-core/src/main/java/org/apache/vxquery/compiler/rewriter/rules/RemoveRedundantBooleanExpressionsRule.java
new file mode 100644
index 0000000..ba129c0
--- /dev/null
+++ b/vxquery-core/src/main/java/org/apache/vxquery/compiler/rewriter/rules/RemoveRedundantBooleanExpressionsRule.java
@@ -0,0 +1,69 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 at
+ *
+ * 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 org.apache.vxquery.compiler.rewriter.rules;
+
+import org.apache.vxquery.functions.BuiltinFunctions;
+import org.apache.vxquery.runtime.functions.type.SequenceTypeMatcher;
+import org.apache.vxquery.types.BuiltinTypeRegistry;
+import org.apache.vxquery.types.Quantifier;
+import org.apache.vxquery.types.SequenceType;
+
+import edu.uci.ics.hyracks.algebricks.core.algebra.functions.FunctionIdentifier;
+
+/**
+ * The rule searches for where the xquery boolean function is used. When the
+ * expressions input is already a boolean value, remove the boolean function.
+ *
+ * <pre>
+ * Before
+ *
+ * plan__parent
+ * %OPERATOR( $v1 : boolean( \@input_expression ) )
+ * plan__child
+ *
+ * Where treat \@input_expression is known to be a boolean value.
+ *
+ * After
+ *
+ * plan__parent
+ * %OPERATOR( $v1 : \@input_expression )
+ * plan__child
+ * </pre>
+ *
+ * @author prestonc
+ */
+
+public class RemoveRedundantBooleanExpressionsRule extends AbstractRemoveRedundantTypeExpressionsRule {
+ final SequenceTypeMatcher stm = new SequenceTypeMatcher();
+
+ protected FunctionIdentifier getSearchFunction() {
+ return BuiltinFunctions.FN_BOOLEAN_1.getFunctionIdentifier();
+ }
+
+ @Override
+ public boolean hasTypeArgument() {
+ return false;
+ }
+
+ public boolean matchesAllInstancesOf(SequenceType sTypeArg, SequenceType sTypeOutput) {
+ stm.setSequenceType(SequenceType.create(BuiltinTypeRegistry.XS_BOOLEAN, Quantifier.QUANT_ONE));
+ if (sTypeOutput != null && stm.matchesAllInstances(sTypeOutput)) {
+ return true;
+ }
+ return false;
+ }
+}
http://git-wip-us.apache.org/repos/asf/incubator-vxquery/blob/5771ac4e/vxquery-core/src/main/java/org/apache/vxquery/compiler/rewriter/rules/util/ExpressionToolbox.java
----------------------------------------------------------------------
diff --git a/vxquery-core/src/main/java/org/apache/vxquery/compiler/rewriter/rules/util/ExpressionToolbox.java b/vxquery-core/src/main/java/org/apache/vxquery/compiler/rewriter/rules/util/ExpressionToolbox.java
index dc9e0d3..78ceeb7 100644
--- a/vxquery-core/src/main/java/org/apache/vxquery/compiler/rewriter/rules/util/ExpressionToolbox.java
+++ b/vxquery-core/src/main/java/org/apache/vxquery/compiler/rewriter/rules/util/ExpressionToolbox.java
@@ -78,6 +78,18 @@ public class ExpressionToolbox {
return null;
}
+ public static void findVariableExpressions(Mutable<ILogicalExpression> mutableLe, List<Mutable<ILogicalExpression>> finds) {
+ ILogicalExpression le = mutableLe.getValue();
+ if (le.getExpressionTag() == LogicalExpressionTag.VARIABLE) {
+ finds.add(mutableLe);
+ } else if (le.getExpressionTag() == LogicalExpressionTag.FUNCTION_CALL) {
+ AbstractFunctionCallExpression afce = (AbstractFunctionCallExpression) le;
+ for (Mutable<ILogicalExpression> argExp : afce.getArguments()) {
+ findVariableExpressions(argExp, finds);
+ }
+ }
+ }
+
public static Mutable<ILogicalExpression> findLastFunctionExpression(Mutable<ILogicalExpression> mutableLe) {
ILogicalExpression le = mutableLe.getValue();
if (le.getExpressionTag() == LogicalExpressionTag.VARIABLE) {
@@ -180,12 +192,12 @@ public class ExpressionToolbox {
}
public static SequenceType getOutputSequenceType(Mutable<ILogicalOperator> opRef,
- Mutable<ILogicalExpression> argFirstM, StaticContextImpl dCtx) {
+ Mutable<ILogicalExpression> argFirstM, StaticContext dCtx) {
ILogicalExpression argFirstLe = argFirstM.getValue();
switch (argFirstLe.getExpressionTag()) {
case FUNCTION_CALL:
// Only process defined functions.
- Function function = ExpressionToolbox.getBuiltIn(argFirstM);
+ Function function = ExpressionToolbox.getBuiltIn(argFirstM, dCtx);
if (function == null) {
return null;
} else if (function.getFunctionIdentifier().equals(BuiltinOperators.CAST.getFunctionIdentifier())) {
http://git-wip-us.apache.org/repos/asf/incubator-vxquery/blob/5771ac4e/vxquery-core/src/main/java/org/apache/vxquery/metadata/VXQueryMetadataProvider.java
----------------------------------------------------------------------
diff --git a/vxquery-core/src/main/java/org/apache/vxquery/metadata/VXQueryMetadataProvider.java b/vxquery-core/src/main/java/org/apache/vxquery/metadata/VXQueryMetadataProvider.java
index cd323d9..71963be 100644
--- a/vxquery-core/src/main/java/org/apache/vxquery/metadata/VXQueryMetadataProvider.java
+++ b/vxquery-core/src/main/java/org/apache/vxquery/metadata/VXQueryMetadataProvider.java
@@ -146,8 +146,16 @@ public class VXQueryMetadataProvider implements IMetadataProvider<String, String
}
@Override
- public IFunctionInfo lookupFunction(FunctionIdentifier fid) {
- return null;
+ public IFunctionInfo lookupFunction(final FunctionIdentifier fid) {
+ return new IFunctionInfo() {
+ @Override
+ public FunctionIdentifier getFunctionIdentifier() {
+ return fid;
+ }
+ public boolean isFunctional() {
+ return true;
+ }
+ };
}
@Override
http://git-wip-us.apache.org/repos/asf/incubator-vxquery/blob/5771ac4e/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/bool/FnBooleanScalarEvaluatorFactory.java
----------------------------------------------------------------------
diff --git a/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/bool/FnBooleanScalarEvaluatorFactory.java b/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/bool/FnBooleanScalarEvaluatorFactory.java
index a6a1d0b..b9c8c6f 100644
--- a/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/bool/FnBooleanScalarEvaluatorFactory.java
+++ b/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/bool/FnBooleanScalarEvaluatorFactory.java
@@ -53,7 +53,7 @@ public class FnBooleanScalarEvaluatorFactory extends AbstractTaggedValueArgument
}
private static class FnBooleanScalarEvaluator extends AbstractTaggedValueArgumentScalarEvaluator {
- final SequencePointable seqp = new SequencePointable();
+ final SequencePointable seqp = (SequencePointable) SequencePointable.FACTORY.createPointable();
final LongPointable lp = (LongPointable) LongPointable.FACTORY.createPointable();
final IntegerPointable ip = (IntegerPointable) IntegerPointable.FACTORY.createPointable();
final ShortPointable sp = (ShortPointable) ShortPointable.FACTORY.createPointable();
http://git-wip-us.apache.org/repos/asf/incubator-vxquery/blob/5771ac4e/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/util/FunctionHelper.java
----------------------------------------------------------------------
diff --git a/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/util/FunctionHelper.java b/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/util/FunctionHelper.java
index cd8d632..a7d7186 100644
--- a/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/util/FunctionHelper.java
+++ b/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/util/FunctionHelper.java
@@ -1200,6 +1200,7 @@ public class FunctionHelper {
public static boolean isDerivedFromString(int tid) {
switch (tid) {
+ case ValueTag.XS_UNTYPED_ATOMIC_TAG:
case ValueTag.XS_STRING_TAG:
case ValueTag.XS_NORMALIZED_STRING_TAG:
case ValueTag.XS_TOKEN_TAG:
http://git-wip-us.apache.org/repos/asf/incubator-vxquery/blob/5771ac4e/vxquery-core/src/main/java/org/apache/vxquery/runtime/provider/VXQueryBinaryHashFunctionFamilyProvider.java
----------------------------------------------------------------------
diff --git a/vxquery-core/src/main/java/org/apache/vxquery/runtime/provider/VXQueryBinaryHashFunctionFamilyProvider.java b/vxquery-core/src/main/java/org/apache/vxquery/runtime/provider/VXQueryBinaryHashFunctionFamilyProvider.java
new file mode 100644
index 0000000..b73cc75
--- /dev/null
+++ b/vxquery-core/src/main/java/org/apache/vxquery/runtime/provider/VXQueryBinaryHashFunctionFamilyProvider.java
@@ -0,0 +1,36 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 at
+ *
+ * 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 org.apache.vxquery.runtime.provider;
+
+import edu.uci.ics.hyracks.algebricks.common.exceptions.AlgebricksException;
+import edu.uci.ics.hyracks.algebricks.data.IBinaryHashFunctionFamilyProvider;
+import edu.uci.ics.hyracks.api.dataflow.value.IBinaryHashFunctionFamily;
+import edu.uci.ics.hyracks.data.std.accessors.MurmurHash3BinaryHashFunctionFamily;
+
+public class VXQueryBinaryHashFunctionFamilyProvider implements IBinaryHashFunctionFamilyProvider {
+
+ public static final VXQueryBinaryHashFunctionFamilyProvider INSTANCE = new VXQueryBinaryHashFunctionFamilyProvider();
+
+ private VXQueryBinaryHashFunctionFamilyProvider() {
+ }
+
+ @Override
+ public IBinaryHashFunctionFamily getBinaryHashFunctionFamily(Object type) throws AlgebricksException {
+ return MurmurHash3BinaryHashFunctionFamily.INSTANCE;
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/incubator-vxquery/blob/5771ac4e/vxquery-core/src/main/java/org/apache/vxquery/xmlquery/query/XMLQueryCompiler.java
----------------------------------------------------------------------
diff --git a/vxquery-core/src/main/java/org/apache/vxquery/xmlquery/query/XMLQueryCompiler.java b/vxquery-core/src/main/java/org/apache/vxquery/xmlquery/query/XMLQueryCompiler.java
index e6a9007..54bac7e 100644
--- a/vxquery-core/src/main/java/org/apache/vxquery/xmlquery/query/XMLQueryCompiler.java
+++ b/vxquery-core/src/main/java/org/apache/vxquery/xmlquery/query/XMLQueryCompiler.java
@@ -33,6 +33,7 @@ import org.apache.vxquery.exceptions.ErrorCode;
import org.apache.vxquery.exceptions.SystemException;
import org.apache.vxquery.metadata.VXQueryMetadataProvider;
import org.apache.vxquery.runtime.provider.VXQueryBinaryHashFunctionFactoryProvider;
+import org.apache.vxquery.runtime.provider.VXQueryBinaryHashFunctionFamilyProvider;
import org.apache.vxquery.types.BuiltinTypeRegistry;
import org.apache.vxquery.types.Quantifier;
import org.apache.vxquery.types.SequenceType;
@@ -115,6 +116,7 @@ public class XMLQueryCompiler {
}
});
builder.setHashFunctionFactoryProvider(VXQueryBinaryHashFunctionFactoryProvider.INSTANCE);
+ builder.setHashFunctionFamilyProvider(VXQueryBinaryHashFunctionFamilyProvider.INSTANCE);
builder.setTypeTraitProvider(new ITypeTraitProvider() {
@Override
public ITypeTraits getTypeTrait(Object type) {
@@ -196,9 +198,9 @@ public class XMLQueryCompiler {
defaultLogicalRewrites.add(new Pair<AbstractRuleController, List<IAlgebraicRewriteRule>>(priorityCtrl,
RewriteRuleset.buildXQueryNormalizationRuleCollection()));
defaultLogicalRewrites.add(new Pair<AbstractRuleController, List<IAlgebraicRewriteRule>>(seqCtrlFullDfs,
- RewriteRuleset.buildNestedDataSourceRuleCollection()));
- defaultLogicalRewrites.add(new Pair<AbstractRuleController, List<IAlgebraicRewriteRule>>(seqCtrlFullDfs,
RewriteRuleset.buildRedundantExpressionNormalizationRuleCollection()));
+ defaultLogicalRewrites.add(new Pair<AbstractRuleController, List<IAlgebraicRewriteRule>>(priorityCtrl,
+ RewriteRuleset.buildNestedDataSourceRuleCollection()));
defaultLogicalRewrites.add(new Pair<AbstractRuleController, List<IAlgebraicRewriteRule>>(seqOnceCtrl,
RewriteRuleset.buildTypeInferenceRuleCollection()));
defaultLogicalRewrites.add(new Pair<AbstractRuleController, List<IAlgebraicRewriteRule>>(seqCtrlFullDfs,