http://git-wip-us.apache.org/repos/asf/asterixdb/blob/ef9be0f9/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/AbstractIntroduceAccessMethodRule.java ---------------------------------------------------------------------- diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/AbstractIntroduceAccessMethodRule.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/AbstractIntroduceAccessMethodRule.java index e6cf12d..ca042f1 100644 --- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/AbstractIntroduceAccessMethodRule.java +++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/AbstractIntroduceAccessMethodRule.java @@ -28,10 +28,10 @@ import java.util.Map; import org.apache.asterix.common.config.DatasetConfig.IndexType; import org.apache.asterix.dataflow.data.common.ExpressionTypeComputer; -import org.apache.asterix.metadata.api.IMetadataEntity; import org.apache.asterix.metadata.declared.MetadataProvider; import org.apache.asterix.metadata.entities.Index; -import org.apache.asterix.metadata.utils.DatasetUtils; +import org.apache.asterix.metadata.utils.DatasetUtil; +import org.apache.asterix.metadata.utils.MetadataUtil; import org.apache.asterix.om.base.AOrderedList; import org.apache.asterix.om.base.AString; import org.apache.asterix.om.constants.AsterixConstantValue; @@ -42,7 +42,7 @@ import org.apache.asterix.om.types.AbstractCollectionType; import org.apache.asterix.om.types.BuiltinType; import org.apache.asterix.om.types.IAType; import org.apache.asterix.om.types.hierachy.ATypeHierarchy; -import org.apache.asterix.om.util.ConstantExpressionUtil; +import org.apache.asterix.om.utils.ConstantExpressionUtil; import org.apache.asterix.optimizer.rules.am.OptimizableOperatorSubTree.DataSourceType; import org.apache.commons.lang3.mutable.Mutable; import org.apache.hyracks.algebricks.common.exceptions.AlgebricksException; @@ -76,15 +76,13 @@ public abstract class AbstractIntroduceAccessMethodRule implements IAlgebraicRew private MetadataProvider metadataProvider; // Function Identifier sets that retain the original field variable through each function's arguments - private final ImmutableSet<FunctionIdentifier> funcIDSetThatRetainFieldName = ImmutableSet.of( - BuiltinFunctions.WORD_TOKENS, BuiltinFunctions.GRAM_TOKENS, BuiltinFunctions.SUBSTRING, - BuiltinFunctions.SUBSTRING_BEFORE, BuiltinFunctions.SUBSTRING_AFTER, - BuiltinFunctions.CREATE_POLYGON, BuiltinFunctions.CREATE_MBR, - BuiltinFunctions.CREATE_RECTANGLE, BuiltinFunctions.CREATE_CIRCLE, - BuiltinFunctions.CREATE_LINE, BuiltinFunctions.CREATE_POINT, - BuiltinFunctions.NUMERIC_ADD, BuiltinFunctions.NUMERIC_SUBTRACT, - BuiltinFunctions.NUMERIC_MULTIPLY, BuiltinFunctions.NUMERIC_DIVIDE, - BuiltinFunctions.NUMERIC_MOD); + private final ImmutableSet<FunctionIdentifier> funcIDSetThatRetainFieldName = + ImmutableSet.of(BuiltinFunctions.WORD_TOKENS, BuiltinFunctions.GRAM_TOKENS, BuiltinFunctions.SUBSTRING, + BuiltinFunctions.SUBSTRING_BEFORE, BuiltinFunctions.SUBSTRING_AFTER, + BuiltinFunctions.CREATE_POLYGON, BuiltinFunctions.CREATE_MBR, BuiltinFunctions.CREATE_RECTANGLE, + BuiltinFunctions.CREATE_CIRCLE, BuiltinFunctions.CREATE_LINE, BuiltinFunctions.CREATE_POINT, + BuiltinFunctions.NUMERIC_ADD, BuiltinFunctions.NUMERIC_SUBTRACT, BuiltinFunctions.NUMERIC_MULTIPLY, + BuiltinFunctions.NUMERIC_DIVIDE, BuiltinFunctions.NUMERIC_MOD); public abstract Map<FunctionIdentifier, List<IAccessMethod>> getAccessMethods(); @@ -94,7 +92,7 @@ public abstract class AbstractIntroduceAccessMethodRule implements IAlgebraicRew for (FunctionIdentifier funcIdent : funcs) { List<IAccessMethod> l = accessMethods.get(funcIdent); if (l == null) { - l = new ArrayList<IAccessMethod>(); + l = new ArrayList<>(); accessMethods.put(funcIdent, l); } l.add(accessMethod); @@ -112,7 +110,7 @@ public abstract class AbstractIntroduceAccessMethodRule implements IAlgebraicRew protected void fillSubTreeIndexExprs(OptimizableOperatorSubTree subTree, Map<IAccessMethod, AccessMethodAnalysisContext> analyzedAMs, IOptimizationContext context) - throws AlgebricksException { + throws AlgebricksException { Iterator<Map.Entry<IAccessMethod, AccessMethodAnalysisContext>> amIt = analyzedAMs.entrySet().iterator(); // Check applicability of indexes by access method type. while (amIt.hasNext()) { @@ -159,15 +157,15 @@ public abstract class AbstractIntroduceAccessMethodRule implements IAlgebraicRew */ protected List<Pair<IAccessMethod, Index>> chooseAllIndex( Map<IAccessMethod, AccessMethodAnalysisContext> analyzedAMs) { - List<Pair<IAccessMethod, Index>> result = new ArrayList<Pair<IAccessMethod, Index>>(); + List<Pair<IAccessMethod, Index>> result = new ArrayList<>(); // Use variables (fields) to the index types map to check which type of indexes are applied for the vars. Map<List<Pair<Integer, Integer>>, List<IndexType>> resultVarsToIndexTypesMap = new HashMap<>(); Iterator<Map.Entry<IAccessMethod, AccessMethodAnalysisContext>> amIt = analyzedAMs.entrySet().iterator(); while (amIt.hasNext()) { Map.Entry<IAccessMethod, AccessMethodAnalysisContext> amEntry = amIt.next(); AccessMethodAnalysisContext analysisCtx = amEntry.getValue(); - Iterator<Map.Entry<Index, List<Pair<Integer, Integer>>>> indexIt = analysisCtx.indexExprsAndVars.entrySet() - .iterator(); + Iterator<Map.Entry<Index, List<Pair<Integer, Integer>>>> indexIt = + analysisCtx.indexExprsAndVars.entrySet().iterator(); while (indexIt.hasNext()) { Map.Entry<Index, List<Pair<Integer, Integer>>> indexEntry = indexIt.next(); IAccessMethod chosenAccessMethod = amEntry.getKey(); @@ -184,13 +182,13 @@ public abstract class AbstractIntroduceAccessMethodRule implements IAlgebraicRew List<IndexType> appliedIndexTypes = resultVarsToIndexTypesMap.get(indexEntry.getValue()); if (!appliedIndexTypes.contains(indexType)) { appliedIndexTypes.add(indexType); - result.add(new Pair<IAccessMethod, Index>(chosenAccessMethod, chosenIndex)); + result.add(new Pair<>(chosenAccessMethod, chosenIndex)); } } else { List<IndexType> addedIndexTypes = new ArrayList<>(); addedIndexTypes.add(indexType); resultVarsToIndexTypesMap.put(indexEntry.getValue(), addedIndexTypes); - result.add(new Pair<IAccessMethod, Index>(chosenAccessMethod, chosenIndex)); + result.add(new Pair<>(chosenAccessMethod, chosenIndex)); } } } @@ -210,11 +208,11 @@ public abstract class AbstractIntroduceAccessMethodRule implements IAlgebraicRew */ public void pruneIndexCandidates(IAccessMethod accessMethod, AccessMethodAnalysisContext analysisCtx, IOptimizationContext context, IVariableTypeEnvironment typeEnvironment) throws AlgebricksException { - Iterator<Map.Entry<Index, List<Pair<Integer, Integer>>>> indexExprAndVarIt = analysisCtx.indexExprsAndVars - .entrySet().iterator(); + Iterator<Map.Entry<Index, List<Pair<Integer, Integer>>>> indexExprAndVarIt = + analysisCtx.indexExprsAndVars.entrySet().iterator(); // Used to keep track of matched expressions (added for prefix search) int numMatchedKeys = 0; - ArrayList<Integer> matchedExpressions = new ArrayList<Integer>(); + ArrayList<Integer> matchedExpressions = new ArrayList<>(); while (indexExprAndVarIt.hasNext()) { Map.Entry<Index, List<Pair<Integer, Integer>>> indexExprAndVarEntry = indexExprAndVarIt.next(); Index index = indexExprAndVarEntry.getKey(); @@ -252,8 +250,7 @@ public abstract class AbstractIntroduceAccessMethodRule implements IAlgebraicRew if (matchedTypes.size() < 2 && optFuncExpr.getNumLogicalVars() == 1) { matchedTypes .add((IAType) ExpressionTypeComputer.INSTANCE.getType(optFuncExpr.getConstantExpr(0), - context.getMetadataProvider(), - typeEnvironment)); + context.getMetadataProvider(), typeEnvironment)); } //infer type of logicalExpr based on index keyType @@ -271,7 +268,7 @@ public abstract class AbstractIntroduceAccessMethodRule implements IAlgebraicRew @Override public Object getVarType(LogicalVariable var, List<LogicalVariable> nonNullVariables, List<List<LogicalVariable>> correlatedNullableVariableLists) - throws AlgebricksException { + throws AlgebricksException { if (var.equals(optFuncExpr.getSourceVar(exprAndVarIdx.second))) { return keyType; } @@ -321,8 +318,8 @@ public abstract class AbstractIntroduceAccessMethodRule implements IAlgebraicRew // Check if any field name in the optFuncExpr matches. if (optFuncExpr.findFieldName(keyField) != -1) { - foundKeyField = typeMatch - && optFuncExpr.getOperatorSubTree(exprAndVarIdx.second).hasDataSourceScan(); + foundKeyField = + typeMatch && optFuncExpr.getOperatorSubTree(exprAndVarIdx.second).hasDataSourceScan(); if (foundKeyField) { matchedExpressions.add(exprAndVarIdx.first); numMatchedKeys++; @@ -401,8 +398,8 @@ public abstract class AbstractIntroduceAccessMethodRule implements IAlgebraicRew continue; } AbstractFunctionCallExpression argFuncExpr = (AbstractFunctionCallExpression) argExpr; - boolean matchFound = analyzeFunctionExpr(argFuncExpr, assignsAndUnnests, analyzedAMs, context, - typeEnvironment); + boolean matchFound = + analyzeFunctionExpr(argFuncExpr, assignsAndUnnests, analyzedAMs, context, typeEnvironment); found = found || matchFound; } return found; @@ -467,13 +464,13 @@ public abstract class AbstractIntroduceAccessMethodRule implements IAlgebraicRew protected boolean fillIndexExprs(List<Index> datasetIndexes, List<String> fieldName, IAType fieldType, IOptimizableFuncExpr optFuncExpr, int matchedFuncExprIndex, int varIdx, OptimizableOperatorSubTree matchedSubTree, AccessMethodAnalysisContext analysisCtx) - throws AlgebricksException { - List<Index> indexCandidates = new ArrayList<Index>(); + throws AlgebricksException { + List<Index> indexCandidates = new ArrayList<>(); // Add an index to the candidates if one of the indexed fields is // fieldName for (Index index : datasetIndexes) { // Need to also verify the index is pending no op - if (index.getKeyFieldNames().contains(fieldName) && index.getPendingOp() == IMetadataEntity.PENDING_NO_OP) { + if (index.getKeyFieldNames().contains(fieldName) && index.getPendingOp() == MetadataUtil.PENDING_NO_OP) { indexCandidates.add(index); if (optFuncExpr.getFieldType(varIdx) == BuiltinType.AMISSING || optFuncExpr.getFieldType(varIdx) == BuiltinType.ANY) { @@ -493,7 +490,7 @@ public abstract class AbstractIntroduceAccessMethodRule implements IAlgebraicRew protected void fillAllIndexExprs(OptimizableOperatorSubTree subTree, AccessMethodAnalysisContext analysisCtx, IOptimizationContext context) throws AlgebricksException { int optFuncExprIndex = 0; - List<Index> datasetIndexes = new ArrayList<Index>(); + List<Index> datasetIndexes = new ArrayList<>(); LogicalVariable datasetMetaVar = null; LogicalVariable datasetRecordVar = null; if (subTree.getDataSourceType() != DataSourceType.COLLECTION_SCAN) { @@ -532,7 +529,7 @@ public abstract class AbstractIntroduceAccessMethodRule implements IAlgebraicRew List<LogicalVariable> additionalDsVarList = null; if (subTree.hasIxJoinOuterAdditionalDataSource()) { - additionalDsVarList = new ArrayList<LogicalVariable>(); + additionalDsVarList = new ArrayList<>(); for (int i = 0; i < subTree.getIxJoinOuterAdditionalDataSourceRefs().size(); i++) { additionalDsVarList.addAll(subTree.getIxJoinOuterAdditionalDataSourceVariables(i)); } @@ -571,8 +568,8 @@ public abstract class AbstractIntroduceAccessMethodRule implements IAlgebraicRew return; } } - IAType fieldType = (IAType) context.getOutputTypeEnvironment(unnestOp) - .getType(optFuncExpr.getLogicalExpr(funcVarIndex)); + IAType fieldType = + (IAType) context.getOutputTypeEnvironment(unnestOp).getType(optFuncExpr.getLogicalExpr(funcVarIndex)); // Set the fieldName in the corresponding matched function // expression. optFuncExpr.setFieldName(funcVarIndex, fieldName); @@ -624,7 +621,7 @@ public abstract class AbstractIntroduceAccessMethodRule implements IAlgebraicRew private void matchVarsFromOptFuncExprToDataSourceScan(IOptimizableFuncExpr optFuncExpr, int optFuncExprIndex, List<Index> datasetIndexes, List<LogicalVariable> dsVarList, OptimizableOperatorSubTree subTree, AccessMethodAnalysisContext analysisCtx, IOptimizationContext context, boolean fromAdditionalDataSource) - throws AlgebricksException { + throws AlgebricksException { for (int varIndex = 0; varIndex < dsVarList.size(); varIndex++) { LogicalVariable var = dsVarList.get(varIndex); int funcVarIndex = optFuncExpr.findLogicalVar(var); @@ -638,7 +635,7 @@ public abstract class AbstractIntroduceAccessMethodRule implements IAlgebraicRew List<List<String>> subTreePKs = null; if (!fromAdditionalDataSource) { - subTreePKs = DatasetUtils.getPartitioningKeys(subTree.getDataset()); + subTreePKs = DatasetUtil.getPartitioningKeys(subTree.getDataset()); // Check whether this variable is PK, not a record variable. if (varIndex <= subTreePKs.size() - 1) { fieldName = subTreePKs.get(varIndex); @@ -649,8 +646,8 @@ public abstract class AbstractIntroduceAccessMethodRule implements IAlgebraicRew // Need to check additional dataset one by one for (int i = 0; i < subTree.getIxJoinOuterAdditionalDatasets().size(); i++) { if (subTree.getIxJoinOuterAdditionalDatasets().get(i) != null) { - subTreePKs = DatasetUtils - .getPartitioningKeys(subTree.getIxJoinOuterAdditionalDatasets().get(i)); + subTreePKs = + DatasetUtil.getPartitioningKeys(subTree.getIxJoinOuterAdditionalDatasets().get(i)); // Check whether this variable is PK, not a record variable. if (subTreePKs.contains(var) && varIndex <= subTreePKs.size() - 1) { @@ -693,10 +690,10 @@ public abstract class AbstractIntroduceAccessMethodRule implements IAlgebraicRew * * @throws AlgebricksException */ - protected List<String> getFieldNameFromSubTree(IOptimizableFuncExpr optFuncExpr, OptimizableOperatorSubTree subTree, - int opIndex, int assignVarIndex, ARecordType recordType, int funcVarIndex, - ILogicalExpression parentFuncExpr, LogicalVariable recordVar, ARecordType metaType, LogicalVariable metaVar) - throws AlgebricksException { + protected List<String> getFieldNameFromSubTree(IOptimizableFuncExpr optFuncExpr, + OptimizableOperatorSubTree subTree, int opIndex, int assignVarIndex, ARecordType recordType, + int funcVarIndex, ILogicalExpression parentFuncExpr, LogicalVariable recordVar, ARecordType metaType, + LogicalVariable metaVar) throws AlgebricksException { // Get expression corresponding to opVar at varIndex. AbstractLogicalExpression expr = null; AbstractFunctionCallExpression childFuncExpr = null; @@ -752,9 +749,9 @@ public abstract class AbstractIntroduceAccessMethodRule implements IAlgebraicRew return Collections.emptyList(); } ConstantExpression constExpr = (ConstantExpression) nameArg; - AOrderedList orderedNestedFieldName = (AOrderedList) ((AsterixConstantValue) constExpr.getValue()) - .getObject(); - nestedAccessFieldName = new ArrayList<String>(); + AOrderedList orderedNestedFieldName = + (AOrderedList) ((AsterixConstantValue) constExpr.getValue()).getObject(); + nestedAccessFieldName = new ArrayList<>(); for (int i = 0; i < orderedNestedFieldName.size(); i++) { nestedAccessFieldName.add(((AString) orderedNestedFieldName.getItem(i)).getStringValue()); } @@ -762,8 +759,8 @@ public abstract class AbstractIntroduceAccessMethodRule implements IAlgebraicRew isByName = true; } if (isFieldAccess) { - LogicalVariable sourceVar = ((VariableReferenceExpression) funcExpr.getArguments().get(0).getValue()) - .getVariableReference(); + LogicalVariable sourceVar = + ((VariableReferenceExpression) funcExpr.getArguments().get(0).getValue()).getVariableReference(); optFuncExpr.setLogicalExpr(funcVarIndex, parentFuncExpr); int[] assignAndExpressionIndexes = null; @@ -785,7 +782,7 @@ public abstract class AbstractIntroduceAccessMethodRule implements IAlgebraicRew //Go through variables in assign to check for match for (int varIndex = 0; varIndex < varList.size(); varIndex++) { LogicalVariable var = varList.get(varIndex); - ArrayList<LogicalVariable> parentVars = new ArrayList<LogicalVariable>(); + ArrayList<LogicalVariable> parentVars = new ArrayList<>(); expr.getUsedVariables(parentVars); if (parentVars.contains(var)) {
http://git-wip-us.apache.org/repos/asf/asterixdb/blob/ef9be0f9/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/AccessMethodJobGenParams.java ---------------------------------------------------------------------- diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/AccessMethodJobGenParams.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/AccessMethodJobGenParams.java index 331922d..e541a79 100644 --- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/AccessMethodJobGenParams.java +++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/AccessMethodJobGenParams.java @@ -35,6 +35,7 @@ import org.apache.hyracks.algebricks.core.algebra.expressions.VariableReferenceE * and from a list of function arguments, typically of an unnest-map. */ public class AccessMethodJobGenParams { + private static final int NUM_PARAMS = 6; protected String indexName; protected IndexType indexType; protected String dataverseName; @@ -43,9 +44,8 @@ public class AccessMethodJobGenParams { protected boolean requiresBroadcast; protected boolean isPrimaryIndex; - private final int NUM_PARAMS = 6; - public AccessMethodJobGenParams() { + // Enable creation of an empty object and fill members using setters } public AccessMethodJobGenParams(String indexName, IndexType indexType, String dataverseName, String datasetName, @@ -60,12 +60,12 @@ public class AccessMethodJobGenParams { } public void writeToFuncArgs(List<Mutable<ILogicalExpression>> funcArgs) { - funcArgs.add(new MutableObject<ILogicalExpression>(AccessMethodUtils.createStringConstant(indexName))); - funcArgs.add(new MutableObject<ILogicalExpression>(AccessMethodUtils.createInt32Constant(indexType.ordinal()))); - funcArgs.add(new MutableObject<ILogicalExpression>(AccessMethodUtils.createStringConstant(dataverseName))); - funcArgs.add(new MutableObject<ILogicalExpression>(AccessMethodUtils.createStringConstant(datasetName))); - funcArgs.add(new MutableObject<ILogicalExpression>(AccessMethodUtils.createBooleanConstant(retainInput))); - funcArgs.add(new MutableObject<ILogicalExpression>(AccessMethodUtils.createBooleanConstant(requiresBroadcast))); + funcArgs.add(new MutableObject<>(AccessMethodUtils.createStringConstant(indexName))); + funcArgs.add(new MutableObject<>(AccessMethodUtils.createInt32Constant(indexType.ordinal()))); + funcArgs.add(new MutableObject<>(AccessMethodUtils.createStringConstant(dataverseName))); + funcArgs.add(new MutableObject<>(AccessMethodUtils.createStringConstant(datasetName))); + funcArgs.add(new MutableObject<>(AccessMethodUtils.createBooleanConstant(retainInput))); + funcArgs.add(new MutableObject<>(AccessMethodUtils.createBooleanConstant(requiresBroadcast))); } public void readFromFuncArgs(List<Mutable<ILogicalExpression>> funcArgs) { @@ -103,12 +103,11 @@ public class AccessMethodJobGenParams { } protected void writeVarList(List<LogicalVariable> varList, List<Mutable<ILogicalExpression>> funcArgs) { - Mutable<ILogicalExpression> numKeysRef = new MutableObject<ILogicalExpression>( - new ConstantExpression(new AsterixConstantValue(new AInt32(varList.size())))); + Mutable<ILogicalExpression> numKeysRef = + new MutableObject<>(new ConstantExpression(new AsterixConstantValue(new AInt32(varList.size())))); funcArgs.add(numKeysRef); for (LogicalVariable keyVar : varList) { - Mutable<ILogicalExpression> keyVarRef = new MutableObject<ILogicalExpression>( - new VariableReferenceExpression(keyVar)); + Mutable<ILogicalExpression> keyVarRef = new MutableObject<>(new VariableReferenceExpression(keyVar)); funcArgs.add(keyVarRef); } } @@ -117,8 +116,8 @@ public class AccessMethodJobGenParams { int numLowKeys = AccessMethodUtils.getInt32Constant(funcArgs.get(index)); if (numLowKeys > 0) { for (int i = 0; i < numLowKeys; i++) { - LogicalVariable var = ((VariableReferenceExpression) funcArgs.get(index + 1 + i).getValue()) - .getVariableReference(); + LogicalVariable var = + ((VariableReferenceExpression) funcArgs.get(index + 1 + i).getValue()).getVariableReference(); varList.add(var); } } http://git-wip-us.apache.org/repos/asf/asterixdb/blob/ef9be0f9/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/AccessMethodUtils.java ---------------------------------------------------------------------- diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/AccessMethodUtils.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/AccessMethodUtils.java index 189f37e..7743d9f 100644 --- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/AccessMethodUtils.java +++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/AccessMethodUtils.java @@ -36,8 +36,8 @@ import org.apache.asterix.metadata.declared.DataSourceId; import org.apache.asterix.metadata.entities.Dataset; import org.apache.asterix.metadata.entities.ExternalDatasetDetails; import org.apache.asterix.metadata.entities.Index; -import org.apache.asterix.metadata.utils.DatasetUtils; -import org.apache.asterix.metadata.utils.KeyFieldTypeUtils; +import org.apache.asterix.metadata.utils.DatasetUtil; +import org.apache.asterix.metadata.utils.KeyFieldTypeUtil; import org.apache.asterix.om.base.ABoolean; import org.apache.asterix.om.base.AInt32; import org.apache.asterix.om.base.AString; @@ -50,7 +50,7 @@ import org.apache.asterix.om.types.ATypeTag; import org.apache.asterix.om.types.BuiltinType; import org.apache.asterix.om.types.IAType; import org.apache.asterix.om.types.hierachy.ATypeHierarchy; -import org.apache.asterix.om.util.ConstantExpressionUtil; +import org.apache.asterix.om.utils.ConstantExpressionUtil; import org.apache.commons.lang3.mutable.Mutable; import org.apache.commons.lang3.mutable.MutableObject; import org.apache.hyracks.algebricks.common.exceptions.AlgebricksException; @@ -76,7 +76,6 @@ import org.apache.hyracks.algebricks.core.algebra.operators.logical.AbstractUnne import org.apache.hyracks.algebricks.core.algebra.operators.logical.GroupByOperator; import org.apache.hyracks.algebricks.core.algebra.operators.logical.LeftOuterUnnestMapOperator; import org.apache.hyracks.algebricks.core.algebra.operators.logical.OrderOperator; -import org.apache.hyracks.algebricks.core.algebra.operators.logical.OrderOperator.IOrder; import org.apache.hyracks.algebricks.core.algebra.operators.logical.SelectOperator; import org.apache.hyracks.algebricks.core.algebra.operators.logical.UnnestMapOperator; import org.apache.hyracks.algebricks.core.algebra.operators.logical.visitors.VariableUtilities; @@ -93,7 +92,7 @@ public class AccessMethodUtils { List<Object> target) throws AlgebricksException { ARecordType recordType = (ARecordType) itemType; ARecordType metaRecordType = (ARecordType) metaItemType; - target.addAll(KeyFieldTypeUtils.getPartitoningKeyTypes(dataset, recordType, metaRecordType)); + target.addAll(KeyFieldTypeUtil.getPartitoningKeyTypes(dataset, recordType, metaRecordType)); // Adds data record type. target.add(itemType); // Adds meta record type if any. @@ -281,10 +280,10 @@ public class AccessMethodUtils { if (!primaryKeysOnly) { switch (index.getIndexType()) { case BTREE: - dest.addAll(KeyFieldTypeUtils.getBTreeIndexKeyTypes(index, recordType, metaRecordType)); + dest.addAll(KeyFieldTypeUtil.getBTreeIndexKeyTypes(index, recordType, metaRecordType)); break; case RTREE: - dest.addAll(KeyFieldTypeUtils.getRTreeIndexKeyTypes(index, recordType, metaRecordType)); + dest.addAll(KeyFieldTypeUtil.getRTreeIndexKeyTypes(index, recordType, metaRecordType)); break; case SINGLE_PARTITION_WORD_INVIX: case SINGLE_PARTITION_NGRAM_INVIX: @@ -303,7 +302,7 @@ public class AccessMethodUtils { throw new AlgebricksException(e); } } else { - dest.addAll(KeyFieldTypeUtils.getPartitoningKeyTypes(dataset, recordType, metaRecordType)); + dest.addAll(KeyFieldTypeUtil.getPartitoningKeyTypes(dataset, recordType, metaRecordType)); } } @@ -315,9 +314,9 @@ public class AccessMethodUtils { numPrimaryKeys = IndexingConstants .getRIDSize(((ExternalDatasetDetails) dataset.getDatasetDetails()).getProperties()); } else { - numPrimaryKeys = DatasetUtils.getPartitioningKeys(dataset).size(); + numPrimaryKeys = DatasetUtil.getPartitioningKeys(dataset).size(); } - int numSecondaryKeys = KeyFieldTypeUtils.getNumSecondaryKeys(index, recordType, metaRecordType); + int numSecondaryKeys = KeyFieldTypeUtil.getNumSecondaryKeys(index, recordType, metaRecordType); int numVars = (primaryKeysOnly) ? numPrimaryKeys : numPrimaryKeys + numSecondaryKeys; for (int i = 0; i < numVars; i++) { dest.add(context.newVar()); @@ -331,9 +330,9 @@ public class AccessMethodUtils { numPrimaryKeys = IndexingConstants .getRIDSize(((ExternalDatasetDetails) dataset.getDatasetDetails()).getProperties()); } else { - numPrimaryKeys = DatasetUtils.getPartitioningKeys(dataset).size(); + numPrimaryKeys = DatasetUtil.getPartitioningKeys(dataset).size(); } - List<LogicalVariable> primaryKeyVars = new ArrayList<LogicalVariable>(); + List<LogicalVariable> primaryKeyVars = new ArrayList<>(); List<LogicalVariable> sourceVars = null; sourceVars = ((AbstractUnnestMapOperator) unnestMapOp).getVariables(); @@ -349,8 +348,8 @@ public class AccessMethodUtils { public static List<LogicalVariable> getPrimaryKeyVarsFromPrimaryUnnestMap(Dataset dataset, ILogicalOperator unnestMapOp) { - int numPrimaryKeys = DatasetUtils.getPartitioningKeys(dataset).size(); - List<LogicalVariable> primaryKeyVars = new ArrayList<LogicalVariable>(); + int numPrimaryKeys = DatasetUtil.getPartitioningKeys(dataset).size(); + List<LogicalVariable> primaryKeyVars = new ArrayList<>(); List<LogicalVariable> sourceVars = null; // For a left outer join case, LEFT_OUTER_UNNEST_MAP operator is placed @@ -467,11 +466,11 @@ public class AccessMethodUtils { IOptimizationContext context, boolean outputPrimaryKeysOnly, boolean retainInput, boolean retainNull) throws AlgebricksException { // The job gen parameters are transferred to the actual job gen via the UnnestMapOperator's function arguments. - ArrayList<Mutable<ILogicalExpression>> secondaryIndexFuncArgs = new ArrayList<Mutable<ILogicalExpression>>(); + ArrayList<Mutable<ILogicalExpression>> secondaryIndexFuncArgs = new ArrayList<>(); jobGenParams.writeToFuncArgs(secondaryIndexFuncArgs); // Variables and types coming out of the secondary-index search. - List<LogicalVariable> secondaryIndexUnnestVars = new ArrayList<LogicalVariable>(); - List<Object> secondaryIndexOutputTypes = new ArrayList<Object>(); + List<LogicalVariable> secondaryIndexUnnestVars = new ArrayList<>(); + List<Object> secondaryIndexOutputTypes = new ArrayList<>(); // Append output variables/types generated by the secondary-index search (not forwarded from input). appendSecondaryIndexOutputVars(dataset, recordType, metaRecordType, index, outputPrimaryKeysOnly, context, secondaryIndexUnnestVars); @@ -492,7 +491,7 @@ public class AccessMethodUtils { LeftOuterUnnestMapOperator secondaryIndexLeftOuterUnnestOp = new LeftOuterUnnestMapOperator( secondaryIndexUnnestVars, new MutableObject<ILogicalExpression>(secondaryIndexSearchFunc), secondaryIndexOutputTypes, true); - secondaryIndexLeftOuterUnnestOp.getInputs().add(new MutableObject<ILogicalOperator>(inputOp)); + secondaryIndexLeftOuterUnnestOp.getInputs().add(new MutableObject<>(inputOp)); context.computeAndSetTypeEnvironmentForOperator(secondaryIndexLeftOuterUnnestOp); secondaryIndexLeftOuterUnnestOp.setExecutionMode(ExecutionMode.PARTITIONED); return secondaryIndexLeftOuterUnnestOp; @@ -505,7 +504,7 @@ public class AccessMethodUtils { UnnestMapOperator secondaryIndexUnnestOp = new UnnestMapOperator(secondaryIndexUnnestVars, new MutableObject<ILogicalExpression>(secondaryIndexSearchFunc), secondaryIndexOutputTypes, retainInput); - secondaryIndexUnnestOp.getInputs().add(new MutableObject<ILogicalOperator>(inputOp)); + secondaryIndexUnnestOp.getInputs().add(new MutableObject<>(inputOp)); context.computeAndSetTypeEnvironmentForOperator(secondaryIndexUnnestOp); secondaryIndexUnnestOp.setExecutionMode(ExecutionMode.PARTITIONED); return secondaryIndexUnnestOp; @@ -523,18 +522,18 @@ public class AccessMethodUtils { if (sortPrimaryKeys) { order = new OrderOperator(); for (LogicalVariable pkVar : primaryKeyVars) { - Mutable<ILogicalExpression> vRef = new MutableObject<ILogicalExpression>( + Mutable<ILogicalExpression> vRef = new MutableObject<>( new VariableReferenceExpression(pkVar)); order.getOrderExpressions() - .add(new Pair<IOrder, Mutable<ILogicalExpression>>(OrderOperator.ASC_ORDER, vRef)); + .add(new Pair<>(OrderOperator.ASC_ORDER, vRef)); } // The secondary-index search feeds into the sort. - order.getInputs().add(new MutableObject<ILogicalOperator>(inputOp)); + order.getInputs().add(new MutableObject<>(inputOp)); order.setExecutionMode(ExecutionMode.LOCAL); context.computeAndSetTypeEnvironmentForOperator(order); } // The job gen parameters are transferred to the actual job gen via the UnnestMapOperator's function arguments. - List<Mutable<ILogicalExpression>> primaryIndexFuncArgs = new ArrayList<Mutable<ILogicalExpression>>(); + List<Mutable<ILogicalExpression>> primaryIndexFuncArgs = new ArrayList<>(); BTreeJobGenParams jobGenParams = new BTreeJobGenParams(dataset.getDatasetName(), IndexType.BTREE, dataset.getDataverseName(), dataset.getDatasetName(), retainInput, requiresBroadcast); // Set low/high inclusive to true for a point lookup. @@ -545,8 +544,8 @@ public class AccessMethodUtils { jobGenParams.setIsEqCondition(true); jobGenParams.writeToFuncArgs(primaryIndexFuncArgs); // Variables and types coming out of the primary-index search. - List<LogicalVariable> primaryIndexUnnestVars = new ArrayList<LogicalVariable>(); - List<Object> primaryIndexOutputTypes = new ArrayList<Object>(); + List<LogicalVariable> primaryIndexUnnestVars = new ArrayList<>(); + List<Object> primaryIndexOutputTypes = new ArrayList<>(); // Append output variables/types generated by the primary-index search (not forwarded from input). primaryIndexUnnestVars.addAll(dataSourceOp.getVariables()); appendPrimaryIndexTypes(dataset, recordType, metaRecordType, primaryIndexOutputTypes); @@ -575,7 +574,7 @@ public class AccessMethodUtils { if (sortPrimaryKeys) { primaryIndexUnnestOp.getInputs().add(new MutableObject<ILogicalOperator>(order)); } else { - primaryIndexUnnestOp.getInputs().add(new MutableObject<ILogicalOperator>(inputOp)); + primaryIndexUnnestOp.getInputs().add(new MutableObject<>(inputOp)); } context.computeAndSetTypeEnvironmentForOperator(primaryIndexUnnestOp); primaryIndexUnnestOp.setExecutionMode(ExecutionMode.PARTITIONED); @@ -653,41 +652,41 @@ public class AccessMethodUtils { } private static void writeVarList(List<LogicalVariable> varList, List<Mutable<ILogicalExpression>> funcArgs) { - Mutable<ILogicalExpression> numKeysRef = new MutableObject<ILogicalExpression>( + Mutable<ILogicalExpression> numKeysRef = new MutableObject<>( new ConstantExpression(new AsterixConstantValue(new AInt32(varList.size())))); funcArgs.add(numKeysRef); for (LogicalVariable keyVar : varList) { - Mutable<ILogicalExpression> keyVarRef = new MutableObject<ILogicalExpression>( + Mutable<ILogicalExpression> keyVarRef = new MutableObject<>( new VariableReferenceExpression(keyVar)); funcArgs.add(keyVarRef); } } private static void addStringArg(String argument, List<Mutable<ILogicalExpression>> funcArgs) { - Mutable<ILogicalExpression> stringRef = new MutableObject<ILogicalExpression>( + Mutable<ILogicalExpression> stringRef = new MutableObject<>( new ConstantExpression(new AsterixConstantValue(new AString(argument)))); funcArgs.add(stringRef); } public static UnnestMapOperator createExternalDataLookupUnnestMap(AbstractDataSourceOperator dataSourceOp, Dataset dataset, ARecordType recordType, ILogicalOperator inputOp, IOptimizationContext context, - Index secondaryIndex, boolean retainInput, boolean retainNull) throws AlgebricksException { + boolean retainInput, boolean retainNull) throws AlgebricksException { List<LogicalVariable> primaryKeyVars = AccessMethodUtils.getPrimaryKeyVarsFromSecondaryUnnestMap(dataset, inputOp); // add a sort on the RID fields before fetching external data. OrderOperator order = new OrderOperator(); for (LogicalVariable pkVar : primaryKeyVars) { - Mutable<ILogicalExpression> vRef = new MutableObject<ILogicalExpression>( + Mutable<ILogicalExpression> vRef = new MutableObject<>( new VariableReferenceExpression(pkVar)); order.getOrderExpressions() - .add(new Pair<IOrder, Mutable<ILogicalExpression>>(OrderOperator.ASC_ORDER, vRef)); + .add(new Pair<>(OrderOperator.ASC_ORDER, vRef)); } // The secondary-index search feeds into the sort. - order.getInputs().add(new MutableObject<ILogicalOperator>(inputOp)); + order.getInputs().add(new MutableObject<>(inputOp)); order.setExecutionMode(ExecutionMode.LOCAL); context.computeAndSetTypeEnvironmentForOperator(order); - List<Mutable<ILogicalExpression>> externalLookupArgs = new ArrayList<Mutable<ILogicalExpression>>(); + List<Mutable<ILogicalExpression>> externalLookupArgs = new ArrayList<>(); //Add dataverse to the arguments AccessMethodUtils.addStringArg(dataset.getDataverseName(), externalLookupArgs); //Add dataset to the arguments @@ -696,8 +695,8 @@ public class AccessMethodUtils { AccessMethodUtils.writeVarList(primaryKeyVars, externalLookupArgs); // Variables and types coming out of the external access. - List<LogicalVariable> externalUnnestVars = new ArrayList<LogicalVariable>(); - List<Object> outputTypes = new ArrayList<Object>(); + List<LogicalVariable> externalUnnestVars = new ArrayList<>(); + List<Object> outputTypes = new ArrayList<>(); // Append output variables/types generated by the data scan (not forwarded from input). externalUnnestVars.addAll(dataSourceOp.getVariables()); appendExternalRecTypes(dataset, recordType, outputTypes); @@ -715,7 +714,7 @@ public class AccessMethodUtils { //set the physical operator DataSourceId dataSourceId = new DataSourceId(dataset.getDataverseName(), dataset.getDatasetName()); - unnestOp.setPhysicalOperator(new ExternalDataLookupPOperator(dataSourceId, dataset, recordType, secondaryIndex, + unnestOp.setPhysicalOperator(new ExternalDataLookupPOperator(dataSourceId, dataset, recordType, primaryKeyVars, false, retainInput, retainNull)); return unnestOp; } @@ -723,7 +722,7 @@ public class AccessMethodUtils { //If the expression is constant at runtime, return the type public static IAType constantRuntimeResultType(ILogicalExpression expr, IOptimizationContext context, IVariableTypeEnvironment typeEnvironment) throws AlgebricksException { - Set<LogicalVariable> usedVariables = new HashSet<LogicalVariable>(); + Set<LogicalVariable> usedVariables = new HashSet<>(); expr.getUsedVariables(usedVariables); if (usedVariables.size() > 0) { return null; http://git-wip-us.apache.org/repos/asf/asterixdb/blob/ef9be0f9/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 3384ad7..79ef433 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 @@ -148,9 +148,9 @@ public class BTreeAccessMethod implements IAccessMethod { select.getInputs().clear(); if (op != null) { subTree.getDataSourceRef().setValue(primaryIndexUnnestOp); - select.getInputs().add(new MutableObject<ILogicalOperator>(op)); + select.getInputs().add(new MutableObject<>(op)); } else { - select.getInputs().add(new MutableObject<ILogicalOperator>(primaryIndexUnnestOp)); + select.getInputs().add(new MutableObject<>(primaryIndexUnnestOp)); } } else { ((AbstractLogicalOperator) primaryIndexUnnestOp).setExecutionMode(ExecutionMode.PARTITIONED); @@ -465,10 +465,10 @@ public class BTreeAccessMethod implements IAccessMethod { // Here we generate vars and funcs for assigning the secondary-index keys to be fed into the secondary-index // search. // List of variables for the assign. - ArrayList<LogicalVariable> keyVarList = new ArrayList<LogicalVariable>(); + ArrayList<LogicalVariable> keyVarList = new ArrayList<>(); // List of variables and expressions for the assign. - ArrayList<LogicalVariable> assignKeyVarList = new ArrayList<LogicalVariable>(); - ArrayList<Mutable<ILogicalExpression>> assignKeyExprList = new ArrayList<Mutable<ILogicalExpression>>(); + ArrayList<LogicalVariable> assignKeyVarList = new ArrayList<>(); + ArrayList<Mutable<ILogicalExpression>> assignKeyExprList = new ArrayList<>(); int numLowKeys = createKeyVarsAndExprs(numSecondaryKeys, lowKeyLimits, lowKeyExprs, assignKeyVarList, assignKeyExprList, keyVarList, context, constantAtRuntimeExpressions, constAtRuntimeExprVars); int numHighKeys = createKeyVarsAndExprs(numSecondaryKeys, highKeyLimits, highKeyExprs, assignKeyVarList, @@ -487,7 +487,7 @@ public class BTreeAccessMethod implements IAccessMethod { // Assign operator that sets the constant secondary-index search-key fields if necessary. AssignOperator assignConstantSearchKeys = new AssignOperator(assignKeyVarList, assignKeyExprList); // Input to this assign is the EmptyTupleSource (which the dataSourceScan also must have had as input). - assignConstantSearchKeys.getInputs().add(new MutableObject<ILogicalOperator>( + assignConstantSearchKeys.getInputs().add(new MutableObject<>( OperatorManipulationUtil.deepCopy(dataSourceOp.getInputs().get(0).getValue()))); assignConstantSearchKeys.setExecutionMode(dataSourceOp.getExecutionMode()); inputOp = assignConstantSearchKeys; @@ -518,7 +518,7 @@ public class BTreeAccessMethod implements IAccessMethod { if (dataset.getDatasetType() == DatasetType.EXTERNAL) { // External dataset UnnestMapOperator externalDataAccessOp = AccessMethodUtils.createExternalDataLookupUnnestMap(dataSourceOp, - dataset, recordType, secondaryIndexUnnestOp, context, chosenIndex, retainInput, retainNull); + dataset, recordType, secondaryIndexUnnestOp, context, retainInput, retainNull); indexSubTree.getDataSourceRef().setValue(externalDataAccessOp); return externalDataAccessOp; } else if (!isPrimaryIndex) { @@ -530,7 +530,7 @@ public class BTreeAccessMethod implements IAccessMethod { EquivalenceClassUtils.addEquivalenceClassesForPrimaryIndexAccess(primaryIndexUnnestOp, dataSourceOp.getVariables(), recordType, metaRecordType, dataset, context); } else { - List<Object> primaryIndexOutputTypes = new ArrayList<Object>(); + List<Object> primaryIndexOutputTypes = new ArrayList<>(); AccessMethodUtils.appendPrimaryIndexTypes(dataset, recordType, metaRecordType, primaryIndexOutputTypes); List<LogicalVariable> scanVariables = dataSourceOp.getVariables(); @@ -540,7 +540,7 @@ public class BTreeAccessMethod implements IAccessMethod { // operator will be removed. // If not, we create a new condition based on remaining ones. if (!primaryIndexPostProccessingIsNeeded) { - List<Mutable<ILogicalExpression>> remainingFuncExprs = new ArrayList<Mutable<ILogicalExpression>>(); + List<Mutable<ILogicalExpression>> remainingFuncExprs = new ArrayList<>(); getNewConditionExprs(conditionRef, replacedFuncExprs, remainingFuncExprs); // Generate new condition. if (!remainingFuncExprs.isEmpty()) { @@ -562,7 +562,7 @@ public class BTreeAccessMethod implements IAccessMethod { if (conditionRef.getValue() != null) { // The job gen parameters are transferred to the actual job gen // via the UnnestMapOperator's function arguments. - List<Mutable<ILogicalExpression>> primaryIndexFuncArgs = new ArrayList<Mutable<ILogicalExpression>>(); + List<Mutable<ILogicalExpression>> primaryIndexFuncArgs = new ArrayList<>(); jobGenParams.writeToFuncArgs(primaryIndexFuncArgs); // An index search is expressed as an unnest-map over an // index-search function. @@ -591,7 +591,7 @@ public class BTreeAccessMethod implements IAccessMethod { } } - primaryIndexUnnestOp.getInputs().add(new MutableObject<ILogicalOperator>(inputOp)); + primaryIndexUnnestOp.getInputs().add(new MutableObject<>(inputOp)); // Adds equivalence classes --- one equivalent class between a primary key // variable and a record field-access expression. @@ -615,12 +615,12 @@ public class BTreeAccessMethod implements IAccessMethod { LogicalVariable keyVar = null; if (searchKeyExpr.getExpressionTag() == LogicalExpressionTag.CONSTANT) { keyVar = context.newVar(); - assignKeyExprList.add(new MutableObject<ILogicalExpression>(searchKeyExpr)); + assignKeyExprList.add(new MutableObject<>(searchKeyExpr)); assignKeyVarList.add(keyVar); } else { keyVar = ((VariableReferenceExpression) searchKeyExpr).getVariableReference(); if (constExpression != null) { - assignKeyExprList.add(new MutableObject<ILogicalExpression>(constExpression)); + assignKeyExprList.add(new MutableObject<>(constExpression)); assignKeyVarList.add(constExprVars[i]); } } http://git-wip-us.apache.org/repos/asf/asterixdb/blob/ef9be0f9/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/IntroduceLSMComponentFilterRule.java ---------------------------------------------------------------------- diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/IntroduceLSMComponentFilterRule.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/IntroduceLSMComponentFilterRule.java index 57af64f..5f9b4ab 100644 --- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/IntroduceLSMComponentFilterRule.java +++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/IntroduceLSMComponentFilterRule.java @@ -29,13 +29,13 @@ import org.apache.asterix.metadata.declared.DatasetDataSource; import org.apache.asterix.metadata.declared.MetadataProvider; import org.apache.asterix.metadata.entities.Dataset; import org.apache.asterix.metadata.entities.Index; -import org.apache.asterix.metadata.utils.DatasetUtils; -import org.apache.asterix.metadata.utils.KeyFieldTypeUtils; +import org.apache.asterix.metadata.utils.DatasetUtil; +import org.apache.asterix.metadata.utils.KeyFieldTypeUtil; import org.apache.asterix.om.functions.BuiltinFunctions; import org.apache.asterix.om.types.ARecordType; import org.apache.asterix.om.types.ATypeTag; import org.apache.asterix.om.types.IAType; -import org.apache.asterix.om.util.ConstantExpressionUtil; +import org.apache.asterix.om.utils.ConstantExpressionUtil; import org.apache.commons.lang3.mutable.Mutable; import org.apache.commons.lang3.mutable.MutableObject; import org.apache.hyracks.algebricks.common.exceptions.AlgebricksException; @@ -91,7 +91,7 @@ public class IntroduceLSMComponentFilterRule implements IAlgebraicRewriteRule { List<String> filterFieldName = null; ARecordType recType = null; if (dataset != null && dataset.getDatasetType() == DatasetType.INTERNAL) { - filterFieldName = DatasetUtils.getFilterField(dataset); + filterFieldName = DatasetUtil.getFilterField(dataset); IAType itemType = ((MetadataProvider) context.getMetadataProvider()) .findType(dataset.getItemTypeDataverseName(), dataset.getItemTypeName()); if (itemType.getTypeTag() == ATypeTag.RECORD) { @@ -335,7 +335,7 @@ public class IntroduceLSMComponentFilterRule implements IAlgebraicRewriteRule { continue; } // The variable value is one of the partitioning fields. - List<String> fieldName = DatasetUtils.getPartitioningKeys(dataset).get(varIndex); + List<String> fieldName = DatasetUtil.getPartitioningKeys(dataset).get(varIndex); if (fieldName == null) { return false; } @@ -375,10 +375,10 @@ public class IntroduceLSMComponentFilterRule implements IAlgebraicRewriteRule { IAType metaItemType = ((MetadataProvider) context.getMetadataProvider()) .findType(dataset.getMetaItemTypeDataverseName(), dataset.getMetaItemTypeName()); ARecordType metaRecType = (ARecordType) metaItemType; - int numSecondaryKeys = KeyFieldTypeUtils.getNumSecondaryKeys(index, recType, metaRecType); + int numSecondaryKeys = KeyFieldTypeUtil.getNumSecondaryKeys(index, recType, metaRecType); List<String> fieldName; if (varIndex >= numSecondaryKeys) { - fieldName = DatasetUtils.getPartitioningKeys(dataset).get(varIndex - numSecondaryKeys); + fieldName = DatasetUtil.getPartitioningKeys(dataset).get(varIndex - numSecondaryKeys); } else { fieldName = index.getKeyFieldNames().get(varIndex); } http://git-wip-us.apache.org/repos/asf/asterixdb/blob/ef9be0f9/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/InvertedIndexAccessMethod.java ---------------------------------------------------------------------- diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/InvertedIndexAccessMethod.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/InvertedIndexAccessMethod.java index 30866cf..7328f97 100644 --- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/InvertedIndexAccessMethod.java +++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/InvertedIndexAccessMethod.java @@ -47,7 +47,7 @@ import org.apache.asterix.om.types.ATypeTag; import org.apache.asterix.om.types.AUnionType; import org.apache.asterix.om.types.IAType; import org.apache.asterix.om.types.hierachy.ATypeHierarchy; -import org.apache.asterix.om.util.ConstantExpressionUtil; +import org.apache.asterix.om.utils.ConstantExpressionUtil; import org.apache.asterix.runtime.evaluators.functions.FullTextContainsDescriptor; import org.apache.commons.lang3.mutable.Mutable; import org.apache.commons.lang3.mutable.MutableObject; http://git-wip-us.apache.org/repos/asf/asterixdb/blob/ef9be0f9/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/InvertedIndexJobGenParams.java ---------------------------------------------------------------------- diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/InvertedIndexJobGenParams.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/InvertedIndexJobGenParams.java index 05122cd..1ddd1b5 100644 --- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/InvertedIndexJobGenParams.java +++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/InvertedIndexJobGenParams.java @@ -118,7 +118,7 @@ public class InvertedIndexJobGenParams extends AccessMethodJobGenParams { // Read full-text search information. isFullTextSearchQuery = AccessMethodUtils.getBooleanConstant(funcArgs.get(index + IS_FULLTEXT_SEARCH_INDEX)); // Read key var list. - keyVarList = new ArrayList<LogicalVariable>(); + keyVarList = new ArrayList<>(); readVarList(funcArgs, index + KEY_VAR_INDEX, keyVarList); // TODO: We could possibly simplify things if we did read the non-key var list here. // We don't need to read the non-key var list. http://git-wip-us.apache.org/repos/asf/asterixdb/blob/ef9be0f9/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/OptimizableOperatorSubTree.java ---------------------------------------------------------------------- diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/OptimizableOperatorSubTree.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/OptimizableOperatorSubTree.java index a96bc56..3d7e959 100644 --- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/OptimizableOperatorSubTree.java +++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/OptimizableOperatorSubTree.java @@ -24,7 +24,7 @@ import java.util.List; import org.apache.asterix.metadata.declared.DataSource; import org.apache.asterix.metadata.declared.MetadataProvider; import org.apache.asterix.metadata.entities.Dataset; -import org.apache.asterix.metadata.utils.DatasetUtils; +import org.apache.asterix.metadata.utils.DatasetUtil; import org.apache.asterix.om.functions.BuiltinFunctions; import org.apache.asterix.om.types.ARecordType; import org.apache.asterix.om.types.ATypeTag; @@ -371,7 +371,7 @@ public class OptimizableOperatorSubTree { switch (getDataSourceType()) { case DATASOURCE_SCAN: DataSourceScanOperator dataSourceScan = (DataSourceScanOperator) getDataSourceRef().getValue(); - int numPrimaryKeys = DatasetUtils.getPartitioningKeys(getDataset()).size(); + int numPrimaryKeys = DatasetUtil.getPartitioningKeys(getDataset()).size(); for (int i = 0; i < numPrimaryKeys; i++) { target.add(dataSourceScan.getVariables().get(i)); } http://git-wip-us.apache.org/repos/asf/asterixdb/blob/ef9be0f9/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/RTreeAccessMethod.java ---------------------------------------------------------------------- diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/RTreeAccessMethod.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/RTreeAccessMethod.java index dc6e91d..44a53e1 100644 --- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/RTreeAccessMethod.java +++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/am/RTreeAccessMethod.java @@ -32,7 +32,7 @@ import org.apache.asterix.om.constants.AsterixConstantValue; import org.apache.asterix.om.functions.BuiltinFunctions; import org.apache.asterix.om.types.ARecordType; import org.apache.asterix.om.types.IAType; -import org.apache.asterix.om.util.NonTaggedFormatUtil; +import org.apache.asterix.om.utils.NonTaggedFormatUtil; import org.apache.commons.lang3.mutable.Mutable; import org.apache.commons.lang3.mutable.MutableObject; import org.apache.hyracks.algebricks.common.exceptions.AlgebricksException; @@ -216,7 +216,7 @@ public class RTreeAccessMethod implements IAccessMethod { AbstractFunctionCallExpression createMBR = new ScalarFunctionCallExpression( FunctionUtil.getFunctionInfo(BuiltinFunctions.CREATE_MBR)); // Spatial object is the constant from the func expr we are optimizing. - createMBR.getArguments().add(new MutableObject<ILogicalExpression>(searchKeyExpr)); + createMBR.getArguments().add(new MutableObject<>(searchKeyExpr)); // The number of dimensions. createMBR.getArguments().add(new MutableObject<ILogicalExpression>( new ConstantExpression(new AsterixConstantValue(new AInt32(numDimensions))))); @@ -235,7 +235,7 @@ public class RTreeAccessMethod implements IAccessMethod { if (probeSubTree == null) { // We are optimizing a selection query. // Input to this assign is the EmptyTupleSource (which the dataSourceScan also must have had as input). - assignSearchKeys.getInputs().add(new MutableObject<ILogicalOperator>( + assignSearchKeys.getInputs().add(new MutableObject<>( OperatorManipulationUtil.deepCopy(dataSourceOp.getInputs().get(0).getValue()))); assignSearchKeys.setExecutionMode(dataSourceOp.getExecutionMode()); } else { @@ -249,7 +249,7 @@ public class RTreeAccessMethod implements IAccessMethod { // Generate the rest of the upstream plan which feeds the search results into the primary index. return dataset.getDatasetType() == DatasetType.EXTERNAL ? AccessMethodUtils.createExternalDataLookupUnnestMap(dataSourceOp, dataset, recordType, - secondaryIndexUnnestOp, context, chosenIndex, retainInput, retainNull) + secondaryIndexUnnestOp, context, retainInput, retainNull) : AccessMethodUtils.createPrimaryIndexUnnestMap(dataSourceOp, dataset, recordType, metaRecordType, secondaryIndexUnnestOp, context, true, retainInput, false, false); } http://git-wip-us.apache.org/repos/asf/asterixdb/blob/ef9be0f9/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/typecast/StaticTypeCastUtil.java ---------------------------------------------------------------------- diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/typecast/StaticTypeCastUtil.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/typecast/StaticTypeCastUtil.java index adee58a..2a569b9 100644 --- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/typecast/StaticTypeCastUtil.java +++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/typecast/StaticTypeCastUtil.java @@ -38,7 +38,7 @@ import org.apache.asterix.om.types.AUnionType; import org.apache.asterix.om.types.AbstractCollectionType; import org.apache.asterix.om.types.BuiltinType; import org.apache.asterix.om.types.IAType; -import org.apache.asterix.om.util.NonTaggedFormatUtil; +import org.apache.asterix.om.utils.NonTaggedFormatUtil; import org.apache.commons.lang3.mutable.Mutable; import org.apache.commons.lang3.mutable.MutableObject; import org.apache.hyracks.algebricks.common.exceptions.AlgebricksException; http://git-wip-us.apache.org/repos/asf/asterixdb/blob/ef9be0f9/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/translator/AbstractLangTranslator.java ---------------------------------------------------------------------- diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/translator/AbstractLangTranslator.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/translator/AbstractLangTranslator.java index 37be55b..634824c 100644 --- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/translator/AbstractLangTranslator.java +++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/translator/AbstractLangTranslator.java @@ -35,8 +35,8 @@ import org.apache.asterix.lang.common.statement.NodeGroupDropStatement; import org.apache.asterix.metadata.dataset.hints.DatasetHints; import org.apache.asterix.metadata.entities.Dataverse; import org.apache.asterix.metadata.utils.MetadataConstants; -import org.apache.asterix.runtime.util.AppContextInfo; -import org.apache.asterix.runtime.util.ClusterStateManager; +import org.apache.asterix.runtime.utils.AppContextInfo; +import org.apache.asterix.runtime.utils.ClusterStateManager; import org.apache.hyracks.algebricks.common.utils.Pair; /** http://git-wip-us.apache.org/repos/asf/asterixdb/blob/ef9be0f9/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/translator/AqlPlusExpressionToPlanTranslator.java ---------------------------------------------------------------------- diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/translator/AqlPlusExpressionToPlanTranslator.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/translator/AqlPlusExpressionToPlanTranslator.java index 09d8055..5eb5a5f 100644 --- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/translator/AqlPlusExpressionToPlanTranslator.java +++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/translator/AqlPlusExpressionToPlanTranslator.java @@ -106,7 +106,7 @@ import org.apache.asterix.metadata.declared.FileSplitDataSink; import org.apache.asterix.metadata.declared.FileSplitSinkId; import org.apache.asterix.metadata.declared.MetadataProvider; import org.apache.asterix.metadata.entities.Dataset; -import org.apache.asterix.metadata.utils.DatasetUtils; +import org.apache.asterix.metadata.utils.DatasetUtil; import org.apache.asterix.om.base.AString; import org.apache.asterix.om.constants.AsterixConstantValue; import org.apache.asterix.om.functions.BuiltinFunctions; @@ -271,7 +271,7 @@ public class AqlPlusExpressionToPlanTranslator extends AbstractLangTranslator } ARecordType itemType = (ARecordType) metadata.findType(dataset.getItemTypeDataverseName(), dataset.getItemTypeName()); - List<List<String>> partitioningKeys = DatasetUtils.getPartitioningKeys(dataset); + List<List<String>> partitioningKeys = DatasetUtil.getPartitioningKeys(dataset); ArrayList<LogicalVariable> vars = new ArrayList<LogicalVariable>(); ArrayList<Mutable<ILogicalExpression>> exprs = new ArrayList<Mutable<ILogicalExpression>>(); List<Mutable<ILogicalExpression>> varRefsForLoading = new ArrayList<Mutable<ILogicalExpression>>(); http://git-wip-us.apache.org/repos/asf/asterixdb/blob/ef9be0f9/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/translator/CompiledStatements.java ---------------------------------------------------------------------- diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/translator/CompiledStatements.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/translator/CompiledStatements.java index c21b5db..403c26b 100644 --- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/translator/CompiledStatements.java +++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/translator/CompiledStatements.java @@ -18,16 +18,15 @@ */ package org.apache.asterix.translator; -import java.util.List; import java.util.Map; -import org.apache.asterix.common.config.DatasetConfig.IndexType; import org.apache.asterix.external.feed.management.FeedConnectionRequest; import org.apache.asterix.lang.common.base.Expression; import org.apache.asterix.lang.common.base.Statement; import org.apache.asterix.lang.common.expression.VariableExpr; import org.apache.asterix.lang.common.statement.Query; -import org.apache.asterix.om.types.IAType; +import org.apache.asterix.metadata.entities.Dataset; +import org.apache.asterix.metadata.entities.Index; import org.apache.hyracks.algebricks.common.exceptions.AlgebricksException; /** @@ -182,62 +181,30 @@ public class CompiledStatements { } public static class CompiledCreateIndexStatement implements ICompiledDmlStatement { - private final String indexName; - private final String dataverseName; - private final String datasetName; - private final List<List<String>> keyFields; - private final List<IAType> keyTypes; - private final boolean isEnforced; - private final IndexType indexType; - - // Specific to NGram index. - private final int gramLength; + private final Dataset dataset; + private final Index index; - public CompiledCreateIndexStatement(String indexName, String dataverseName, String datasetName, - List<List<String>> keyFields, List<IAType> keyTypes, boolean isEnforced, int gramLength, - IndexType indexType) { - this.indexName = indexName; - this.dataverseName = dataverseName; - this.datasetName = datasetName; - this.keyFields = keyFields; - this.keyTypes = keyTypes; - this.gramLength = gramLength; - this.isEnforced = isEnforced; - this.indexType = indexType; + public CompiledCreateIndexStatement(Dataset dataset, Index index) { + this.dataset = dataset; + this.index = index; } @Override public String getDatasetName() { - return datasetName; + return index.getDatasetName(); } @Override public String getDataverseName() { - return dataverseName; - } - - public String getIndexName() { - return indexName; - } - - public List<List<String>> getKeyFields() { - return keyFields; + return index.getDataverseName(); } - public List<IAType> getKeyFieldTypes() { - return keyTypes; + public Index getIndex() { + return index; } - public IndexType getIndexType() { - return indexType; - } - - public int getGramLength() { - return gramLength; - } - - public boolean isEnforced() { - return isEnforced; + public Dataset getDataset() { + return dataset; } @Override @@ -538,49 +505,21 @@ public class CompiledStatements { } public static class CompiledIndexCompactStatement extends CompiledCompactStatement { - private final String indexName; - private final List<List<String>> keyFields; - private final List<IAType> keyTypes; - private final IndexType indexType; - private final boolean isEnforced; - - // Specific to NGram index. - private final int gramLength; - - public CompiledIndexCompactStatement(String dataverseName, String datasetName, String indexName, - List<List<String>> keyFields, List<IAType> keyTypes, boolean isEnforced, int gramLength, - IndexType indexType) { - super(dataverseName, datasetName); - this.indexName = indexName; - this.keyFields = keyFields; - this.keyTypes = keyTypes; - this.gramLength = gramLength; - this.indexType = indexType; - this.isEnforced = isEnforced; - } - - public String getIndexName() { - return indexName; - } - - public List<List<String>> getKeyFields() { - return keyFields; - } - - public List<IAType> getKeyTypes() { - return keyTypes; - } + private Dataset dataset; + private Index index; - public IndexType getIndexType() { - return indexType; + public CompiledIndexCompactStatement(Dataset dataset, Index index) { + super(dataset.getDataverseName(), dataset.getDatasetName()); + this.dataset = dataset; + this.index = index; } - public int getGramLength() { - return gramLength; + public Dataset getDataset() { + return dataset; } - public boolean isEnforced() { - return isEnforced; + public Index getIndex() { + return index; } } } http://git-wip-us.apache.org/repos/asf/asterixdb/blob/ef9be0f9/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/translator/IStatementExecutorFactory.java ---------------------------------------------------------------------- diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/translator/IStatementExecutorFactory.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/translator/IStatementExecutorFactory.java index 05fde09..cf54921 100644 --- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/translator/IStatementExecutorFactory.java +++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/translator/IStatementExecutorFactory.java @@ -20,6 +20,7 @@ package org.apache.asterix.translator; import java.util.List; +import org.apache.asterix.common.context.IStorageComponentProvider; import org.apache.asterix.compiler.provider.ILangCompilationProvider; import org.apache.asterix.lang.common.base.Statement; @@ -38,8 +39,11 @@ public interface IStatementExecutorFactory { * @param conf * request configuration * @param compilationProvider - * @return an implementation of {@code IStatementExecutor} that is used to execute the passed list of statements + * provides query language related components + * @param storageComponentProvider + * provides storage related components + * @return an implementation of {@code IStatementExecutor} thaxt is used to execute the passed list of statements */ IStatementExecutor create(List<Statement> statements, SessionConfig conf, - ILangCompilationProvider compilationProvider); + ILangCompilationProvider compilationProvider, IStorageComponentProvider storageComponentProvider); }
