You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@asterixdb.apache.org by mb...@apache.org on 2018/01/28 20:53:09 UTC
[28/29] asterixdb git commit: [ASTERIXDB-2256] Reformat sources using
code format template
http://git-wip-us.apache.org/repos/asf/asterixdb/blob/cb9ca975/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/FuzzyJoinRule.java
----------------------------------------------------------------------
diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/FuzzyJoinRule.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/FuzzyJoinRule.java
index 160e909..003cff0 100644
--- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/FuzzyJoinRule.java
+++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/FuzzyJoinRule.java
@@ -263,8 +263,8 @@ public class FuzzyJoinRule implements IAlgebraicRewriteRule {
AqlPlusExpressionToPlanTranslator translator = new AqlPlusExpressionToPlanTranslator(metadataProvider, counter);
context.setVarCounter(counter.get());
- LogicalOperatorDeepCopyWithNewVariablesVisitor deepCopyVisitor = new LogicalOperatorDeepCopyWithNewVariablesVisitor(
- context, context);
+ LogicalOperatorDeepCopyWithNewVariablesVisitor deepCopyVisitor =
+ new LogicalOperatorDeepCopyWithNewVariablesVisitor(context, context);
translator.addOperatorToMetaScope(new Identifier("#LEFT"), leftInputOp);
translator.addVariableToMetaScope(new Identifier("$$LEFT"), leftInputVar);
http://git-wip-us.apache.org/repos/asf/asterixdb/blob/cb9ca975/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/InjectTypeCastForSwitchCaseRule.java
----------------------------------------------------------------------
diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/InjectTypeCastForSwitchCaseRule.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/InjectTypeCastForSwitchCaseRule.java
index bb529d4..27b2712 100644
--- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/InjectTypeCastForSwitchCaseRule.java
+++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/InjectTypeCastForSwitchCaseRule.java
@@ -100,9 +100,9 @@ public class InjectTypeCastForSwitchCaseRule implements IAlgebraicRewriteRule {
if (TypeResolverUtil.needsCast(producedType, type)) {
ILogicalExpression argExpr = argRef.getValue();
// Injects a cast call to cast the data type to the produced type of the switch-case function call.
- ScalarFunctionCallExpression castFunc = new ScalarFunctionCallExpression(
- FunctionUtil.getFunctionInfo(BuiltinFunctions.CAST_TYPE),
- new ArrayList<>(Collections.singletonList(new MutableObject<>(argExpr))));
+ ScalarFunctionCallExpression castFunc =
+ new ScalarFunctionCallExpression(FunctionUtil.getFunctionInfo(BuiltinFunctions.CAST_TYPE),
+ new ArrayList<>(Collections.singletonList(new MutableObject<>(argExpr))));
TypeCastUtils.setRequiredAndInputTypes(castFunc, producedType, type);
argRef.setValue(castFunc);
rewritten = true;
http://git-wip-us.apache.org/repos/asf/asterixdb/blob/cb9ca975/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/InlineUnnestFunctionRule.java
----------------------------------------------------------------------
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 09c98dd..9f1b968 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
@@ -65,8 +65,8 @@ public class InlineUnnestFunctionRule implements IAlgebraicRewriteRule {
return false;
}
UnnestOperator unnestOperator = (UnnestOperator) op1;
- AbstractFunctionCallExpression expr = (AbstractFunctionCallExpression) unnestOperator.getExpressionRef()
- .getValue();
+ AbstractFunctionCallExpression expr =
+ (AbstractFunctionCallExpression) unnestOperator.getExpressionRef().getValue();
//we only inline for the scan-collection function
if (expr.getFunctionIdentifier() != BuiltinFunctions.SCAN_COLLECTION) {
return false;
@@ -96,10 +96,11 @@ public class InlineUnnestFunctionRule implements IAlgebraicRewriteRule {
*/
private void 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<Pair<AbstractFunctionCallExpression, Integer>>();
getParentFunctionExpression(usedVar, expr, parentAndIndexList);
- ILogicalExpression usedVarOrginExpr = findUsedVarOrigin(usedVar, unnestOp,
- (AbstractLogicalOperator) unnestOp.getInputs().get(0).getValue());
+ 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
@@ -160,8 +161,8 @@ public class InlineUnnestFunctionRule implements IAlgebraicRewriteRule {
}
} else {
for (Mutable<ILogicalOperator> child : currentOp.getInputs()) {
- ILogicalExpression expr = findUsedVarOrigin(usedVar, currentOp,
- (AbstractLogicalOperator) child.getValue());
+ ILogicalExpression expr =
+ findUsedVarOrigin(usedVar, currentOp, (AbstractLogicalOperator) child.getValue());
if (expr != null) {
ret = expr;
}
http://git-wip-us.apache.org/repos/asf/asterixdb/blob/cb9ca975/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/IntroduceAutogenerateIDRule.java
----------------------------------------------------------------------
diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/IntroduceAutogenerateIDRule.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/IntroduceAutogenerateIDRule.java
index a24c6e0..c3e036e 100644
--- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/IntroduceAutogenerateIDRule.java
+++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/IntroduceAutogenerateIDRule.java
@@ -133,8 +133,8 @@ public class IntroduceAutogenerateIDRule implements IAlgebraicRewriteRule {
return false;
}
- List<String> pkFieldName = ((InternalDatasetDetails) dds.getDataset().getDatasetDetails()).getPrimaryKey()
- .get(0);
+ List<String> pkFieldName =
+ ((InternalDatasetDetails) dds.getDataset().getDatasetDetails()).getPrimaryKey().get(0);
ILogicalExpression rec0 = new VariableReferenceExpression(inputRecord);
ILogicalExpression rec1 = createPrimaryKeyRecordExpression(pkFieldName);
ILogicalExpression mergedRec = createRecordMergeFunction(rec0, rec1);
@@ -160,15 +160,15 @@ public class IntroduceAutogenerateIDRule implements IAlgebraicRewriteRule {
private ILogicalExpression createNotNullFunction(ILogicalExpression mergedRec) {
List<Mutable<ILogicalExpression>> args = new ArrayList<>();
args.add(new MutableObject<ILogicalExpression>(mergedRec));
- AbstractFunctionCallExpression notNullFn = new ScalarFunctionCallExpression(
- FunctionUtil.getFunctionInfo(BuiltinFunctions.CHECK_UNKNOWN), args);
+ AbstractFunctionCallExpression notNullFn =
+ new ScalarFunctionCallExpression(FunctionUtil.getFunctionInfo(BuiltinFunctions.CHECK_UNKNOWN), args);
return notNullFn;
}
private AbstractFunctionCallExpression createPrimaryKeyRecordExpression(List<String> pkFieldName) {
//Create lowest level of nested uuid
- AbstractFunctionCallExpression uuidFn = new ScalarFunctionCallExpression(
- FunctionUtil.getFunctionInfo(BuiltinFunctions.CREATE_UUID));
+ AbstractFunctionCallExpression uuidFn =
+ new ScalarFunctionCallExpression(FunctionUtil.getFunctionInfo(BuiltinFunctions.CREATE_UUID));
List<Mutable<ILogicalExpression>> openRecordConsArgs = new ArrayList<>();
Mutable<ILogicalExpression> pkFieldNameExpression = new MutableObject<ILogicalExpression>(
new ConstantExpression(new AsterixConstantValue(new AString(pkFieldName.get(pkFieldName.size() - 1)))));
http://git-wip-us.apache.org/repos/asf/asterixdb/blob/cb9ca975/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/IntroduceDynamicTypeCastForExternalFunctionRule.java
----------------------------------------------------------------------
diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/IntroduceDynamicTypeCastForExternalFunctionRule.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/IntroduceDynamicTypeCastForExternalFunctionRule.java
index bb39993..5644a6c 100644
--- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/IntroduceDynamicTypeCastForExternalFunctionRule.java
+++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/IntroduceDynamicTypeCastForExternalFunctionRule.java
@@ -94,8 +94,8 @@ public class IntroduceDynamicTypeCastForExternalFunctionRule implements IAlgebra
}
boolean castFlag = !IntroduceDynamicTypeCastRule.compatible(requiredRecordType, inputRecordType);
if (castFlag || checkUnknown) {
- AbstractFunctionCallExpression castFunc = new ScalarFunctionCallExpression(
- FunctionUtil.getFunctionInfo(BuiltinFunctions.CAST_TYPE));
+ AbstractFunctionCallExpression castFunc =
+ new ScalarFunctionCallExpression(FunctionUtil.getFunctionInfo(BuiltinFunctions.CAST_TYPE));
castFunc.getArguments().add(funcCallExpr.getArguments().get(iter1));
TypeCastUtils.setRequiredAndInputTypes(castFunc, requiredRecordType, inputRecordType);
funcCallExpr.getArguments().set(iter1, new MutableObject<>(castFunc));
http://git-wip-us.apache.org/repos/asf/asterixdb/blob/cb9ca975/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/IntroduceDynamicTypeCastRule.java
----------------------------------------------------------------------
diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/IntroduceDynamicTypeCastRule.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/IntroduceDynamicTypeCastRule.java
index 075a65c..2695337 100644
--- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/IntroduceDynamicTypeCastRule.java
+++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/IntroduceDynamicTypeCastRule.java
@@ -167,8 +167,7 @@ public class IntroduceDynamicTypeCastRule implements IAlgebraicRewriteRule {
boolean cast = !compatible(requiredRecordType, inputRecordType);
if (checkUnknown) {
- recordVar = addWrapperFunction(requiredRecordType, recordVar, op, context,
- BuiltinFunctions.CHECK_UNKNOWN);
+ recordVar = addWrapperFunction(requiredRecordType, recordVar, op, context, BuiltinFunctions.CHECK_UNKNOWN);
}
if (cast) {
addWrapperFunction(requiredRecordType, recordVar, op, context, BuiltinFunctions.CAST_TYPE);
@@ -208,15 +207,15 @@ public class IntroduceDynamicTypeCastRule implements IAlgebraicRewriteRule {
if (var.equals(recordVar)) {
/** insert an assign operator to call the function on-top-of the variable */
IAType actualType = (IAType) env.getVarType(var);
- AbstractFunctionCallExpression cast = new ScalarFunctionCallExpression(
- FunctionUtil.getFunctionInfo(fd));
+ AbstractFunctionCallExpression cast =
+ new ScalarFunctionCallExpression(FunctionUtil.getFunctionInfo(fd));
cast.getArguments()
.add(new MutableObject<ILogicalExpression>(new VariableReferenceExpression(var)));
/** enforce the required record type */
TypeCastUtils.setRequiredAndInputTypes(cast, requiredRecordType, actualType);
LogicalVariable newAssignVar = context.newVar();
- AssignOperator newAssignOperator = new AssignOperator(newAssignVar,
- new MutableObject<ILogicalExpression>(cast));
+ AssignOperator newAssignOperator =
+ new AssignOperator(newAssignVar, new MutableObject<ILogicalExpression>(cast));
newAssignOperator.getInputs().add(new MutableObject<ILogicalOperator>(op));
opRef.setValue(newAssignOperator);
context.computeAndSetTypeEnvironmentForOperator(newAssignOperator);
http://git-wip-us.apache.org/repos/asf/asterixdb/blob/cb9ca975/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/IntroduceEnforcedListTypeRule.java
----------------------------------------------------------------------
diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/IntroduceEnforcedListTypeRule.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/IntroduceEnforcedListTypeRule.java
index 3ff2a1b..0c44ba0 100644
--- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/IntroduceEnforcedListTypeRule.java
+++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/IntroduceEnforcedListTypeRule.java
@@ -48,7 +48,8 @@ import org.apache.hyracks.algebricks.core.rewriter.base.IAlgebraicRewriteRule;
public class IntroduceEnforcedListTypeRule implements IAlgebraicRewriteRule {
@Override
- public boolean rewritePre(Mutable<ILogicalOperator> opRef, IOptimizationContext context) throws AlgebricksException {
+ public boolean rewritePre(Mutable<ILogicalOperator> opRef, IOptimizationContext context)
+ throws AlgebricksException {
return false;
}
http://git-wip-us.apache.org/repos/asf/asterixdb/blob/cb9ca975/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/IntroduceMaterializationForInsertWithSelfScanRule.java
----------------------------------------------------------------------
diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/IntroduceMaterializationForInsertWithSelfScanRule.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/IntroduceMaterializationForInsertWithSelfScanRule.java
index 5518325..0fa4d30 100644
--- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/IntroduceMaterializationForInsertWithSelfScanRule.java
+++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/IntroduceMaterializationForInsertWithSelfScanRule.java
@@ -58,16 +58,16 @@ public class IntroduceMaterializationForInsertWithSelfScanRule implements IAlgeb
}
InsertDeleteUpsertOperator insertOp = (InsertDeleteUpsertOperator) op;
- boolean sameDataset = checkIfInsertAndScanDatasetsSame(op, ((DatasetDataSource) insertOp.getDataSource())
- .getDataset().getDatasetName());
+ boolean sameDataset = checkIfInsertAndScanDatasetsSame(op,
+ ((DatasetDataSource) insertOp.getDataSource()).getDataset().getDatasetName());
if (sameDataset) {
MaterializeOperator materializeOperator = new MaterializeOperator();
MaterializePOperator materializePOperator = new MaterializePOperator(true);
materializeOperator.setPhysicalOperator(materializePOperator);
- materializeOperator.getInputs().add(
- new MutableObject<ILogicalOperator>(insertOp.getInputs().get(0).getValue()));
+ materializeOperator.getInputs()
+ .add(new MutableObject<ILogicalOperator>(insertOp.getInputs().get(0).getValue()));
context.computeAndSetTypeEnvironmentForOperator(materializeOperator);
insertOp.getInputs().clear();
@@ -105,8 +105,7 @@ public class IntroduceMaterializationForInsertWithSelfScanRule implements IAlgeb
} else if (descendantOp.getOperatorTag() == LogicalOperatorTag.DATASOURCESCAN) {
DataSourceScanOperator dataSourceScanOp = (DataSourceScanOperator) descendantOp;
DataSource ds = (DataSource) dataSourceScanOp.getDataSource();
- if ((ds.getDatasourceType() == Type.INTERNAL_DATASET
- || ds.getDatasourceType() == Type.EXTERNAL_DATASET)
+ if ((ds.getDatasourceType() == Type.INTERNAL_DATASET || ds.getDatasourceType() == Type.EXTERNAL_DATASET)
&& ((DatasetDataSource) ds).getDataset().getDatasetName().compareTo(insertDatasetName) == 0) {
return true;
}
http://git-wip-us.apache.org/repos/asf/asterixdb/blob/cb9ca975/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/IntroduceRapidFrameFlushProjectAssignRule.java
----------------------------------------------------------------------
diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/IntroduceRapidFrameFlushProjectAssignRule.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/IntroduceRapidFrameFlushProjectAssignRule.java
index f655b24..1097d25 100644
--- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/IntroduceRapidFrameFlushProjectAssignRule.java
+++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/IntroduceRapidFrameFlushProjectAssignRule.java
@@ -45,7 +45,8 @@ import org.apache.hyracks.algebricks.core.rewriter.base.IAlgebraicRewriteRule;
public class IntroduceRapidFrameFlushProjectAssignRule implements IAlgebraicRewriteRule {
@Override
- public boolean rewritePre(Mutable<ILogicalOperator> opRef, IOptimizationContext context) throws AlgebricksException {
+ public boolean rewritePre(Mutable<ILogicalOperator> opRef, IOptimizationContext context)
+ throws AlgebricksException {
return false;
}
http://git-wip-us.apache.org/repos/asf/asterixdb/blob/cb9ca975/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/IntroduceSecondaryIndexInsertDeleteRule.java
----------------------------------------------------------------------
diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/IntroduceSecondaryIndexInsertDeleteRule.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/IntroduceSecondaryIndexInsertDeleteRule.java
index 3b6a959..6d53c13 100644
--- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/IntroduceSecondaryIndexInsertDeleteRule.java
+++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/IntroduceSecondaryIndexInsertDeleteRule.java
@@ -107,12 +107,12 @@ public class IntroduceSecondaryIndexInsertDeleteRule implements IAlgebraicRewrit
return false;
}
/** find the record variable */
- InsertDeleteUpsertOperator primaryIndexModificationOp = (InsertDeleteUpsertOperator) op0.getInputs().get(0)
- .getValue();
+ InsertDeleteUpsertOperator primaryIndexModificationOp =
+ (InsertDeleteUpsertOperator) op0.getInputs().get(0).getValue();
boolean isBulkload = primaryIndexModificationOp.isBulkload();
ILogicalExpression newRecordExpr = primaryIndexModificationOp.getPayloadExpression().getValue();
- List<Mutable<ILogicalExpression>> newMetaExprs = primaryIndexModificationOp
- .getAdditionalNonFilteringExpressions();
+ List<Mutable<ILogicalExpression>> newMetaExprs =
+ primaryIndexModificationOp.getAdditionalNonFilteringExpressions();
LogicalVariable newRecordVar;
LogicalVariable newMetaVar = null;
@@ -120,8 +120,8 @@ public class IntroduceSecondaryIndexInsertDeleteRule implements IAlgebraicRewrit
* inputOp is the assign operator which extracts primary keys from the input
* variables (record or meta)
*/
- AbstractLogicalOperator inputOp = (AbstractLogicalOperator) primaryIndexModificationOp.getInputs().get(0)
- .getValue();
+ AbstractLogicalOperator inputOp =
+ (AbstractLogicalOperator) primaryIndexModificationOp.getInputs().get(0).getValue();
newRecordVar = getRecordVar(context, inputOp, newRecordExpr, 0);
if (newMetaExprs != null && !newMetaExprs.isEmpty()) {
if (newMetaExprs.size() > 1) {
@@ -280,8 +280,8 @@ public class IntroduceSecondaryIndexInsertDeleteRule implements IAlgebraicRewrit
IndexInsertDeleteUpsertOperator indexUpdate;
if (index.getIndexType() != IndexType.RTREE) {
// Create an expression per key
- Mutable<ILogicalExpression> filterExpression = (primaryIndexModificationOp
- .getOperation() == Kind.UPSERT) ? null
+ Mutable<ILogicalExpression> filterExpression =
+ (primaryIndexModificationOp.getOperation() == Kind.UPSERT) ? null
: createFilterExpression(secondaryKeyVars, context.getOutputTypeEnvironment(currentTop),
index.isOverridingKeyFieldTypes());
DataSourceIndex dataSourceIndex = new DataSourceIndex(index, dataverseName, datasetName, mp);
@@ -371,8 +371,8 @@ public class IntroduceSecondaryIndexInsertDeleteRule implements IAlgebraicRewrit
Pair<IAType, Boolean> keyPairType = Index.getNonNullableOpenFieldType(index.getKeyFieldTypes().get(0),
secondaryKeyFields.get(0), recType);
IAType spatialType = keyPairType.first;
- boolean isPointMBR = spatialType.getTypeTag() == ATypeTag.POINT
- || spatialType.getTypeTag() == ATypeTag.POINT3D;
+ boolean isPointMBR =
+ spatialType.getTypeTag() == ATypeTag.POINT || spatialType.getTypeTag() == ATypeTag.POINT3D;
int dimension = NonTaggedFormatUtil.getNumDimensions(spatialType.getTypeTag());
int numKeys = (isPointMBR && isBulkload) ? dimension : dimension * 2;
// Get variables and expressions
@@ -381,8 +381,8 @@ public class IntroduceSecondaryIndexInsertDeleteRule implements IAlgebraicRewrit
for (int i = 0; i < numKeys; i++) {
LogicalVariable keyVar = context.newVar();
keyVarList.add(keyVar);
- AbstractFunctionCallExpression createMBR = new ScalarFunctionCallExpression(
- FunctionUtil.getFunctionInfo(BuiltinFunctions.CREATE_MBR));
+ AbstractFunctionCallExpression createMBR =
+ new ScalarFunctionCallExpression(FunctionUtil.getFunctionInfo(BuiltinFunctions.CREATE_MBR));
createMBR.getArguments().add(new MutableObject<ILogicalExpression>(
new VariableReferenceExpression(secondaryKeyVars.get(0))));
createMBR.getArguments().add(new MutableObject<ILogicalExpression>(
@@ -574,8 +574,8 @@ public class IntroduceSecondaryIndexInsertDeleteRule implements IAlgebraicRewrit
// make handling of records with incorrect value type for this field easier and cleaner
context.addNotToBeInlinedVar(fieldVar);
// create field access
- AbstractFunctionCallExpression fieldAccessFunc = getOpenOrNestedFieldAccessFunction(varRef,
- indexFieldId.fieldName);
+ AbstractFunctionCallExpression fieldAccessFunc =
+ getOpenOrNestedFieldAccessFunction(varRef, indexFieldId.fieldName);
// create cast
theFieldAccessFunc = new ScalarFunctionCallExpression(FunctionUtil.getFunctionInfo(
index.isEnforced() ? BuiltinFunctions.CAST_TYPE : BuiltinFunctions.CAST_TYPE_LAX));
@@ -587,9 +587,9 @@ public class IntroduceSecondaryIndexInsertDeleteRule implements IAlgebraicRewrit
int pos = indexFieldId.fieldName.size() > 1 ? -1
: sourceType.getFieldIndex(indexFieldId.fieldName.get(0));
// Field not found --> This is either an open field or a nested field. it can't be accessed by index
- theFieldAccessFunc = (pos == -1)
- ? getOpenOrNestedFieldAccessFunction(varRef, indexFieldId.fieldName)
- : getClosedFieldAccessFunction(varRef, pos);
+ theFieldAccessFunc =
+ (pos == -1) ? getOpenOrNestedFieldAccessFunction(varRef, indexFieldId.fieldName)
+ : getClosedFieldAccessFunction(varRef, pos);
}
vars.add(fieldVar);
exprs.add(new MutableObject<ILogicalExpression>(theFieldAccessFunc));
@@ -619,10 +619,10 @@ public class IntroduceSecondaryIndexInsertDeleteRule implements IAlgebraicRewrit
private static AbstractFunctionCallExpression getClosedFieldAccessFunction(Mutable<ILogicalExpression> varRef,
int position) {
- Mutable<ILogicalExpression> indexRef = new MutableObject<>(
- new ConstantExpression(new AsterixConstantValue(new AInt32(position))));
- return new ScalarFunctionCallExpression(
- FunctionUtil.getFunctionInfo(BuiltinFunctions.FIELD_ACCESS_BY_INDEX), varRef, indexRef);
+ Mutable<ILogicalExpression> indexRef =
+ new MutableObject<>(new ConstantExpression(new AsterixConstantValue(new AInt32(position))));
+ return new ScalarFunctionCallExpression(FunctionUtil.getFunctionInfo(BuiltinFunctions.FIELD_ACCESS_BY_INDEX),
+ varRef, indexRef);
}
private static AbstractFunctionCallExpression getOpenOrNestedFieldAccessFunction(Mutable<ILogicalExpression> varRef,
@@ -632,14 +632,14 @@ public class IntroduceSecondaryIndexInsertDeleteRule implements IAlgebraicRewrit
IAObject fieldList = stringListToAOrderedList(fields);
Mutable<ILogicalExpression> fieldRef = constantToMutableLogicalExpression(fieldList);
// Create an expression for the nested case
- func = new ScalarFunctionCallExpression(
- FunctionUtil.getFunctionInfo(BuiltinFunctions.FIELD_ACCESS_NESTED), varRef, fieldRef);
+ func = new ScalarFunctionCallExpression(FunctionUtil.getFunctionInfo(BuiltinFunctions.FIELD_ACCESS_NESTED),
+ varRef, fieldRef);
} else {
IAObject fieldList = new AString(fields.get(0));
Mutable<ILogicalExpression> fieldRef = constantToMutableLogicalExpression(fieldList);
// Create an expression for the open field case (By name)
- func = new ScalarFunctionCallExpression(
- FunctionUtil.getFunctionInfo(BuiltinFunctions.FIELD_ACCESS_BY_NAME), varRef, fieldRef);
+ func = new ScalarFunctionCallExpression(FunctionUtil.getFunctionInfo(BuiltinFunctions.FIELD_ACCESS_BY_NAME),
+ varRef, fieldRef);
}
return func;
}
@@ -666,12 +666,12 @@ public class IntroduceSecondaryIndexInsertDeleteRule implements IAlgebraicRewrit
if (!NonTaggedFormatUtil.isOptional(secondaryKeyType) && !forceFilter) {
continue;
}
- ScalarFunctionCallExpression isUnknownFuncExpr = new ScalarFunctionCallExpression(
- FunctionUtil.getFunctionInfo(BuiltinFunctions.IS_UNKNOWN),
- new MutableObject<ILogicalExpression>(new VariableReferenceExpression(secondaryKeyVar)));
- ScalarFunctionCallExpression notFuncExpr = new ScalarFunctionCallExpression(
- FunctionUtil.getFunctionInfo(BuiltinFunctions.NOT),
- new MutableObject<ILogicalExpression>(isUnknownFuncExpr));
+ ScalarFunctionCallExpression isUnknownFuncExpr =
+ new ScalarFunctionCallExpression(FunctionUtil.getFunctionInfo(BuiltinFunctions.IS_UNKNOWN),
+ new MutableObject<ILogicalExpression>(new VariableReferenceExpression(secondaryKeyVar)));
+ ScalarFunctionCallExpression notFuncExpr =
+ new ScalarFunctionCallExpression(FunctionUtil.getFunctionInfo(BuiltinFunctions.NOT),
+ new MutableObject<ILogicalExpression>(isUnknownFuncExpr));
filterExpressions.add(new MutableObject<ILogicalExpression>(notFuncExpr));
}
// No nullable secondary keys.
http://git-wip-us.apache.org/repos/asf/asterixdb/blob/cb9ca975/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/IntroduceTransactionCommitByAssignOpRule.java
----------------------------------------------------------------------
diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/IntroduceTransactionCommitByAssignOpRule.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/IntroduceTransactionCommitByAssignOpRule.java
index 0c23ace..c5cb6ae 100644
--- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/IntroduceTransactionCommitByAssignOpRule.java
+++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/IntroduceTransactionCommitByAssignOpRule.java
@@ -36,7 +36,8 @@ import org.apache.hyracks.algebricks.core.rewriter.base.IAlgebraicRewriteRule;
public class IntroduceTransactionCommitByAssignOpRule implements IAlgebraicRewriteRule {
@Override
- public boolean rewritePre(Mutable<ILogicalOperator> opRef, IOptimizationContext context) throws AlgebricksException {
+ public boolean rewritePre(Mutable<ILogicalOperator> opRef, IOptimizationContext context)
+ throws AlgebricksException {
return false;
}
@@ -61,8 +62,8 @@ public class IntroduceTransactionCommitByAssignOpRule implements IAlgebraicRewri
//create an assignOp with a variable and the condition of the select-operator.
LogicalVariable v = context.newVar();
- AssignOperator assignOperator = new AssignOperator(v, new MutableObject<ILogicalExpression>(selectOperator
- .getCondition().getValue()));
+ AssignOperator assignOperator =
+ new AssignOperator(v, new MutableObject<ILogicalExpression>(selectOperator.getCondition().getValue()));
//set the input of the new assign-operator to the input of the select-operator.
assignOperator.getInputs().add(childOfSelect);
http://git-wip-us.apache.org/repos/asf/asterixdb/blob/cb9ca975/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/ListifyUnnestingFunctionRule.java
----------------------------------------------------------------------
diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/ListifyUnnestingFunctionRule.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/ListifyUnnestingFunctionRule.java
index 8e35ffb..2fe6460 100644
--- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/ListifyUnnestingFunctionRule.java
+++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/ListifyUnnestingFunctionRule.java
@@ -118,14 +118,13 @@ public class ListifyUnnestingFunctionRule implements IAlgebraicRewriteRule {
// Listify the dataset into one collection.
LogicalVariable aggVar = context.newVar();
Mutable<ILogicalExpression> aggArgExprRef = new MutableObject<>(new VariableReferenceExpression(unnestVar));
- ILogicalExpression aggExpr = new AggregateFunctionCallExpression(
- FunctionUtil.getFunctionInfo(BuiltinFunctions.LISTIFY), false, new ArrayList<>(
- Collections.singletonList(aggArgExprRef)));
+ ILogicalExpression aggExpr =
+ new AggregateFunctionCallExpression(FunctionUtil.getFunctionInfo(BuiltinFunctions.LISTIFY), false,
+ new ArrayList<>(Collections.singletonList(aggArgExprRef)));
AggregateOperator aggregateOperator = new AggregateOperator(new ArrayList<>(Collections.singletonList(aggVar)),
new ArrayList<>(Collections.singletonList(new MutableObject<>(aggExpr))));
aggregateOperator.getInputs().add(new MutableObject<>(unnestOperator));
-
// Adds the aggregate operator as the root of the subplan.
subplanOperator.setRootOp(new MutableObject<>(aggregateOperator));
http://git-wip-us.apache.org/repos/asf/asterixdb/blob/cb9ca975/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/LoadRecordFieldsRule.java
----------------------------------------------------------------------
diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/LoadRecordFieldsRule.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/LoadRecordFieldsRule.java
index 7336181..d6581a2 100644
--- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/LoadRecordFieldsRule.java
+++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/LoadRecordFieldsRule.java
@@ -310,16 +310,16 @@ public class LoadRecordFieldsRule implements IAlgebraicRewriteRule {
AssignOperator op2 = (AssignOperator) opChild;
int i = op2.getVariables().indexOf(recordVar);
if (i >= 0) {
- AbstractLogicalExpression constr = (AbstractLogicalExpression) op2.getExpressions().get(i)
- .getValue();
+ AbstractLogicalExpression constr =
+ (AbstractLogicalExpression) op2.getExpressions().get(i).getValue();
return resolveFieldExpression(constr, accessKey, typeEnvironment, resolver);
}
} else if (opChild.getOperatorTag() == LogicalOperatorTag.NESTEDTUPLESOURCE) {
NestedTupleSourceOperator nts = (NestedTupleSourceOperator) opChild;
- AbstractLogicalOperator opBelowNestedPlan = (AbstractLogicalOperator) nts.getDataSourceReference()
- .getValue().getInputs().get(0).getValue();
- ILogicalExpression expr1 = findFieldExpression(opBelowNestedPlan, recordVar, accessKey, typeEnvironment,
- resolver);
+ AbstractLogicalOperator opBelowNestedPlan =
+ (AbstractLogicalOperator) nts.getDataSourceReference().getValue().getInputs().get(0).getValue();
+ ILogicalExpression expr1 =
+ findFieldExpression(opBelowNestedPlan, recordVar, accessKey, typeEnvironment, resolver);
if (expr1 != null) {
return expr1;
}
http://git-wip-us.apache.org/repos/asf/asterixdb/blob/cb9ca975/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/NestGroupByRule.java
----------------------------------------------------------------------
diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/NestGroupByRule.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/NestGroupByRule.java
index 84567d7..78399a8 100644
--- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/NestGroupByRule.java
+++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/NestGroupByRule.java
@@ -47,7 +47,8 @@ import org.apache.hyracks.algebricks.core.rewriter.base.IAlgebraicRewriteRule;
public class NestGroupByRule implements IAlgebraicRewriteRule {
@Override
- public boolean rewritePre(Mutable<ILogicalOperator> opRef, IOptimizationContext context) throws AlgebricksException {
+ public boolean rewritePre(Mutable<ILogicalOperator> opRef, IOptimizationContext context)
+ throws AlgebricksException {
return false;
}
http://git-wip-us.apache.org/repos/asf/asterixdb/blob/cb9ca975/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/PushAggFuncIntoStandaloneAggregateRule.java
----------------------------------------------------------------------
diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/PushAggFuncIntoStandaloneAggregateRule.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/PushAggFuncIntoStandaloneAggregateRule.java
index abb8775..cf5088b 100644
--- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/PushAggFuncIntoStandaloneAggregateRule.java
+++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/PushAggFuncIntoStandaloneAggregateRule.java
@@ -54,7 +54,8 @@ import org.apache.hyracks.algebricks.core.rewriter.base.IAlgebraicRewriteRule;
public class PushAggFuncIntoStandaloneAggregateRule implements IAlgebraicRewriteRule {
@Override
- public boolean rewritePre(Mutable<ILogicalOperator> opRef, IOptimizationContext context) throws AlgebricksException {
+ public boolean rewritePre(Mutable<ILogicalOperator> opRef, IOptimizationContext context)
+ throws AlgebricksException {
return false;
}
@@ -98,8 +99,7 @@ public class PushAggFuncIntoStandaloneAggregateRule implements IAlgebraicRewrite
continue;
}
AbstractFunctionCallExpression funcExpr = (AbstractFunctionCallExpression) expr;
- FunctionIdentifier funcIdent = BuiltinFunctions.getAggregateFunction(funcExpr
- .getFunctionIdentifier());
+ FunctionIdentifier funcIdent = BuiltinFunctions.getAggregateFunction(funcExpr.getFunctionIdentifier());
if (funcIdent == null) {
// Recursively look in func args.
if (containsAggregate(funcExpr.getArguments())) {
@@ -169,8 +169,8 @@ public class PushAggFuncIntoStandaloneAggregateRule implements IAlgebraicRewrite
return applied;
}
- private boolean pushAggregateFunction(AggregateOperator aggOp, AssignOperator assignOp, IOptimizationContext context)
- throws AlgebricksException {
+ private boolean pushAggregateFunction(AggregateOperator aggOp, AssignOperator assignOp,
+ IOptimizationContext context) throws AlgebricksException {
Mutable<ILogicalOperator> opRef3 = aggOp.getInputs().get(0);
AbstractLogicalOperator op3 = (AbstractLogicalOperator) opRef3.getValue();
// If there's a group by below the agg, then we want to have the agg pushed into the group by
@@ -204,23 +204,23 @@ public class PushAggFuncIntoStandaloneAggregateRule implements IAlgebraicRewrite
return false;
}
- AbstractFunctionCallExpression aggOpExpr = (AbstractFunctionCallExpression) aggOp.getExpressions().get(0)
- .getValue();
+ AbstractFunctionCallExpression aggOpExpr =
+ (AbstractFunctionCallExpression) aggOp.getExpressions().get(0).getValue();
aggOp.getExpressions().clear();
aggOp.getVariables().clear();
for (Mutable<ILogicalExpression> srcAssignExprRef : srcAssignExprRefs) {
- AbstractFunctionCallExpression assignFuncExpr = (AbstractFunctionCallExpression) srcAssignExprRef
- .getValue();
- FunctionIdentifier aggFuncIdent = BuiltinFunctions.getAggregateFunction(assignFuncExpr
- .getFunctionIdentifier());
+ AbstractFunctionCallExpression assignFuncExpr =
+ (AbstractFunctionCallExpression) srcAssignExprRef.getValue();
+ FunctionIdentifier aggFuncIdent =
+ BuiltinFunctions.getAggregateFunction(assignFuncExpr.getFunctionIdentifier());
// Push the agg func into the agg op.
List<Mutable<ILogicalExpression>> aggArgs = new ArrayList<Mutable<ILogicalExpression>>();
aggArgs.add(aggOpExpr.getArguments().get(0));
- AggregateFunctionCallExpression aggFuncExpr = BuiltinFunctions.makeAggregateFunctionExpression(
- aggFuncIdent, aggArgs);
+ AggregateFunctionCallExpression aggFuncExpr =
+ BuiltinFunctions.makeAggregateFunctionExpression(aggFuncIdent, aggArgs);
LogicalVariable newVar = context.newVar();
aggOp.getVariables().add(newVar);
aggOp.getExpressions().add(new MutableObject<ILogicalExpression>(aggFuncExpr));
@@ -249,8 +249,7 @@ public class PushAggFuncIntoStandaloneAggregateRule implements IAlgebraicRewrite
continue;
}
AbstractFunctionCallExpression funcExpr = (AbstractFunctionCallExpression) expr;
- FunctionIdentifier funcIdent = BuiltinFunctions.getAggregateFunction(funcExpr
- .getFunctionIdentifier());
+ FunctionIdentifier funcIdent = BuiltinFunctions.getAggregateFunction(funcExpr.getFunctionIdentifier());
if (funcIdent == null) {
// Recursively look in func args.
if (fingAggFuncExprRef(funcExpr.getArguments(), aggVar, srcAssignExprRefs) == false) {
http://git-wip-us.apache.org/repos/asf/asterixdb/blob/cb9ca975/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/PushAggregateIntoNestedSubplanRule.java
----------------------------------------------------------------------
diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/PushAggregateIntoNestedSubplanRule.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/PushAggregateIntoNestedSubplanRule.java
index d69dd3b..ccf7ccb 100644
--- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/PushAggregateIntoNestedSubplanRule.java
+++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/PushAggregateIntoNestedSubplanRule.java
@@ -64,8 +64,8 @@ public class PushAggregateIntoNestedSubplanRule implements IAlgebraicRewriteRule
Map<LogicalVariable, AbstractOperatorWithNestedPlans> nspWithAgg = new HashMap<>();
Map<ILogicalExpression, ILogicalExpression> aggExprToVarExpr = new HashMap<>();
// first collect vars. referring to listified sequences
- boolean changed = collectVarsBottomUp(opRef, context, nspAggVars, nspWithAgg, nspAggVarToPlanIndex,
- aggExprToVarExpr);
+ boolean changed =
+ collectVarsBottomUp(opRef, context, nspAggVars, nspWithAgg, nspAggVarToPlanIndex, aggExprToVarExpr);
if (changed) {
removeRedundantListifies(nspAggVars, nspWithAgg, nspAggVarToPlanIndex);
}
@@ -147,8 +147,8 @@ public class PushAggregateIntoNestedSubplanRule implements IAlgebraicRewriteRule
if (op1.getOperatorTag() == LogicalOperatorTag.ASSIGN) {
AssignOperator assign = (AssignOperator) op1;
for (Mutable<ILogicalExpression> exprRef : assign.getExpressions()) {
- Pair<Boolean, ILogicalExpression> p = extractAggFunctionsFromExpression(exprRef, nspWithAgg,
- aggregateExprToVarExpr, context);
+ Pair<Boolean, ILogicalExpression> p =
+ extractAggFunctionsFromExpression(exprRef, nspWithAgg, aggregateExprToVarExpr, context);
if (p.first) {
change = true;
exprRef.setValue(p.second);
@@ -158,8 +158,8 @@ public class PushAggregateIntoNestedSubplanRule implements IAlgebraicRewriteRule
if (op1.getOperatorTag() == LogicalOperatorTag.SELECT) {
SelectOperator select = (SelectOperator) op1;
Mutable<ILogicalExpression> exprRef = select.getCondition();
- Pair<Boolean, ILogicalExpression> p = extractAggFunctionsFromExpression(exprRef, nspWithAgg,
- aggregateExprToVarExpr, context);
+ Pair<Boolean, ILogicalExpression> p =
+ extractAggFunctionsFromExpression(exprRef, nspWithAgg, aggregateExprToVarExpr, context);
if (p.first) {
change = true;
exprRef.setValue(p.second);
@@ -283,8 +283,8 @@ public class PushAggregateIntoNestedSubplanRule implements IAlgebraicRewriteRule
if (nspOp != null) {
if (!aggregateExprToVarExpr.containsKey(expr)) {
LogicalVariable newVar = context.newVar();
- AggregateFunctionCallExpression aggFun = BuiltinFunctions
- .makeAggregateFunctionExpression(fi, fce.getArguments());
+ AggregateFunctionCallExpression aggFun =
+ BuiltinFunctions.makeAggregateFunctionExpression(fi, fce.getArguments());
rewriteAggregateInNestedSubplan(argVar, nspOp, aggFun, newVar, context);
ILogicalExpression newVarExpr = new VariableReferenceExpression(newVar);
aggregateExprToVarExpr.put(expr, newVarExpr);
@@ -299,8 +299,8 @@ public class PushAggregateIntoNestedSubplanRule implements IAlgebraicRewriteRule
boolean change = false;
for (Mutable<ILogicalExpression> a : fce.getArguments()) {
- Pair<Boolean, ILogicalExpression> aggArg = extractAggFunctionsFromExpression(a, nspWithAgg,
- aggregateExprToVarExpr, context);
+ Pair<Boolean, ILogicalExpression> aggArg =
+ extractAggFunctionsFromExpression(a, nspWithAgg, aggregateExprToVarExpr, context);
if (aggArg.first.booleanValue()) {
a.setValue(aggArg.second);
change = true;
@@ -324,8 +324,8 @@ public class PushAggregateIntoNestedSubplanRule implements IAlgebraicRewriteRule
for (int i = 0; i < n; i++) {
LogicalVariable v = aggOp.getVariables().get(i);
if (v.equals(oldAggVar)) {
- AbstractFunctionCallExpression oldAggExpr = (AbstractFunctionCallExpression) aggOp.getExpressions()
- .get(i).getValue();
+ AbstractFunctionCallExpression oldAggExpr =
+ (AbstractFunctionCallExpression) aggOp.getExpressions().get(i).getValue();
AggregateFunctionCallExpression newAggFun = BuiltinFunctions
.makeAggregateFunctionExpression(aggFun.getFunctionIdentifier(), new ArrayList<>());
for (Mutable<ILogicalExpression> arg : oldAggExpr.getArguments()) {
@@ -468,8 +468,8 @@ public class PushAggregateIntoNestedSubplanRule implements IAlgebraicRewriteRule
int n = nspAgg.getVariables().size();
for (int i = 0; i < n; i++) {
if (nspAgg.getVariables().get(i).equals(varFromNestedAgg)) {
- AbstractFunctionCallExpression fce = (AbstractFunctionCallExpression) nspAgg.getExpressions().get(i)
- .getValue();
+ AbstractFunctionCallExpression fce =
+ (AbstractFunctionCallExpression) nspAgg.getExpressions().get(i).getValue();
if (fce.getFunctionIdentifier().equals(BuiltinFunctions.LISTIFY)) {
ILogicalExpression argExpr = fce.getArguments().get(0).getValue();
if (argExpr.getExpressionTag() == LogicalExpressionTag.VARIABLE) {
http://git-wip-us.apache.org/repos/asf/asterixdb/blob/cb9ca975/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/PushGroupByThroughProduct.java
----------------------------------------------------------------------
diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/PushGroupByThroughProduct.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/PushGroupByThroughProduct.java
index 903f49e..48c4324 100644
--- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/PushGroupByThroughProduct.java
+++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/PushGroupByThroughProduct.java
@@ -77,8 +77,10 @@ public class PushGroupByThroughProduct implements IAlgebraicRewriteRule {
}
GroupByOperator gby = (GroupByOperator) op1;
- List<Pair<LogicalVariable, Mutable<ILogicalExpression>>> decorToPush = new ArrayList<Pair<LogicalVariable, Mutable<ILogicalExpression>>>();
- List<Pair<LogicalVariable, Mutable<ILogicalExpression>>> decorNotToPush = new ArrayList<Pair<LogicalVariable, Mutable<ILogicalExpression>>>();
+ List<Pair<LogicalVariable, Mutable<ILogicalExpression>>> decorToPush =
+ new ArrayList<Pair<LogicalVariable, Mutable<ILogicalExpression>>>();
+ List<Pair<LogicalVariable, Mutable<ILogicalExpression>>> decorNotToPush =
+ new ArrayList<Pair<LogicalVariable, Mutable<ILogicalExpression>>>();
Mutable<ILogicalOperator> opLeftRef = join.getInputs().get(0);
ILogicalOperator opLeft = opLeftRef.getValue();
@@ -110,7 +112,7 @@ public class PushGroupByThroughProduct implements IAlgebraicRewriteRule {
private void push(Mutable<ILogicalOperator> opRefGby, Mutable<ILogicalOperator> opRefJoin, int branch,
List<Pair<LogicalVariable, Mutable<ILogicalExpression>>> decorToPush,
List<Pair<LogicalVariable, Mutable<ILogicalExpression>>> decorNotToPush, IOptimizationContext context)
- throws AlgebricksException {
+ throws AlgebricksException {
GroupByOperator gby = (GroupByOperator) opRefGby.getValue();
AbstractBinaryJoinOperator join = (AbstractBinaryJoinOperator) opRefJoin.getValue();
gby.getDecorList().clear();
http://git-wip-us.apache.org/repos/asf/asterixdb/blob/cb9ca975/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/PushProperJoinThroughProduct.java
----------------------------------------------------------------------
diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/PushProperJoinThroughProduct.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/PushProperJoinThroughProduct.java
index ada4a57..1734f34 100644
--- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/PushProperJoinThroughProduct.java
+++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/PushProperJoinThroughProduct.java
@@ -42,7 +42,8 @@ public class PushProperJoinThroughProduct implements IAlgebraicRewriteRule {
private List<LogicalVariable> productLeftBranchVars = new ArrayList<LogicalVariable>();
@Override
- public boolean rewritePre(Mutable<ILogicalOperator> opRef, IOptimizationContext context) throws AlgebricksException {
+ public boolean rewritePre(Mutable<ILogicalOperator> opRef, IOptimizationContext context)
+ throws AlgebricksException {
return false;
}
http://git-wip-us.apache.org/repos/asf/asterixdb/blob/cb9ca975/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/RemoveLeftOuterUnnestForLeftOuterJoinRule.java
----------------------------------------------------------------------
diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/RemoveLeftOuterUnnestForLeftOuterJoinRule.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/RemoveLeftOuterUnnestForLeftOuterJoinRule.java
index b720714..1d7a61a 100644
--- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/RemoveLeftOuterUnnestForLeftOuterJoinRule.java
+++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/RemoveLeftOuterUnnestForLeftOuterJoinRule.java
@@ -88,8 +88,8 @@ public class RemoveLeftOuterUnnestForLeftOuterJoinRule implements IAlgebraicRewr
LeftOuterJoinOperator lojOperator = (LeftOuterJoinOperator) gbyOperator.getInputs().get(0).getValue();
// Checks whether the left outer unnest and the group-by operator are qualified for rewriting.
- Triple<Boolean, ILogicalExpression, ILogicalExpression> checkGbyResult = checkUnnestAndGby(outerUnnest,
- gbyOperator);
+ Triple<Boolean, ILogicalExpression, ILogicalExpression> checkGbyResult =
+ checkUnnestAndGby(outerUnnest, gbyOperator);
// The argument for listify and not(is-missing(...)) check should be variables.
if (!isVariableReference(checkGbyResult.second) || !isVariableReference(checkGbyResult.third)) {
return false;
http://git-wip-us.apache.org/repos/asf/asterixdb/blob/cb9ca975/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/RemoveRedundantListifyRule.java
----------------------------------------------------------------------
diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/RemoveRedundantListifyRule.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/RemoveRedundantListifyRule.java
index 334b966..7b46b39 100644
--- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/RemoveRedundantListifyRule.java
+++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/RemoveRedundantListifyRule.java
@@ -142,8 +142,7 @@ public class RemoveRedundantListifyRule implements IAlgebraicRewriteRule {
if (expr.getExpressionTag() != LogicalExpressionTag.FUNCTION_CALL) {
return false;
}
- if (((AbstractFunctionCallExpression) expr)
- .getFunctionIdentifier() != BuiltinFunctions.SCAN_COLLECTION) {
+ if (((AbstractFunctionCallExpression) expr).getFunctionIdentifier() != BuiltinFunctions.SCAN_COLLECTION) {
return false;
}
AbstractFunctionCallExpression functionCall = (AbstractFunctionCallExpression) expr;
http://git-wip-us.apache.org/repos/asf/asterixdb/blob/cb9ca975/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/RemoveRedundantSelectRule.java
----------------------------------------------------------------------
diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/RemoveRedundantSelectRule.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/RemoveRedundantSelectRule.java
index fe9e49e..53eb33a 100644
--- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/RemoveRedundantSelectRule.java
+++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/RemoveRedundantSelectRule.java
@@ -44,7 +44,8 @@ import org.apache.hyracks.algebricks.core.rewriter.base.IAlgebraicRewriteRule;
public class RemoveRedundantSelectRule implements IAlgebraicRewriteRule {
@Override
- public boolean rewritePre(Mutable<ILogicalOperator> opRef, IOptimizationContext context) throws AlgebricksException {
+ public boolean rewritePre(Mutable<ILogicalOperator> opRef, IOptimizationContext context)
+ throws AlgebricksException {
return false;
}
http://git-wip-us.apache.org/repos/asf/asterixdb/blob/cb9ca975/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/SetAsterixPhysicalOperatorsRule.java
----------------------------------------------------------------------
diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/SetAsterixPhysicalOperatorsRule.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/SetAsterixPhysicalOperatorsRule.java
index d22ec54..464476b 100644
--- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/SetAsterixPhysicalOperatorsRule.java
+++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/SetAsterixPhysicalOperatorsRule.java
@@ -107,8 +107,7 @@ public class SetAsterixPhysicalOperatorsRule implements IAlgebraicRewriteRule {
boolean serializable = true;
for (Mutable<ILogicalExpression> exprRef : aggOp.getExpressions()) {
AbstractFunctionCallExpression expr = (AbstractFunctionCallExpression) exprRef.getValue();
- if (!BuiltinFunctions
- .isAggregateFunctionSerializable(expr.getFunctionIdentifier())) {
+ if (!BuiltinFunctions.isAggregateFunctionSerializable(expr.getFunctionIdentifier())) {
serializable = false;
break;
}
@@ -121,17 +120,17 @@ public class SetAsterixPhysicalOperatorsRule implements IAlgebraicRewriteRule {
// if serializable, use external group-by
// now check whether the serialized version aggregation function has corresponding intermediate agg
boolean hasIntermediateAgg = true;
- IMergeAggregationExpressionFactory mergeAggregationExpressionFactory = context
- .getMergeAggregationExpressionFactory();
+ IMergeAggregationExpressionFactory mergeAggregationExpressionFactory =
+ context.getMergeAggregationExpressionFactory();
List<LogicalVariable> originalVariables = aggOp.getVariables();
List<Mutable<ILogicalExpression>> aggExprs = aggOp.getExpressions();
int aggNum = aggExprs.size();
for (int i = 0; i < aggNum; i++) {
- AbstractFunctionCallExpression expr = (AbstractFunctionCallExpression) aggExprs
- .get(i).getValue();
- AggregateFunctionCallExpression serialAggExpr = BuiltinFunctions
- .makeSerializableAggregateFunctionExpression(expr.getFunctionIdentifier(),
- expr.getArguments());
+ AbstractFunctionCallExpression expr =
+ (AbstractFunctionCallExpression) aggExprs.get(i).getValue();
+ AggregateFunctionCallExpression serialAggExpr =
+ BuiltinFunctions.makeSerializableAggregateFunctionExpression(
+ expr.getFunctionIdentifier(), expr.getArguments());
if (mergeAggregationExpressionFactory.createMergeAggregation(
originalVariables.get(i), serialAggExpr, context) == null) {
hasIntermediateAgg = false;
@@ -153,16 +152,15 @@ public class SetAsterixPhysicalOperatorsRule implements IAlgebraicRewriteRule {
if (hasIntermediateAgg && !multipleAggOpsFound) {
for (int i = 0; i < aggNum; i++) {
- AbstractFunctionCallExpression expr = (AbstractFunctionCallExpression) aggExprs
- .get(i).getValue();
- AggregateFunctionCallExpression serialAggExpr = BuiltinFunctions
- .makeSerializableAggregateFunctionExpression(
+ AbstractFunctionCallExpression expr =
+ (AbstractFunctionCallExpression) aggExprs.get(i).getValue();
+ AggregateFunctionCallExpression serialAggExpr =
+ BuiltinFunctions.makeSerializableAggregateFunctionExpression(
expr.getFunctionIdentifier(), expr.getArguments());
aggOp.getExpressions().get(i).setValue(serialAggExpr);
}
ExternalGroupByPOperator externalGby = new ExternalGroupByPOperator(
- gby.getGroupByList(),
- physicalOptimizationConfig.getMaxFramesForGroupBy(),
+ gby.getGroupByList(), physicalOptimizationConfig.getMaxFramesForGroupBy(),
(long) physicalOptimizationConfig.getMaxFramesForGroupBy()
* physicalOptimizationConfig.getFrameSize());
generateMergeAggregationExpressions(gby, context);
@@ -229,12 +227,12 @@ public class SetAsterixPhysicalOperatorsRule implements IAlgebraicRewriteRule {
AccessMethodJobGenParams jobGenParams = new AccessMethodJobGenParams();
jobGenParams.readFromFuncArgs(f.getArguments());
MetadataProvider mp = (MetadataProvider) context.getMetadataProvider();
- DataSourceId dataSourceId = new DataSourceId(jobGenParams.getDataverseName(),
- jobGenParams.getDatasetName());
- Dataset dataset = mp.findDataset(jobGenParams.getDataverseName(),
- jobGenParams.getDatasetName());
- IDataSourceIndex<String, DataSourceId> dsi = mp.findDataSourceIndex(jobGenParams.getIndexName(),
- dataSourceId);
+ DataSourceId dataSourceId =
+ new DataSourceId(jobGenParams.getDataverseName(), jobGenParams.getDatasetName());
+ Dataset dataset =
+ mp.findDataset(jobGenParams.getDataverseName(), jobGenParams.getDatasetName());
+ IDataSourceIndex<String, DataSourceId> dsi =
+ mp.findDataSourceIndex(jobGenParams.getIndexName(), dataSourceId);
INodeDomain storageDomain = mp.findNodeDomain(dataset.getNodeGroupName());
if (dsi == null) {
throw new AlgebricksException("Could not find index " + jobGenParams.getIndexName()
@@ -300,8 +298,8 @@ public class SetAsterixPhysicalOperatorsRule implements IAlgebraicRewriteRule {
"External group-by currently works only for one nested plan with one root containing"
+ "an aggregate and a nested-tuple-source.");
}
- IMergeAggregationExpressionFactory mergeAggregationExpressionFactory = context
- .getMergeAggregationExpressionFactory();
+ IMergeAggregationExpressionFactory mergeAggregationExpressionFactory =
+ context.getMergeAggregationExpressionFactory();
Mutable<ILogicalOperator> r0 = p0.getRoots().get(0);
AbstractLogicalOperator r0Logical = (AbstractLogicalOperator) r0.getValue();
if (r0Logical.getOperatorTag() != LogicalOperatorTag.AGGREGATE) {
http://git-wip-us.apache.org/repos/asf/asterixdb/blob/cb9ca975/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/SetClosedRecordConstructorsRule.java
----------------------------------------------------------------------
diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/SetClosedRecordConstructorsRule.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/SetClosedRecordConstructorsRule.java
index d1e7d5c..48a744d 100644
--- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/SetClosedRecordConstructorsRule.java
+++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/SetClosedRecordConstructorsRule.java
@@ -130,8 +130,7 @@ public class SetClosedRecordConstructorsRule implements IAlgebraicRewriteRule {
}
}
if (allClosed) {
- expr.setFunctionInfo(
- FunctionUtil.getFunctionInfo(BuiltinFunctions.CLOSED_RECORD_CONSTRUCTOR));
+ expr.setFunctionInfo(FunctionUtil.getFunctionInfo(BuiltinFunctions.CLOSED_RECORD_CONSTRUCTOR));
GlobalConfig.ASTERIX_LOGGER.trace("Switching to CLOSED record constructor in " + expr + ".\n");
changed = true;
}
http://git-wip-us.apache.org/repos/asf/asterixdb/blob/cb9ca975/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/SetupCommitExtensionOpRule.java
----------------------------------------------------------------------
diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/SetupCommitExtensionOpRule.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/SetupCommitExtensionOpRule.java
index 7dfe161..90491d3 100644
--- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/SetupCommitExtensionOpRule.java
+++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/SetupCommitExtensionOpRule.java
@@ -99,8 +99,7 @@ public class SetupCommitExtensionOpRule implements IAlgebraicRewriteRule {
//create the logical and physical operator
CommitOperator commitOperator = new CommitOperator(primaryKeyLogicalVars, isSink);
- CommitPOperator commitPOperator =
- new CommitPOperator(dataset, primaryKeyLogicalVars, isSink);
+ CommitPOperator commitPOperator = new CommitPOperator(dataset, primaryKeyLogicalVars, isSink);
commitOperator.setPhysicalOperator(commitPOperator);
//create ExtensionOperator and put the commitOperator in it.
http://git-wip-us.apache.org/repos/asf/asterixdb/blob/cb9ca975/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/SimilarityCheckRule.java
----------------------------------------------------------------------
diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/SimilarityCheckRule.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/SimilarityCheckRule.java
index 1e445e5..0c3de91 100644
--- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/SimilarityCheckRule.java
+++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/SimilarityCheckRule.java
@@ -183,8 +183,8 @@ public class SimilarityCheckRule implements IAlgebraicRewriteRule {
if (simCheckFuncExpr != null) {
// Create a new assign under matchingAssign which assigns the result of our similarity-check function to a variable.
LogicalVariable newVar = context.newVar();
- AssignOperator newAssign = new AssignOperator(newVar,
- new MutableObject<ILogicalExpression>(simCheckFuncExpr));
+ AssignOperator newAssign =
+ new AssignOperator(newVar, new MutableObject<ILogicalExpression>(simCheckFuncExpr));
// Hook up inputs.
newAssign.getInputs()
.add(new MutableObject<ILogicalOperator>(matchingAssign.getInputs().get(0).getValue()));
http://git-wip-us.apache.org/repos/asf/asterixdb/blob/cb9ca975/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/BTreeAccessMethod.java
----------------------------------------------------------------------
diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/BTreeAccessMethod.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/BTreeAccessMethod.java
index 29d00d0..1f4676c 100644
--- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/BTreeAccessMethod.java
+++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/BTreeAccessMethod.java
@@ -87,12 +87,8 @@ public class BTreeAccessMethod implements IAccessMethod {
}
private static final List<FunctionIdentifier> FUNC_IDENTIFIERS =
- Collections.unmodifiableList(Arrays.asList(
- AlgebricksBuiltinFunctions.EQ,
- AlgebricksBuiltinFunctions.LE,
- AlgebricksBuiltinFunctions.GE,
- AlgebricksBuiltinFunctions.LT,
- AlgebricksBuiltinFunctions.GT));
+ Collections.unmodifiableList(Arrays.asList(AlgebricksBuiltinFunctions.EQ, AlgebricksBuiltinFunctions.LE,
+ AlgebricksBuiltinFunctions.GE, AlgebricksBuiltinFunctions.LT, AlgebricksBuiltinFunctions.GT));
public static final BTreeAccessMethod INSTANCE = new BTreeAccessMethod();
@@ -105,9 +101,8 @@ public class BTreeAccessMethod implements IAccessMethod {
public boolean analyzeFuncExprArgsAndUpdateAnalysisCtx(AbstractFunctionCallExpression funcExpr,
List<AbstractLogicalOperator> assignsAndUnnests, AccessMethodAnalysisContext analysisCtx,
IOptimizationContext context, IVariableTypeEnvironment typeEnvironment) throws AlgebricksException {
- boolean matches =
- AccessMethodUtils.analyzeFuncExprArgsForOneConstAndVarAndUpdateAnalysisCtx(
- funcExpr, analysisCtx, context, typeEnvironment);
+ boolean matches = AccessMethodUtils.analyzeFuncExprArgsForOneConstAndVarAndUpdateAnalysisCtx(funcExpr,
+ analysisCtx, context, typeEnvironment);
if (!matches) {
matches = AccessMethodUtils.analyzeFuncExprArgsForTwoVarsAndUpdateAnalysisCtx(funcExpr, analysisCtx);
}
@@ -131,13 +126,13 @@ public class BTreeAccessMethod implements IAccessMethod {
SelectOperator select = (SelectOperator) selectRef.getValue();
Mutable<ILogicalExpression> conditionRef = select.getCondition();
- ILogicalOperator primaryIndexUnnestOp = createSecondaryToPrimaryPlan(conditionRef, subTree, null, chosenIndex,
- analysisCtx,
- AccessMethodUtils.retainInputs(subTree.getDataSourceVariables(), subTree.getDataSourceRef().getValue(),
- afterSelectRefs),
- false, subTree.getDataSourceRef().getValue().getInputs().get(0).getValue()
- .getExecutionMode() == ExecutionMode.UNPARTITIONED,
- context);
+ ILogicalOperator primaryIndexUnnestOp =
+ createSecondaryToPrimaryPlan(conditionRef, subTree, null, chosenIndex, analysisCtx,
+ AccessMethodUtils.retainInputs(subTree.getDataSourceVariables(),
+ subTree.getDataSourceRef().getValue(), afterSelectRefs),
+ false, subTree.getDataSourceRef().getValue().getInputs().get(0).getValue()
+ .getExecutionMode() == ExecutionMode.UNPARTITIONED,
+ context);
if (primaryIndexUnnestOp == null) {
return false;
http://git-wip-us.apache.org/repos/asf/asterixdb/blob/cb9ca975/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/IntroduceJoinAccessMethodRule.java
----------------------------------------------------------------------
diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/IntroduceJoinAccessMethodRule.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/IntroduceJoinAccessMethodRule.java
index 5c1a95e..1171ae5 100644
--- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/IntroduceJoinAccessMethodRule.java
+++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/IntroduceJoinAccessMethodRule.java
@@ -361,8 +361,8 @@ public class IntroduceJoinAccessMethodRule extends AbstractIntroduceAccessMethod
// in GroupByOp.
if (isThisOpLeftOuterJoin && isParentOpGroupBy) {
analysisCtx.setLOJGroupbyOpRef(opRef);
- ScalarFunctionCallExpression isNullFuncExpr = AccessMethodUtils
- .findLOJIsMissingFuncInGroupBy((GroupByOperator) opRef.getValue());
+ ScalarFunctionCallExpression isNullFuncExpr =
+ AccessMethodUtils.findLOJIsMissingFuncInGroupBy((GroupByOperator) opRef.getValue());
analysisCtx.setLOJIsNullFuncInGroupBy(isNullFuncExpr);
}
http://git-wip-us.apache.org/repos/asf/asterixdb/blob/cb9ca975/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/IntroducePrimaryIndexForAggregationRule.java
----------------------------------------------------------------------
diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/IntroducePrimaryIndexForAggregationRule.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/IntroducePrimaryIndexForAggregationRule.java
index eaea208..7b8b906 100644
--- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/IntroducePrimaryIndexForAggregationRule.java
+++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/IntroducePrimaryIndexForAggregationRule.java
@@ -123,21 +123,20 @@ public class IntroducePrimaryIndexForAggregationRule implements IAlgebraicRewrit
}
context.addToDontApplySet(this, opRef.getValue());
// find the data scan or unnest map
- Pair<Mutable<ILogicalOperator>,Mutable<ILogicalOperator>> scanAndAssignOpRef =
- findScanAndAssignOperator(localAggregateOperator,context.getMetadataProvider());
+ Pair<Mutable<ILogicalOperator>, Mutable<ILogicalOperator>> scanAndAssignOpRef =
+ findScanAndAssignOperator(localAggregateOperator, context.getMetadataProvider());
if (scanAndAssignOpRef == null) {
return false;
}
// find its primary index and replace datascan
- boolean transformed =
- replaceDatascan(localAggregateOperator,scanAndAssignOpRef, context);
+ boolean transformed = replaceDatascan(localAggregateOperator, scanAndAssignOpRef, context);
if (transformed) {
OperatorPropertiesUtil.typeOpRec(opRef, context);
}
return transformed;
}
- private Pair<Mutable<ILogicalOperator>,Mutable<ILogicalOperator>> findScanAndAssignOperator(
+ private Pair<Mutable<ILogicalOperator>, Mutable<ILogicalOperator>> findScanAndAssignOperator(
ILogicalOperator localAggregateOperator, IMetadataProvider metadataProvider) throws AlgebricksException {
Mutable<ILogicalOperator> scanOpRef = localAggregateOperator.getInputs().get(0);
Mutable<ILogicalOperator> assignOpRef = null;
@@ -148,8 +147,8 @@ public class IntroducePrimaryIndexForAggregationRule implements IAlgebraicRewrit
scanOpRef = scanOpRef.getValue().getInputs().get(0);
}
// next operator must be datascan or unnest map using the dataset
- if (scanOpRef.getValue().getOperatorTag() != LogicalOperatorTag.DATASOURCESCAN &&
- scanOpRef.getValue().getOperatorTag() != LogicalOperatorTag.UNNEST_MAP) {
+ if (scanOpRef.getValue().getOperatorTag() != LogicalOperatorTag.DATASOURCESCAN
+ && scanOpRef.getValue().getOperatorTag() != LogicalOperatorTag.UNNEST_MAP) {
return null;
}
if (scanOpRef.getValue().getOperatorTag() == LogicalOperatorTag.UNNEST_MAP) {
@@ -159,31 +158,31 @@ public class IntroducePrimaryIndexForAggregationRule implements IAlgebraicRewrit
if (logicalExpression.getExpressionTag() != LogicalExpressionTag.FUNCTION_CALL) {
return null;
}
- AbstractFunctionCallExpression functionCallExpression = (AbstractFunctionCallExpression)logicalExpression;
+ AbstractFunctionCallExpression functionCallExpression = (AbstractFunctionCallExpression) logicalExpression;
if (functionCallExpression.getFunctionIdentifier() != BuiltinFunctions.INDEX_SEARCH) {
return null;
}
- String indexName = ConstantExpressionUtil.getStringArgument(functionCallExpression,0);
- String dataverseName = ConstantExpressionUtil.getStringArgument(functionCallExpression,2);
- String datasetName = ConstantExpressionUtil.getStringArgument(functionCallExpression,3);
- Index index = ((MetadataProvider)metadataProvider).getIndex(dataverseName, datasetName, indexName);
+ String indexName = ConstantExpressionUtil.getStringArgument(functionCallExpression, 0);
+ String dataverseName = ConstantExpressionUtil.getStringArgument(functionCallExpression, 2);
+ String datasetName = ConstantExpressionUtil.getStringArgument(functionCallExpression, 3);
+ Index index = ((MetadataProvider) metadataProvider).getIndex(dataverseName, datasetName, indexName);
if (!index.isPrimaryIndex()) {
return null;
}
}
- return Pair.of(scanOpRef,assignOpRef);
+ return Pair.of(scanOpRef, assignOpRef);
}
private boolean replaceDatascan(AggregateOperator localAggregateOperator,
- Pair<Mutable<ILogicalOperator>,Mutable<ILogicalOperator>> scanAndAssignOpRef, IOptimizationContext context)
+ Pair<Mutable<ILogicalOperator>, Mutable<ILogicalOperator>> scanAndAssignOpRef, IOptimizationContext context)
throws AlgebricksException {
/* find the primary index */
Mutable<ILogicalOperator> scanOperatorRef = scanAndAssignOpRef.getLeft();
Mutable<ILogicalOperator> assignOperatorRef = scanAndAssignOpRef.getRight();
AbstractScanOperator scanOperator = (AbstractScanOperator) scanOperatorRef.getValue();
BTreeJobGenParams originalBTreeParameters = new BTreeJobGenParams();
- Pair<Dataset,Index> datasetAndIndex = findDatasetAndSecondaryPrimaryIndex(scanOperator,originalBTreeParameters,
- context);
+ Pair<Dataset, Index> datasetAndIndex =
+ findDatasetAndSecondaryPrimaryIndex(scanOperator, originalBTreeParameters, context);
if (datasetAndIndex == null) {
return false;
}
@@ -194,8 +193,8 @@ public class IntroducePrimaryIndexForAggregationRule implements IAlgebraicRewrit
/////// check usage of variables produced by scan operator in parents ///////
Set<LogicalVariable> variablesProducedByScanOp = getVariablesProducedByScanOp(scanOperator,
dataset.getPrimaryKeys().size(), scanOperator.getVariables().size());
- boolean variablesAreUsed = scanOperatorVariablesAreUsed(localAggregateOperator, assignOperatorRef,
- variablesProducedByScanOp);
+ boolean variablesAreUsed =
+ scanOperatorVariablesAreUsed(localAggregateOperator, assignOperatorRef, variablesProducedByScanOp);
if (variablesAreUsed) {
return false;
}
@@ -206,8 +205,8 @@ public class IntroducePrimaryIndexForAggregationRule implements IAlgebraicRewrit
retainInput = AccessMethodUtils.retainInputs(scanOperator.getVariables(), scanOperator, parents);
newBTreeParameters = new BTreeJobGenParams(primaryIndex.getIndexName(), DatasetConfig.IndexType.BTREE,
dataset.getDataverseName(), dataset.getDatasetName(), retainInput,
- scanOperator.getInputs().get(0).getValue().getExecutionMode() ==
- AbstractLogicalOperator.ExecutionMode.UNPARTITIONED);
+ scanOperator.getInputs().get(0).getValue()
+ .getExecutionMode() == AbstractLogicalOperator.ExecutionMode.UNPARTITIONED);
List<LogicalVariable> empty = new ArrayList<>();
newBTreeParameters.setLowKeyInclusive(true);
newBTreeParameters.setHighKeyInclusive(true);
@@ -227,9 +226,9 @@ public class IntroducePrimaryIndexForAggregationRule implements IAlgebraicRewrit
newBTreeParameters.setHighKeyVarList(originalBTreeParameters.getHighKeyVarList(), 0,
originalBTreeParameters.getHighKeyVarList().size());
}
- ARecordType recordType = (ARecordType) ((MetadataProvider)context.getMetadataProvider()).findType(dataset);
+ ARecordType recordType = (ARecordType) ((MetadataProvider) context.getMetadataProvider()).findType(dataset);
ARecordType metaRecordType =
- (ARecordType) ((MetadataProvider)context.getMetadataProvider()).findMetaType(dataset);
+ (ARecordType) ((MetadataProvider) context.getMetadataProvider()).findMetaType(dataset);
// create the operator that will replace the dataset scan/search
AbstractUnnestMapOperator primaryIndexUnnestOperator =
(AbstractUnnestMapOperator) AccessMethodUtils.createSecondaryIndexUnnestMap(dataset, recordType,
@@ -256,7 +255,7 @@ public class IntroducePrimaryIndexForAggregationRule implements IAlgebraicRewrit
* @return The dataset and its primary index
* @throws AlgebricksException when there is a problem getting the dataset or its indexes from the metadata
*/
- private Pair<Dataset,Index> findDatasetAndSecondaryPrimaryIndex(AbstractScanOperator scanOperator,
+ private Pair<Dataset, Index> findDatasetAndSecondaryPrimaryIndex(AbstractScanOperator scanOperator,
BTreeJobGenParams originalBTreeParameters, IOptimizationContext context) throws AlgebricksException {
// #1. get the dataset
Dataset dataset;
@@ -271,20 +270,20 @@ public class IntroducePrimaryIndexForAggregationRule implements IAlgebraicRewrit
} else {
// case 2: dataset range search
AbstractFunctionCallExpression primaryIndexFunctionCall =
- (AbstractFunctionCallExpression) ((UnnestMapOperator)scanOperator).getExpressionRef().getValue();
+ (AbstractFunctionCallExpression) ((UnnestMapOperator) scanOperator).getExpressionRef().getValue();
originalBTreeParameters.readFromFuncArgs(primaryIndexFunctionCall.getArguments());
if (originalBTreeParameters.isEqCondition()) {
return null;
}
- dataset = ((MetadataProvider)context.getMetadataProvider()).findDataset(
- originalBTreeParameters.getDataverseName(), originalBTreeParameters.getDatasetName());
+ dataset = ((MetadataProvider) context.getMetadataProvider())
+ .findDataset(originalBTreeParameters.getDataverseName(), originalBTreeParameters.getDatasetName());
}
// #2. get all indexes and look for the primary one
- List<Index> indexes = ((MetadataProvider)context.getMetadataProvider()).getDatasetIndexes(
- dataset.getDataverseName(), dataset.getDatasetName());
+ List<Index> indexes = ((MetadataProvider) context.getMetadataProvider())
+ .getDatasetIndexes(dataset.getDataverseName(), dataset.getDatasetName());
for (Index index : indexes) {
if (index.getKeyFieldNames().isEmpty()) {
- return Pair.of(dataset,index);
+ return Pair.of(dataset, index);
}
}
return null;
http://git-wip-us.apache.org/repos/asf/asterixdb/blob/cb9ca975/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/IntroduceSelectAccessMethodRule.java
----------------------------------------------------------------------
diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/IntroduceSelectAccessMethodRule.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/IntroduceSelectAccessMethodRule.java
index d95b278..d0e973f 100644
--- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/IntroduceSelectAccessMethodRule.java
+++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/IntroduceSelectAccessMethodRule.java
@@ -177,8 +177,8 @@ public class IntroduceSelectAccessMethodRule extends AbstractIntroduceAccessMeth
Map<IAccessMethod, AccessMethodAnalysisContext> analyzedAMs, IOptimizationContext context)
throws AlgebricksException {
Pair<IAccessMethod, Index> chosenIndex = null;
- Optional<Pair<IAccessMethod, Index>> primaryIndex = chosenIndexes.stream()
- .filter(pair -> pair.second.isPrimaryIndex()).findFirst();
+ Optional<Pair<IAccessMethod, Index>> primaryIndex =
+ chosenIndexes.stream().filter(pair -> pair.second.isPrimaryIndex()).findFirst();
if (chosenIndexes.size() == 1) {
chosenIndex = chosenIndexes.get(0);
} else if (primaryIndex.isPresent()) {
@@ -235,8 +235,8 @@ public class IntroduceSelectAccessMethodRule extends AbstractIntroduceAccessMeth
throw new AlgebricksException(
"The order by expression should be variables, but they aren't variables.");
}
- VariableReferenceExpression orderedVar = (VariableReferenceExpression) orderExpression.second
- .getValue();
+ VariableReferenceExpression orderedVar =
+ (VariableReferenceExpression) orderExpression.second.getValue();
orderedColumn.add(orderedVar.getVariableReference());
}
inputVars.add(orderedColumn);
@@ -373,7 +373,6 @@ public class IntroduceSelectAccessMethodRule extends AbstractIntroduceAccessMeth
}
-
@Override
public Map<FunctionIdentifier, List<IAccessMethod>> getAccessMethods() {
return accessMethods;