>From Wail Alkowaileet <[email protected]>:
Wail Alkowaileet has uploaded this change for review. (
https://asterix-gerrit.ics.uci.edu/c/asterixdb/+/17303 )
Change subject: [WIP] Muliple fixes for non-pure functions
......................................................................
[WIP] Muliple fixes for non-pure functions
Change-Id: I717fdfca8d09144443b1f49c5588defeb895766e
---
A
asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/RemoveUnknownCheckForKnownTypesRule.java
A
asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/RemoveOrReplaceDefaultNullCastRule.java
M
asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/base/RuleCollections.java
M
asterixdb/asterix-lang-sqlpp/src/main/java/org/apache/asterix/lang/sqlpp/rewrites/SqlppFunctionBodyRewriter.java
4 files changed, 282 insertions(+), 0 deletions(-)
git pull ssh://asterix-gerrit.ics.uci.edu:29418/asterixdb
refs/changes/03/17303/1
diff --git
a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/base/RuleCollections.java
b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/base/RuleCollections.java
index 5493dd1..d68c99f 100644
---
a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/base/RuleCollections.java
+++
b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/base/RuleCollections.java
@@ -80,9 +80,11 @@
import
org.apache.asterix.optimizer.rules.PushValueAccessToExternalDataScanRule;
import org.apache.asterix.optimizer.rules.RemoveDuplicateFieldsRule;
import
org.apache.asterix.optimizer.rules.RemoveLeftOuterUnnestForLeftOuterJoinRule;
+import org.apache.asterix.optimizer.rules.RemoveOrReplaceDefaultNullCastRule;
import org.apache.asterix.optimizer.rules.RemoveRedundantListifyRule;
import org.apache.asterix.optimizer.rules.RemoveRedundantSelectRule;
import org.apache.asterix.optimizer.rules.RemoveSortInFeedIngestionRule;
+import org.apache.asterix.optimizer.rules.RemoveUnknownCheckForKnownTypesRule;
import org.apache.asterix.optimizer.rules.RemoveUnusedOneToOneEquiJoinRule;
import org.apache.asterix.optimizer.rules.RewriteDistinctAggregateRule;
import org.apache.asterix.optimizer.rules.SetAsterixMemoryRequirementsRule;
@@ -218,6 +220,8 @@
normalization.add(new MetaFunctionToMetaVariableRule());
normalization.add(new FuzzyEqRule());
normalization.add(new SimilarityCheckRule());
+ normalization.add(new RemoveOrReplaceDefaultNullCastRule());
+ normalization.add(new RemoveUnknownCheckForKnownTypesRule());
return normalization;
}
diff --git
a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/RemoveOrReplaceDefaultNullCastRule.java
b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/RemoveOrReplaceDefaultNullCastRule.java
new file mode 100644
index 0000000..e226a70
--- /dev/null
+++
b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/RemoveOrReplaceDefaultNullCastRule.java
@@ -0,0 +1,160 @@
+/*
+ * 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.asterix.optimizer.rules;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.asterix.metadata.declared.MetadataProvider;
+import org.apache.asterix.om.functions.BuiltinFunctions;
+import org.apache.asterix.om.types.ATypeTag;
+import org.apache.asterix.om.types.AUnionType;
+import org.apache.asterix.om.types.IAType;
+import org.apache.asterix.om.types.hierachy.ATypeHierarchy;
+import org.apache.commons.lang3.mutable.Mutable;
+import org.apache.hyracks.algebricks.common.exceptions.AlgebricksException;
+import org.apache.hyracks.algebricks.core.algebra.base.ILogicalExpression;
+import org.apache.hyracks.algebricks.core.algebra.base.ILogicalOperator;
+import org.apache.hyracks.algebricks.core.algebra.base.IOptimizationContext;
+import org.apache.hyracks.algebricks.core.algebra.base.LogicalExpressionTag;
+import org.apache.hyracks.algebricks.core.algebra.base.LogicalOperatorTag;
+import
org.apache.hyracks.algebricks.core.algebra.expressions.AbstractFunctionCallExpression;
+import
org.apache.hyracks.algebricks.core.algebra.expressions.IVariableTypeEnvironment;
+import org.apache.hyracks.algebricks.core.algebra.functions.FunctionIdentifier;
+import org.apache.hyracks.algebricks.core.algebra.functions.IFunctionInfo;
+import
org.apache.hyracks.algebricks.core.algebra.operators.logical.AssignOperator;
+import
org.apache.hyracks.algebricks.core.algebra.operators.logical.SelectOperator;
+import org.apache.hyracks.algebricks.core.rewriter.base.IAlgebraicRewriteRule;
+
+public class RemoveOrReplaceDefaultNullCastRule implements
IAlgebraicRewriteRule {
+ private static final Map<FunctionIdentifier, FunctionIdentifier> CAST_MAP;
+
+ static {
+ CAST_MAP = new HashMap<>();
+ CAST_MAP.put(BuiltinFunctions.BOOLEAN_DEFAULT_NULL_CONSTRUCTOR,
+ BuiltinFunctions.BOOLEAN_DEFAULT_NULL_CONSTRUCTOR);
+
+ CAST_MAP.put(BuiltinFunctions.INT8_DEFAULT_NULL_CONSTRUCTOR,
BuiltinFunctions.INT8_CONSTRUCTOR);
+ CAST_MAP.put(BuiltinFunctions.INT16_DEFAULT_NULL_CONSTRUCTOR,
BuiltinFunctions.INT16_CONSTRUCTOR);
+ CAST_MAP.put(BuiltinFunctions.INT32_DEFAULT_NULL_CONSTRUCTOR,
BuiltinFunctions.INT32_CONSTRUCTOR);
+ CAST_MAP.put(BuiltinFunctions.INT64_DEFAULT_NULL_CONSTRUCTOR,
BuiltinFunctions.INT64_CONSTRUCTOR);
+
+ CAST_MAP.put(BuiltinFunctions.FLOAT_DEFAULT_NULL_CONSTRUCTOR,
BuiltinFunctions.FLOAT_CONSTRUCTOR);
+ CAST_MAP.put(BuiltinFunctions.DOUBLE_DEFAULT_NULL_CONSTRUCTOR,
BuiltinFunctions.DOUBLE_CONSTRUCTOR);
+
+ // *_DEFAULT_NULL_WITH_FORMAT_CONSTRUCTOR are not considered here as
format may differ from the original value
+ CAST_MAP.put(BuiltinFunctions.DATE_DEFAULT_NULL_CONSTRUCTOR,
BuiltinFunctions.DATE_CONSTRUCTOR);
+ CAST_MAP.put(BuiltinFunctions.TIME_DEFAULT_NULL_CONSTRUCTOR,
BuiltinFunctions.TIME_CONSTRUCTOR);
+ CAST_MAP.put(BuiltinFunctions.DATETIME_DEFAULT_NULL_CONSTRUCTOR,
BuiltinFunctions.DATETIME_CONSTRUCTOR);
+
+ CAST_MAP.put(BuiltinFunctions.DURATION_DEFAULT_NULL_CONSTRUCTOR,
BuiltinFunctions.DURATION_CONSTRUCTOR);
+ CAST_MAP.put(BuiltinFunctions.DAY_TIME_DURATION_CONSTRUCTOR,
BuiltinFunctions.DAY_TIME_DURATION_CONSTRUCTOR);
+ CAST_MAP.put(BuiltinFunctions.YEAR_MONTH_DURATION_CONSTRUCTOR,
+ BuiltinFunctions.YEAR_MONTH_DURATION_CONSTRUCTOR);
+
+ CAST_MAP.put(BuiltinFunctions.STRING_DEFAULT_NULL_CONSTRUCTOR,
BuiltinFunctions.STRING_CONSTRUCTOR);
+
+ CAST_MAP.put(BuiltinFunctions.BINARY_BASE64_DEFAULT_NULL_CONSTRUCTOR,
+ BuiltinFunctions.BINARY_BASE64_CONSTRUCTOR);
+
+ CAST_MAP.put(BuiltinFunctions.UUID_DEFAULT_NULL_CONSTRUCTOR,
BuiltinFunctions.UUID_CONSTRUCTOR);
+ }
+
+ @Override
+ public boolean rewritePre(Mutable<ILogicalOperator> opRef,
IOptimizationContext context)
+ throws AlgebricksException {
+ ILogicalOperator op = opRef.getValue();
+
+ if (op.getOperatorTag() == LogicalOperatorTag.ASSIGN) {
+ //process assign
+ AssignOperator assignOp = (AssignOperator) op;
+ return processExpressions(context, assignOp,
assignOp.getExpressions());
+ } else if (op.getOperatorTag() == LogicalOperatorTag.SELECT) {
+ //process select
+ SelectOperator selectOp = (SelectOperator) op;
+ return processExpression(context, selectOp,
selectOp.getCondition());
+ }
+ return false;
+ }
+
+ private boolean processExpressions(IOptimizationContext context,
ILogicalOperator op,
+ List<Mutable<ILogicalExpression>> expressions) throws
AlgebricksException {
+ boolean changed = false;
+ for (Mutable<ILogicalExpression> exprRef : expressions) {
+ changed |= processExpression(context, op, exprRef);
+ }
+ return changed;
+ }
+
+ private boolean processExpression(IOptimizationContext context,
ILogicalOperator op,
+ Mutable<ILogicalExpression> exprRef) throws AlgebricksException {
+ ILogicalExpression expr = exprRef.getValue();
+ if (expr.getExpressionTag() != LogicalExpressionTag.FUNCTION_CALL) {
+ return false;
+ }
+
+ AbstractFunctionCallExpression funcExpr =
(AbstractFunctionCallExpression) expr;
+ FunctionIdentifier fid = funcExpr.getFunctionIdentifier();
+ if (!CAST_MAP.containsKey(fid)) {
+ return processExpressions(context, op, funcExpr.getArguments());
+ }
+
+ ILogicalExpression castArgExpr =
funcExpr.getArguments().get(0).getValue();
+ IVariableTypeEnvironment env = context.getOutputTypeEnvironment(op);
+
+ IAType outputType = ((AUnionType)
env.getType(funcExpr)).getActualType();
+ IAType argType = (IAType) env.getType(castArgExpr);
+
+ //If arg type is a union type (or unknowable), then the function
removed as below
+ if (isDerivedOrAny(argType) || !outputType.equals(argType) &&
!typeIsConvertable(fid, outputType, argType)) {
+ // The types of cast and its argument are different
+ // Also, the cast function isn't a string function
+ return false;
+ }
+
+ if (outputType.equals(argType)) {
+ exprRef.setValue(castArgExpr);
+ } else {
+ MetadataProvider metadataProvider = (MetadataProvider)
context.getMetadataProvider();
+ IFunctionInfo functionInfo =
metadataProvider.lookupFunction(CAST_MAP.get(fid));
+ funcExpr.setFunctionInfo(functionInfo);
+ context.computeAndSetTypeEnvironmentForOperator(op);
+ }
+ return true;
+ }
+
+ private boolean isDerivedOrAny(IAType argType) {
+ ATypeTag argTypeTag = argType.getTypeTag();
+ return argTypeTag.isDerivedType() || argTypeTag == ATypeTag.ANY;
+ }
+
+ private boolean typeIsConvertable(FunctionIdentifier fid, IAType
outputType, IAType argType) {
+ ATypeTag outputTypeTag = outputType.getTypeTag();
+ ATypeTag argTypeTag = argType.getTypeTag();
+
+ boolean convertableNumeric =
ATypeHierarchy.getTypeDomain(outputTypeTag) == ATypeHierarchy.Domain.NUMERIC
+ && ATypeHierarchy.getTypeDomain(argTypeTag) ==
ATypeHierarchy.Domain.NUMERIC
+ && (ATypeHierarchy.canPromote(argTypeTag, outputTypeTag)
+ || ATypeHierarchy.canDemote(argTypeTag,
outputTypeTag));
+
+ // converting to string is suitable for all non-derived types
+ return BuiltinFunctions.STRING_DEFAULT_NULL_CONSTRUCTOR.equals(fid) ||
convertableNumeric;
+ }
+}
diff --git
a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/RemoveUnknownCheckForKnownTypesRule.java
b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/RemoveUnknownCheckForKnownTypesRule.java
new file mode 100644
index 0000000..adf5982
--- /dev/null
+++
b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/RemoveUnknownCheckForKnownTypesRule.java
@@ -0,0 +1,108 @@
+/*
+ * 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.asterix.optimizer.rules;
+
+import java.util.List;
+
+import org.apache.asterix.om.functions.BuiltinFunctions;
+import org.apache.asterix.om.types.ATypeTag;
+import org.apache.asterix.om.types.AUnionType;
+import org.apache.asterix.om.types.IAType;
+import org.apache.commons.lang3.mutable.Mutable;
+import org.apache.hyracks.algebricks.common.exceptions.AlgebricksException;
+import org.apache.hyracks.algebricks.core.algebra.base.ILogicalExpression;
+import org.apache.hyracks.algebricks.core.algebra.base.ILogicalOperator;
+import org.apache.hyracks.algebricks.core.algebra.base.IOptimizationContext;
+import org.apache.hyracks.algebricks.core.algebra.base.LogicalExpressionTag;
+import org.apache.hyracks.algebricks.core.algebra.base.LogicalOperatorTag;
+import
org.apache.hyracks.algebricks.core.algebra.expressions.AbstractFunctionCallExpression;
+import
org.apache.hyracks.algebricks.core.algebra.expressions.ConstantExpression;
+import
org.apache.hyracks.algebricks.core.algebra.expressions.IVariableTypeEnvironment;
+import org.apache.hyracks.algebricks.core.algebra.functions.FunctionIdentifier;
+import
org.apache.hyracks.algebricks.core.algebra.operators.logical.SelectOperator;
+import org.apache.hyracks.algebricks.core.rewriter.base.IAlgebraicRewriteRule;
+
+public class RemoveUnknownCheckForKnownTypesRule implements
IAlgebraicRewriteRule {
+ @Override
+ public boolean rewritePre(Mutable<ILogicalOperator> opRef,
IOptimizationContext context)
+ throws AlgebricksException {
+ ILogicalOperator op = opRef.getValue();
+ if (op.getOperatorTag() != LogicalOperatorTag.SELECT) {
+ return false;
+ }
+
+ SelectOperator selectOp = (SelectOperator) op;
+ return processExpression(context, selectOp, selectOp.getCondition());
+ }
+
+ private boolean processExpressions(IOptimizationContext context,
ILogicalOperator op,
+ List<Mutable<ILogicalExpression>> expressions) throws
AlgebricksException {
+ boolean changed = false;
+ for (Mutable<ILogicalExpression> exprRef : expressions) {
+ changed |= processExpression(context, op, exprRef);
+ }
+ return changed;
+ }
+
+ private boolean processExpression(IOptimizationContext context,
ILogicalOperator op,
+ Mutable<ILogicalExpression> exprRef) throws AlgebricksException {
+
+ AbstractFunctionCallExpression notFuncExpr =
getFunctionExpression(exprRef);
+ if (notFuncExpr == null) {
+ return false;
+ }
+ FunctionIdentifier fid1 = notFuncExpr.getFunctionIdentifier();
+ if (!BuiltinFunctions.NOT.equals(fid1)) {
+ return processExpressions(context, op, notFuncExpr.getArguments());
+ }
+
+ AbstractFunctionCallExpression unknownCheckFuncExpr =
getFunctionExpression(notFuncExpr.getArguments().get(0));
+ if (unknownCheckFuncExpr == null ||
!isNullOrIsMissingOrIsUnknownCheck(unknownCheckFuncExpr)) {
+ return false;
+ }
+
+ ILogicalExpression unknownCheckArg =
unknownCheckFuncExpr.getArguments().get(0).getValue();
+ IVariableTypeEnvironment env = context.getOutputTypeEnvironment(op);
+
+ IAType type = (IAType) env.getType(unknownCheckArg);
+ if (type.getTypeTag() == ATypeTag.UNION && ((AUnionType)
type).isUnknownableType()) {
+ return false;
+ }
+
+ // Set the expression to true and allow the constant folding to remove
the SELECT if possible
+ exprRef.setValue(ConstantExpression.TRUE);
+ return true;
+ }
+
+ private boolean
isNullOrIsMissingOrIsUnknownCheck(AbstractFunctionCallExpression funcExpr) {
+ FunctionIdentifier fid = funcExpr.getFunctionIdentifier();
+ return BuiltinFunctions.IS_NULL.equals(fid) ||
BuiltinFunctions.IS_MISSING.equals(fid)
+ || BuiltinFunctions.IS_UNKNOWN.equals(fid);
+ }
+
+ private AbstractFunctionCallExpression
getFunctionExpression(Mutable<ILogicalExpression> exprRef) {
+ ILogicalExpression expr = exprRef.getValue();
+
+ if (expr.getExpressionTag() != LogicalExpressionTag.FUNCTION_CALL) {
+ return null;
+ }
+
+ return (AbstractFunctionCallExpression) expr;
+ }
+}
diff --git
a/asterixdb/asterix-lang-sqlpp/src/main/java/org/apache/asterix/lang/sqlpp/rewrites/SqlppFunctionBodyRewriter.java
b/asterixdb/asterix-lang-sqlpp/src/main/java/org/apache/asterix/lang/sqlpp/rewrites/SqlppFunctionBodyRewriter.java
index 557f17d..6215455 100644
---
a/asterixdb/asterix-lang-sqlpp/src/main/java/org/apache/asterix/lang/sqlpp/rewrites/SqlppFunctionBodyRewriter.java
+++
b/asterixdb/asterix-lang-sqlpp/src/main/java/org/apache/asterix/lang/sqlpp/rewrites/SqlppFunctionBodyRewriter.java
@@ -188,6 +188,7 @@
VariableExpr projectVarRef3 = new VariableExpr(projectVar);
projectVarRef3.setSourceLocation(sourceLoc);
Expression notIsNullExpr =
ViewUtil.createNotIsNullExpression(projectVarRef3, sourceLoc);
+
if (filters == null) {
filters = new ArrayList<>();
}
--
To view, visit https://asterix-gerrit.ics.uci.edu/c/asterixdb/+/17303
To unsubscribe, or for help writing mail filters, visit
https://asterix-gerrit.ics.uci.edu/settings
Gerrit-Project: asterixdb
Gerrit-Branch: neo
Gerrit-Change-Id: I717fdfca8d09144443b1f49c5588defeb895766e
Gerrit-Change-Number: 17303
Gerrit-PatchSet: 1
Gerrit-Owner: Wail Alkowaileet <[email protected]>
Gerrit-MessageType: newchange
