This is an automated email from the ASF dual-hosted git repository.
alsuliman pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/asterixdb.git
The following commit(s) were added to refs/heads/master by this push:
new 0a5528c [NO ISSUE][COMP] Fix InlineUnnestFunction to return false if
not fired
0a5528c is described below
commit 0a5528c38611ae8636ac1cf9a7d102d7b36a3dda
Author: Ali Alsuliman <[email protected]>
AuthorDate: Mon Aug 19 21:55:10 2019 -0700
[NO ISSUE][COMP] Fix InlineUnnestFunction to return false if not fired
- user model changes: no
- storage format changes: no
- interface changes: no
Details:
Fix InlineUnnestFunctionRule to return false if there are no
changes in the plan.
- minor clean-ups.
Change-Id: Ib2b69ae3ad9712d1443078e0ba0b254b46376d43
Reviewed-on: https://asterix-gerrit.ics.uci.edu/3526
Contrib: Jenkins <[email protected]>
Tested-by: Jenkins <[email protected]>
Integration-Tests: Jenkins <[email protected]>
Reviewed-by: Ali Alsuliman <[email protected]>
Reviewed-by: Dmitry Lychagin <[email protected]>
---
.../optimizer/rules/InlineUnnestFunctionRule.java | 31 +++++++++++-----------
1 file changed, 16 insertions(+), 15 deletions(-)
diff --git
a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/InlineUnnestFunctionRule.java
b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/InlineUnnestFunctionRule.java
index 9f1b968..15b2d73 100644
---
a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/InlineUnnestFunctionRule.java
+++
b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/InlineUnnestFunctionRule.java
@@ -67,22 +67,22 @@ public class InlineUnnestFunctionRule implements
IAlgebraicRewriteRule {
UnnestOperator unnestOperator = (UnnestOperator) op1;
AbstractFunctionCallExpression expr =
(AbstractFunctionCallExpression)
unnestOperator.getExpressionRef().getValue();
- //we only inline for the scan-collection function
+ // we only inline for the scan-collection function
if (expr.getFunctionIdentifier() != BuiltinFunctions.SCAN_COLLECTION) {
return false;
}
// inline all variables from an unnesting function call
- AbstractFunctionCallExpression funcExpr = expr;
- List<Mutable<ILogicalExpression>> args = funcExpr.getArguments();
+ List<Mutable<ILogicalExpression>> args = expr.getArguments();
+ boolean changed = false;
for (int i = 0; i < args.size(); i++) {
ILogicalExpression argExpr = args.get(i).getValue();
if (argExpr.getExpressionTag() == LogicalExpressionTag.VARIABLE) {
VariableReferenceExpression varExpr =
(VariableReferenceExpression) argExpr;
- inlineVariable(varExpr.getVariableReference(), unnestOperator);
+ changed |= inlineVariable(varExpr.getVariableReference(),
unnestOperator);
}
}
- return true;
+ return changed;
}
/**
@@ -94,38 +94,38 @@ public class InlineUnnestFunctionRule implements
IAlgebraicRewriteRule {
* The unnest operator.
* @throws AlgebricksException
*/
- private void inlineVariable(LogicalVariable usedVar, UnnestOperator
unnestOp) throws AlgebricksException {
+ private boolean inlineVariable(LogicalVariable usedVar, UnnestOperator
unnestOp) throws AlgebricksException {
AbstractFunctionCallExpression expr = (AbstractFunctionCallExpression)
unnestOp.getExpressionRef().getValue();
- List<Pair<AbstractFunctionCallExpression, Integer>> parentAndIndexList
=
- new ArrayList<Pair<AbstractFunctionCallExpression, Integer>>();
+ List<Pair<AbstractFunctionCallExpression, Integer>> parentAndIndexList
= new ArrayList<>();
getParentFunctionExpression(usedVar, expr, parentAndIndexList);
ILogicalExpression usedVarOrginExpr =
findUsedVarOrigin(usedVar, unnestOp, (AbstractLogicalOperator)
unnestOp.getInputs().get(0).getValue());
if (usedVarOrginExpr != null) {
for (Pair<AbstractFunctionCallExpression, Integer> parentAndIndex
: parentAndIndexList) {
- //we only rewrite the top scan-collection function
+ // we only rewrite the top scan-collection function
if (parentAndIndex.first.getFunctionIdentifier() ==
BuiltinFunctions.SCAN_COLLECTION
&& parentAndIndex.first == expr) {
unnestOp.getExpressionRef().setValue(usedVarOrginExpr);
}
}
+ return true;
}
+ return false;
}
- private void getParentFunctionExpression(LogicalVariable usedVar,
ILogicalExpression expr,
+ private void getParentFunctionExpression(LogicalVariable usedVar,
AbstractFunctionCallExpression funcExpr,
List<Pair<AbstractFunctionCallExpression, Integer>>
parentAndIndexList) {
- AbstractFunctionCallExpression funcExpr =
(AbstractFunctionCallExpression) expr;
List<Mutable<ILogicalExpression>> args = funcExpr.getArguments();
for (int i = 0; i < args.size(); i++) {
ILogicalExpression argExpr = args.get(i).getValue();
if (argExpr.getExpressionTag() == LogicalExpressionTag.VARIABLE) {
VariableReferenceExpression varExpr =
(VariableReferenceExpression) argExpr;
if (varExpr.getVariableReference().equals(usedVar)) {
- parentAndIndexList.add(new
Pair<AbstractFunctionCallExpression, Integer>(funcExpr, i));
+ parentAndIndexList.add(new Pair<>(funcExpr, i));
}
}
if (argExpr.getExpressionTag() ==
LogicalExpressionTag.FUNCTION_CALL) {
- getParentFunctionExpression(usedVar, argExpr,
parentAndIndexList);
+ getParentFunctionExpression(usedVar,
(AbstractFunctionCallExpression) argExpr, parentAndIndexList);
}
}
}
@@ -134,7 +134,7 @@ public class InlineUnnestFunctionRule implements
IAlgebraicRewriteRule {
AbstractLogicalOperator currentOp) throws AlgebricksException {
ILogicalExpression ret = null;
if (currentOp.getOperatorTag() == LogicalOperatorTag.ASSIGN) {
- List<LogicalVariable> producedVars = new
ArrayList<LogicalVariable>();
+ List<LogicalVariable> producedVars = new ArrayList<>();
VariableUtilities.getProducedVariables(currentOp, producedVars);
if (producedVars.contains(usedVar)) {
AssignOperator assignOp = (AssignOperator) currentOp;
@@ -148,7 +148,7 @@ public class InlineUnnestFunctionRule implements
IAlgebraicRewriteRule {
ret = returnedExpr;
}
} else if (returnedExpr.getExpressionTag() ==
LogicalExpressionTag.VARIABLE) {
- //recusively inline
+ // recursively inline
VariableReferenceExpression varExpr =
(VariableReferenceExpression) returnedExpr;
LogicalVariable var = varExpr.getVariableReference();
ILogicalExpression finalExpr = findUsedVarOrigin(var,
currentOp,
@@ -173,6 +173,7 @@ public class InlineUnnestFunctionRule implements
IAlgebraicRewriteRule {
private void removeUnecessaryAssign(AbstractLogicalOperator parentOp,
AbstractLogicalOperator currentOp,
AssignOperator assignOp, int index) {
+ // TODO: how come the assign variable is removed before checking that
other operators might be using it?
assignOp.getVariables().remove(index);
assignOp.getExpressions().remove(index);
if (assignOp.getVariables().size() == 0) {
