protected static IBinaryComparator[] createBinaryComparators(IBinaryComparatorFactory[] factories) { IBinaryComparator[] comparators = new IBinaryComparator[factories.length]; for (int i = 0; i < factories.length; i++) { comparators[i] = factories[i].createBinaryComparator(); } return comparators; }
@Override public JsonNode toJson(IPersistedResourceRegistry registry) throws HyracksDataException { ObjectNode json = registry.getClassIdentifier(getClass(), serialVersionUID); json.set("factory", factory.toJson(registry)); json.put("ascending", ascending); return json; }
@Override public IBinaryComparator createBinaryComparator() { final IBinaryComparator bc = factory.createBinaryComparator(); if (ascending) { return new ABinaryComparator() { @Override public int compare(byte[] b1, int s1, int l1, byte[] b2, int s2, int l2) throws HyracksDataException { return bc.compare(b1, s1 + 1, l1 - 1, b2, s2 + 1, l2 - 1); } }; } else { return new ABinaryComparator() { @Override public int compare(byte[] b1, int s1, int l1, byte[] b2, int s2, int l2) throws HyracksDataException { return -bc.compare(b1, s1 + 1, l1 - 1, b2, s2 + 1, l2 - 1); } }; } }
@Override public JsonNode toJson(IPersistedResourceRegistry registry) throws HyracksDataException { ObjectNode json = registry.getClassIdentifier(getClass(), serialVersionUID); json.set("factory", factory.toJson(registry)); json.put("ascending", ascending); return json; }
final IBinaryComparator[] comparators = new IBinaryComparator[comparatorFactories.length]; for (int i = 0; i < comparatorFactories.length; ++i) { comparators[i] = comparatorFactories[i].createBinaryComparator();
@Override protected void appendToJson(final ObjectNode json, IPersistedResourceRegistry registry) throws HyracksDataException { super.appendToJson(json, registry); final ArrayNode btreeCmpFactoriesArray = OBJECT_MAPPER.createArrayNode(); for (IBinaryComparatorFactory factory : btreeCmpFactories) { btreeCmpFactoriesArray.add(factory.toJson(registry)); } json.set("btreeCmpFactories", btreeCmpFactoriesArray); json.set("linearizeCmpFactory", linearizeCmpFactory.toJson(registry)); final ArrayNode valueProviderFactoriesArray = OBJECT_MAPPER.createArrayNode(); for (IPrimitiveValueProviderFactory factory : valueProviderFactories) { valueProviderFactoriesArray.add(factory.toJson(registry)); } json.set("valueProviderFactories", valueProviderFactoriesArray); json.set("rtreePolicyType", rtreePolicyType.toJson(registry)); json.putPOJO("rtreeFields", rtreeFields); json.putPOJO("buddyBTreeFields", buddyBTreeFields); json.put("isPointMBR", isPointMBR); json.put("bloomFilterFalsePositiveRate", bloomFilterFalsePositiveRate); }
final IBinaryComparator[] comparators = new IBinaryComparator[comparatorFactories.length]; for (int i = 0; i < comparatorFactories.length; ++i) { comparators[i] = comparatorFactories[i].createBinaryComparator();
@Override public JsonNode toJson(IPersistedResourceRegistry registry) throws HyracksDataException { ObjectNode jsonObject = registry.getClassIdentifier(getClass(), serialVersionUID); super.appendToJson(jsonObject, registry); ArrayNode btreeCmpFactoriesArray = OBJECT_MAPPER.createArrayNode(); for (IBinaryComparatorFactory factory : btreeCmpFactories) { btreeCmpFactoriesArray.add(factory.toJson(registry)); } jsonObject.set("btreeCmpFactories", btreeCmpFactoriesArray); jsonObject.set("linearizeCmpFactory", linearizeCmpFactory.toJson(registry)); final ArrayNode valueProviderFactoriesArray = OBJECT_MAPPER.createArrayNode(); for (IPrimitiveValueProviderFactory factory : valueProviderFactories) { valueProviderFactoriesArray.add(factory.toJson(registry)); } jsonObject.set("valueProviderFactories", valueProviderFactoriesArray); jsonObject.set("rtreePolicyType", rtreePolicyType.toJson(registry)); jsonObject.putPOJO("rtreeFields", rtreeFields); jsonObject.put("isPointMBR", isPointMBR); return jsonObject; }
@Override public ITuplePairComparator createTuplePairComparator(IHyracksTaskContext ctx) { IBinaryComparator[] binaryComparators = new IBinaryComparator[binaryComparatorFactories.length]; for (int i = 0; i < binaryComparators.length; i++) { binaryComparators[i] = binaryComparatorFactories[i].createBinaryComparator(); } return new JoinMultiComparator(binaryComparators, keysLeft, keysRight); } }
@Override protected IFrameWriter getFlushableFrameWriter(RunFileWriter writer) throws HyracksDataException { //create group-by comparators IBinaryComparator[] comparators = new IBinaryComparator[Math.min(groupFields.length, comparatorFactories.length)]; for (int i = 0; i < comparators.length; i++) { comparators[i] = comparatorFactories[i].createBinaryComparator(); } return new PreclusteredGroupWriter(ctx, groupFields, comparators, aggregatorFactory, this.inRecordDesc, this.outRecordDesc, writer, true); } }
@Override public JsonNode toJson(IPersistedResourceRegistry registry) throws HyracksDataException { ObjectNode jsonObject = registry.getClassIdentifier(getClass(), serialVersionUID); super.appendToJson(jsonObject, registry); final ArrayNode tokenTypeTraitsArray = OBJECT_MAPPER.createArrayNode(); for (ITypeTraits tt : tokenTypeTraits) { tokenTypeTraitsArray.add(tt.toJson(registry)); } jsonObject.set("tokenTypeTraits", tokenTypeTraitsArray); final ArrayNode tokenCmpFactoriesArray = OBJECT_MAPPER.createArrayNode(); for (IBinaryComparatorFactory factory : tokenCmpFactories) { tokenCmpFactoriesArray.add(factory.toJson(registry)); } jsonObject.set("tokenCmpFactories", tokenCmpFactoriesArray); jsonObject.set("tokenizerFactory", tokenizerFactory.toJson(registry)); jsonObject.put("isPartitioned", isPartitioned); jsonObject.putPOJO("invertedIndexFields", invertedIndexFields); jsonObject.putPOJO("filterFieldsForNonBulkLoadOps", filterFieldsForNonBulkLoadOps); jsonObject.putPOJO("invertedIndexFieldsForNonBulkLoadOps", invertedIndexFieldsForNonBulkLoadOps); jsonObject.putPOJO("bloomFilterFalsePositiveRate", bloomFilterFalsePositiveRate); return jsonObject; }
public static IBinaryComparator serdeToComparator(ISerializerDeserializer serde) { IBinaryComparatorFactory f = serdeToComparatorFactory(serde); return f.createBinaryComparator(); }
@Override public ITuplePairComparator createTuplePairComparator(IHyracksTaskContext ctx) { return new JoinComparator(bFactory.createBinaryComparator(), pos0, pos1); }
public ExternalGroupBuildOperatorNodePushable(IHyracksTaskContext ctx, Object stateId, int tableSize, long fileSize, int[] keyFields, int framesLimit, IBinaryComparatorFactory[] comparatorFactories, INormalizedKeyComputerFactory firstNormalizerFactory, IAggregatorDescriptorFactory aggregatorFactory, RecordDescriptor inRecordDescriptor, RecordDescriptor outRecordDescriptor, ISpillableTableFactory spillableTableFactory) { this.ctx = ctx; this.stateId = stateId; this.framesLimit = framesLimit; this.aggregatorFactory = aggregatorFactory; this.keyFields = keyFields; this.comparators = new IBinaryComparator[comparatorFactories.length]; for (int i = 0; i < comparatorFactories.length; ++i) { comparators[i] = comparatorFactories[i].createBinaryComparator(); } this.firstNormalizerComputer = firstNormalizerFactory == null ? null : firstNormalizerFactory.createNormalizedKeyComputer(); this.spillableTableFactory = spillableTableFactory; this.inRecordDescriptor = inRecordDescriptor; this.outRecordDescriptor = outRecordDescriptor; this.tableSize = tableSize; this.fileSize = fileSize; }
public ExternalGroupWriteOperatorNodePushable(IHyracksTaskContext ctx, Object stateId, ISpillableTableFactory spillableTableFactory, RecordDescriptor partialAggRecordDesc, RecordDescriptor outRecordDesc, int framesLimit, int[] groupFields, INormalizedKeyComputerFactory nmkFactory, IBinaryComparatorFactory[] comparatorFactories, IAggregatorDescriptorFactory aggregatorFactory) { this.ctx = ctx; this.stateId = stateId; this.spillableTableFactory = spillableTableFactory; this.frameLimit = framesLimit; this.nmkComputer = nmkFactory == null ? null : nmkFactory.createNormalizedKeyComputer(); this.partialAggRecordDesc = partialAggRecordDesc; this.outRecordDesc = outRecordDesc; this.mergeAggregatorFactory = aggregatorFactory; //create merge group fields int numGroupFields = groupFields.length; mergeGroupFields = new int[numGroupFields]; for (int i = 0; i < numGroupFields; i++) { mergeGroupFields[i] = i; } //setup comparators for grouping groupByComparators = new IBinaryComparator[Math.min(mergeGroupFields.length, comparatorFactories.length)]; for (int i = 0; i < groupByComparators.length; i++) { groupByComparators[i] = comparatorFactories[i].createBinaryComparator(); } }
@Override public ILinearizeComparator createBinaryComparator() { final ILinearizeComparator bc = (ILinearizeComparator) factory.createBinaryComparator(); final int dimension = bc.getDimensions(); if (ascending) { return new ILinearizeComparator() { @Override public int compare(byte[] b1, int s1, int l1, byte[] b2, int s2, int l2) throws HyracksDataException { return bc.compare(b1, s1 + 1, l1, b2, s2 + 1, l2); } @Override public int getDimensions() { return dimension; } }; } else { return new ILinearizeComparator() { @Override public int compare(byte[] b1, int s1, int l1, byte[] b2, int s2, int l2) throws HyracksDataException { return -bc.compare(b1, s1 + 1, l1, b2, s2 + 1, l2); } @Override public int getDimensions() { return dimension; } }; } }
public static MultiComparator create(IBinaryComparatorFactory[] cmpFactories) { IBinaryComparator[] cmps = new IBinaryComparator[cmpFactories.length]; for (int i = 0; i < cmpFactories.length; i++) { cmps[i] = cmpFactories[i].createBinaryComparator(); } if (cmps.length == 1) { return new SingleComparator(cmps); } else { return new MultiComparator(cmps); } }
public static MultiComparator create(IBinaryComparatorFactory[] cmpFactories, int startIndex, int numCmps) { IBinaryComparator[] cmps = new IBinaryComparator[numCmps]; for (int i = startIndex; i < startIndex + numCmps; i++) { cmps[i] = cmpFactories[i].createBinaryComparator(); } if (cmps.length == 1) { return new SingleComparator(cmps); } else { return new MultiComparator(cmps); } }
@Override public void open() throws HyracksDataException { final IBinaryComparator[] comparators = new IBinaryComparator[comparatorFactories.length]; for (int i = 0; i < comparatorFactories.length; ++i) { comparators[i] = comparatorFactories[i].createBinaryComparator(); } pgw = new PreclusteredGroupWriter(ctx, groupFields, comparators, aggregatorFactory, inRecordDescriptor, outRecordDescriptor, writer, false, groupAll, frameLimit); pgw.open(); }