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;
