public static IBinaryComparatorFactory[] variablesToAscBinaryComparatorFactories(List<LogicalVariable> varLogical, int start, int size, IVariableTypeEnvironment env, JobGenContext context) throws AlgebricksException { IBinaryComparatorFactory[] compFactories = new IBinaryComparatorFactory[size]; IBinaryComparatorFactoryProvider bcfProvider = context.getBinaryComparatorFactoryProvider(); for (int i = 0; i < size; i++) { Object type = env.getVarType(varLogical.get(start + i)); compFactories[i] = bcfProvider.getBinaryComparatorFactory(type, true); } return compFactories; }
public static IBinaryComparatorFactory[] variablesToAscBinaryComparatorFactories( Collection<LogicalVariable> varLogical, IVariableTypeEnvironment env, JobGenContext context) throws AlgebricksException { IBinaryComparatorFactory[] compFactories = new IBinaryComparatorFactory[varLogical.size()]; IBinaryComparatorFactoryProvider bcfProvider = context.getBinaryComparatorFactoryProvider(); int i = 0; for (LogicalVariable v : varLogical) { Object type = env.getVarType(v); compFactories[i++] = bcfProvider.getBinaryComparatorFactory(type, true); } return compFactories; }
public static IBinaryComparatorFactory[] variablesToBinaryComparatorFactories(Collection<OrderColumn> orderColumns, IVariableTypeEnvironment env, JobGenContext context) throws AlgebricksException { IBinaryComparatorFactory[] compFactories = new IBinaryComparatorFactory[orderColumns.size()]; IBinaryComparatorFactoryProvider bcfProvider = context.getBinaryComparatorFactoryProvider(); int i = 0; for (OrderColumn oc : orderColumns) { LogicalVariable v = oc.getColumn(); boolean ascending = oc.getOrder() == OrderOperator.IOrder.OrderKind.ASC; Object type = env.getVarType(v); compFactories[i++] = bcfProvider.getBinaryComparatorFactory(type, ascending); } return compFactories; }
public static IBinaryComparatorFactory[] computeFilterBinaryComparatorFactories(Dataset dataset, ARecordType itemType, IBinaryComparatorFactoryProvider comparatorFactoryProvider) throws AlgebricksException { if (dataset.getDatasetType() == DatasetType.EXTERNAL) { return null; } List<String> filterField = getFilterField(dataset); if (filterField == null) { return null; } IBinaryComparatorFactory[] bcfs = new IBinaryComparatorFactory[1]; IAType type = itemType.getSubFieldType(filterField); bcfs[0] = comparatorFactoryProvider.getBinaryComparatorFactory(type, true); return bcfs; }
private <T> Pair<IScalarEvaluatorFactory[], IBinaryComparatorFactory[]> createEvaluatorAndComparatorFactories( List<T> exprList, Function<T, Mutable<ILogicalExpression>> exprGetter, Function<T, OrderOperator.IOrder> orderGetter, IOperatorSchema[] inputSchemas, IVariableTypeEnvironment inputTypeEnv, IExpressionRuntimeProvider exprRuntimeProvider, IBinaryComparatorFactoryProvider binaryComparatorFactoryProvider, JobGenContext context) throws AlgebricksException { if (exprList.isEmpty()) { return new Pair<>(null, null); } int ln = exprList.size(); IScalarEvaluatorFactory[] evals = new IScalarEvaluatorFactory[ln]; IBinaryComparatorFactory[] comparators = new IBinaryComparatorFactory[ln]; for (int i = 0; i < ln; i++) { T exprObj = exprList.get(i); ILogicalExpression expr = exprGetter.apply(exprObj).getValue(); OrderOperator.IOrder order = orderGetter.apply(exprObj); evals[i] = exprRuntimeProvider.createEvaluatorFactory(expr, inputTypeEnv, inputSchemas, context); comparators[i] = binaryComparatorFactoryProvider.getBinaryComparatorFactory(inputTypeEnv.getType(expr), order.getKind() == OrderOperator.IOrder.OrderKind.ASC); } return new Pair<>(evals, comparators); }
/** * Gets the comparator factories for the primary key fields of this dataset. * * @param metadataProvider, * the metadata provider. * @return the comparator factories for the primary key fields of this dataset. * @throws AlgebricksException */ public IBinaryComparatorFactory[] getPrimaryComparatorFactories(MetadataProvider metadataProvider, ARecordType recordType, ARecordType metaType) throws AlgebricksException { IStorageComponentProvider storageComponentProvider = metadataProvider.getStorageComponentProvider(); IBinaryComparatorFactoryProvider cmpFactoryProvider = storageComponentProvider.getComparatorFactoryProvider(); List<List<String>> partitioningKeys = getPrimaryKeys(); int numPrimaryKeys = partitioningKeys.size(); IBinaryComparatorFactory[] cmpFactories = new IBinaryComparatorFactory[numPrimaryKeys]; List<Integer> indicators = null; if (hasMetaPart()) { indicators = ((InternalDatasetDetails) getDatasetDetails()).getKeySourceIndicator(); } for (int i = 0; i < numPrimaryKeys; i++) { IAType keyType = (indicators == null || indicators.get(i) == 0) ? recordType.getSubFieldType(partitioningKeys.get(i)) : metaType.getSubFieldType(partitioningKeys.get(i)); cmpFactories[i] = cmpFactoryProvider.getBinaryComparatorFactory(keyType, true); } return cmpFactories; }
new IBinaryComparatorFactory[numNestedSecondaryKeyFields]; for (int i = 0; i < numNestedSecondaryKeyFields; i++) { secondaryComparatorFactories[i] = cmpFactoryProvider.getBinaryComparatorFactory(nestedKeyType, true);
index.getKeyFieldNames().get(i), sourceType); IAType keyType = keyTypePair.first; secondaryCmpFactories[i] = cmpFactoryProvider.getBinaryComparatorFactory(keyType, true);
@Override public Pair<IConnectorDescriptor, TargetConstraint> createConnectorDescriptor(IConnectorDescriptorRegistry spec, ILogicalOperator op, IOperatorSchema opSchema, JobGenContext context) throws AlgebricksException { int n = partitioningFields.size(); int[] sortFields = new int[n]; IBinaryComparatorFactory[] comps = new IBinaryComparatorFactory[n]; IVariableTypeEnvironment env = context.getTypeEnvironment(op); int i = 0; for (OrderColumn oc : partitioningFields) { LogicalVariable var = oc.getColumn(); sortFields[i] = opSchema.findVariable(var); Object type = env.getVarType(var); IBinaryComparatorFactoryProvider bcfp = context.getBinaryComparatorFactoryProvider(); comps[i] = bcfp.getBinaryComparatorFactory(type, oc.getOrder() == OrderKind.ASC); i++; } FieldRangePartitionComputerFactory partitionerFactory; if (rangeMapIsComputedAtRunTime) { partitionerFactory = new DynamicFieldRangePartitionComputerFactory(sortFields, comps, rangeMapKeyInContext, op.getSourceLocation()); } else { partitionerFactory = new StaticFieldRangePartitionComputerFactory(sortFields, comps, rangeMap); } IConnectorDescriptor conn = new MToNPartitioningConnectorDescriptor(spec, partitionerFactory); return new Pair<>(conn, null); }
Object type = env.getVarType(var); IBinaryComparatorFactoryProvider bcfp = context.getBinaryComparatorFactoryProvider(); comparatorFactories[j] = bcfp.getBinaryComparatorFactory(type, oc.getOrder() == OrderKind.ASC); if (j == 0 && nkcfProvider != null && type != null) { nkcf = nkcfProvider.getNormalizedKeyComputerFactory(type, oc.getOrder() == OrderKind.ASC);
@Override public Pair<IConnectorDescriptor, TargetConstraint> createConnectorDescriptor(IConnectorDescriptorRegistry spec, ILogicalOperator op, IOperatorSchema opSchema, JobGenContext context) throws AlgebricksException { int n = partitioningFields.size(); int[] sortFields = new int[n]; IBinaryComparatorFactory[] comps = new IBinaryComparatorFactory[n]; INormalizedKeyComputerFactoryProvider nkcfProvider = context.getNormalizedKeyComputerFactoryProvider(); INormalizedKeyComputerFactory nkcf = null; IVariableTypeEnvironment env = context.getTypeEnvironment(op); int i = 0; for (OrderColumn oc : partitioningFields) { LogicalVariable var = oc.getColumn(); sortFields[i] = opSchema.findVariable(var); Object type = env.getVarType(var); OrderKind order = oc.getOrder(); if (i == 0 && nkcfProvider != null && type != null) { nkcf = nkcfProvider.getNormalizedKeyComputerFactory(type, order == OrderKind.ASC); } IBinaryComparatorFactoryProvider bcfp = context.getBinaryComparatorFactoryProvider(); comps[i] = bcfp.getBinaryComparatorFactory(type, oc.getOrder() == OrderKind.ASC); i++; } ITuplePartitionComputerFactory tpcf = new StaticFieldRangePartitionComputerFactory(sortFields, comps, rangeMap); IConnectorDescriptor conn = new MToNPartitioningMergingConnectorDescriptor(spec, tpcf, sortFields, comps, nkcf); return new Pair<IConnectorDescriptor, TargetConstraint>(conn, null); }
Object type = aggOpInputEnv.getVarType(v); if (orderColumns[i].getOrder() == OrderKind.ASC) { compFactories[i] = bcfProvider.getBinaryComparatorFactory(type, true); } else { compFactories[i] = bcfProvider.getBinaryComparatorFactory(type, false);
index.getKeyFieldNames().get(i), sourceType); IAType keyType = keyTypePair.first; secondaryCmpFactories[i] = cmpFactoryProvider.getBinaryComparatorFactory(keyType, true);
comps[i] = bcfp.getBinaryComparatorFactory(type, oc.getOrder() == OrderKind.ASC); i++;
for (LogicalVariable v : keysLeftBranch) { Object t = env.getVarType(v); comparatorFactories[i++] = bcfp.getBinaryComparatorFactory(t, true);
: metaType.getSubFieldType(primaryKeyFields.get(i)); primaryComparatorFactories[i] = storageComponentProvider.getComparatorFactoryProvider() .getBinaryComparatorFactory(keyType, true); primaryTypeTraits[i] = storageComponentProvider.getTypeTraitProvider().getTypeTrait(keyType); for (int i = 0; i < numNestedSecondaryKeyFields; i++) { secondaryComparatorFactories[i] = storageComponentProvider.getComparatorFactoryProvider() .getBinaryComparatorFactory(nestedKeyType, true); secondaryTypeTraits[i] = storageComponentProvider.getTypeTraitProvider().getTypeTrait(nestedKeyType); valueProviderFactories[i] = storageComponentProvider.getPrimitiveValueProviderFactory();
@Override public Pair<IConnectorDescriptor, TargetConstraint> createConnectorDescriptor(IConnectorDescriptorRegistry spec, ILogicalOperator op, IOperatorSchema opSchema, JobGenContext context) throws AlgebricksException { int n = sortColumns.length; int[] sortFields = new int[n]; IBinaryComparatorFactory[] comps = new IBinaryComparatorFactory[n]; IBinaryHashFunctionFactory[] hashFuns = new IBinaryHashFunctionFactory[n]; IVariableTypeEnvironment env = context.getTypeEnvironment(op); INormalizedKeyComputerFactoryProvider nkcfProvider = context.getNormalizedKeyComputerFactoryProvider(); INormalizedKeyComputerFactory nkcf = null; for (int i = 0; i < n; i++) { sortFields[i] = opSchema.findVariable(sortColumns[i].getColumn()); Object type = env.getVarType(sortColumns[i].getColumn()); IBinaryComparatorFactoryProvider bcfp = context.getBinaryComparatorFactoryProvider(); comps[i] = bcfp.getBinaryComparatorFactory(type, sortColumns[i].getOrder() == OrderKind.ASC); IBinaryHashFunctionFactoryProvider bhffp = context.getBinaryHashFunctionFactoryProvider(); hashFuns[i] = bhffp.getBinaryHashFunctionFactory(type); if (i == 0 && nkcfProvider != null && type != null) { nkcf = nkcfProvider.getNormalizedKeyComputerFactory(type, sortColumns[i].getOrder() == OrderKind.ASC); } } ITuplePartitionComputerFactory tpcf = new FieldHashPartitionComputerFactory(sortFields, hashFuns); IConnectorDescriptor conn = new MToNPartitioningMergingConnectorDescriptor(spec, tpcf, sortFields, comps, nkcf); return new Pair<IConnectorDescriptor, TargetConstraint>(conn, TargetConstraint.ONE); }
for (LogicalVariable v : keysLeftBranch) { Object t = env.getVarType(v); comparatorFactories[i++] = bcfp.getBinaryComparatorFactory(t, true);
comps[i] = bcfp.getBinaryComparatorFactory(type, oc.getOrder() == OrderKind.ASC); i++;
ISerializerDeserializer keySerde = serdeProvider.getSerializerDeserializer(keyType); secondaryRecFields[i] = keySerde; secondaryComparatorFactories[i] = comparatorFactoryProvider.getBinaryComparatorFactory(keyType, true); secondaryTypeTraits[i] = typeTraitProvider.getTypeTrait(keyType); secondaryBloomFilterKeyFields[i] = i;