@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 int compare(byte[] b1, int s1, int l1, byte[] b2, int s2, int l2) throws HyracksDataException { return -comparator.compare(b1, s1, l1, b2, s2, l2); } };
@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 int compare(byte[] b1, int s1, int l1, byte[] b2, int s2, int l2) throws HyracksDataException { ATypeTag tag1 = EnumDeserializer.ATYPETAGDESERIALIZER.deserialize(b1[s1]); ATypeTag tag2 = EnumDeserializer.ATYPETAGDESERIALIZER.deserialize(b2[s2]); if (tag1 == ATypeTag.INTERVAL && tag2 == ATypeTag.INTERVAL) { return descIntervalComp.compare(b1, s1 + 1, l1 - 1, b2, s2 + 1, l2 - 1); } return -ascComp.compare(b1, s1, l1, b2, s2, l2); } };
@Override public int compare(ISequenceIterator cmpIter) throws HyracksDataException { return cmp.compare(data, pos, -1, cmpIter.getData(), cmpIter.getPos(), -1); }
private int compareStrInByteArrayAndPointable(byte[] left, IPointable right, boolean rightTypeTagIncluded) throws HyracksDataException { int rightTypeTagLength = rightTypeTagIncluded ? 1 : 0; return strLowerCaseCmp.compare(left, 0, left.length, right.getByteArray(), right.getStartOffset() + rightTypeTagLength, right.getLength() - rightTypeTagLength); }
public static boolean sameGroup(IFrameTupleAccessor a1, int t1Idx, IFrameTupleAccessor a2, int t2Idx, int[] groupFields, IBinaryComparator[] comparators) throws HyracksDataException { for (int i = 0; i < comparators.length; ++i) { int fIdx = groupFields[i]; int s1 = a1.getAbsoluteFieldStartOffset(t1Idx, fIdx); int l1 = a1.getFieldLength(t1Idx, fIdx); int s2 = a2.getAbsoluteFieldStartOffset(t2Idx, fIdx); int l2 = a2.getFieldLength(t2Idx, fIdx); if (comparators[i].compare(a1.getBuffer().array(), s1, l1, a2.getBuffer().array(), s2, l2) != 0) { return false; } } return true; }
public static <T extends IValueReference> T findItem(IValueReference item, List<T> sameHashes, IBinaryComparator comp) throws HyracksDataException { T sameItem; for (int k = 0; k < sameHashes.size(); k++) { sameItem = sameHashes.get(k); if (comp.compare(item.getByteArray(), item.getStartOffset(), item.getLength(), sameItem.getByteArray(), sameItem.getStartOffset(), sameItem.getLength()) == 0) { return sameItem; } } return null; } }
@Override public int compare(IPointable val1, IPointable val2) { try { return comp.compare(val1.getByteArray(), val1.getStartOffset(), val1.getLength(), val2.getByteArray(), val2.getStartOffset(), val2.getLength()); } catch (HyracksDataException e) { throw new IllegalStateException(e); } } }
@Override public int compare(ITupleReference tupleA, ITupleReference tupleB) throws HyracksDataException { return cmp.compare(tupleA.getFieldData(0), tupleA.getFieldStart(0), tupleA.getFieldLength(0), tupleB.getFieldData(0), tupleB.getFieldStart(0), tupleB.getFieldLength(0)); } }
protected int pointerCmp(ITupleReference tupleA, ITupleReference tupleB, MultiComparator cmp) throws HyracksDataException { return childPtrCmp.compare(tupleA.getFieldData(cmp.getKeyFieldCount() - 1), getChildPointerOff(tupleA), childPtrSize, tupleB.getFieldData(cmp.getKeyFieldCount() - 1), getChildPointerOff(tupleB), childPtrSize); }
public static int compareStringBinValues(IValueReference a, IValueReference b, IBinaryComparator comparator) throws HyracksDataException { // start+1 and len-1 due to type tag ignore (only interested in String value) return comparator.compare(a.getByteArray(), a.getStartOffset() + 1, a.getLength() - 1, b.getByteArray(), b.getStartOffset() + 1, b.getLength() - 1); }
public int selectiveFieldCompare(ITupleReference tupleA, ITupleReference tupleB, int[] fields) throws HyracksDataException { for (int j = 0; j < cmps.length; j++) { int i = fields[j]; int cmp = cmps[j].compare(tupleA.getFieldData(i), tupleA.getFieldStart(i), tupleA.getFieldLength(i), tupleB.getFieldData(i), tupleB.getFieldStart(i), tupleB.getFieldLength(i)); if (cmp != 0) { return cmp; } } return 0; }
public static int compareFilterTuples(ITupleReference lhs, ITupleReference rhs, IBinaryComparator comp) throws HyracksDataException { return comp.compare(lhs.getFieldData(0), lhs.getFieldStart(0), lhs.getFieldLength(0), rhs.getFieldData(0), rhs.getFieldStart(0), rhs.getFieldLength(0)); }
private boolean sameGroup() throws HyracksDataException { for (int i = 0; i < args.length; i++) { IPointable v1 = argPrevValues[i]; IPointable v2 = argCurrValues[i]; IBinaryComparator cmp = argComparators[i]; if (cmp.compare(v1.getByteArray(), v1.getStartOffset(), v1.getLength(), v2.getByteArray(), v2.getStartOffset(), v2.getLength()) != 0) { return false; } } return true; } }
private int compare(IValueReference a, IValueReference b) throws HyracksDataException { // start+1 and len-1 due to the type tag return fieldNameComparator.compare(a.getByteArray(), a.getStartOffset() + 1, a.getLength() - 1, b.getByteArray(), b.getStartOffset() + 1, b.getLength() - 1); } }
public int fieldRangeCompare(ITupleReference tupleA, ITupleReference tupleB, int startFieldIndex, int numFields) throws HyracksDataException { for (int i = startFieldIndex; i < startFieldIndex + numFields; i++) { int cmp = cmps[i].compare(tupleA.getFieldData(i), tupleA.getFieldStart(i), tupleA.getFieldLength(i), tupleB.getFieldData(i), tupleB.getFieldStart(i), tupleB.getFieldLength(i)); if (cmp != 0) { return cmp; } } return 0; }
public int compare(ITupleReference tupleA, ITupleReference tupleB) throws HyracksDataException { for (int i = 0; i < cmps.length; i++) { int cmp = cmps[i].compare(tupleA.getFieldData(i), tupleA.getFieldStart(i), tupleA.getFieldLength(i), tupleB.getFieldData(i), tupleB.getFieldStart(i), tupleB.getFieldLength(i)); if (cmp != 0) { return cmp; } } return 0; }
public int compare(ITupleReference tupleA, ITupleReference tupleB, int startFieldIndex) throws HyracksDataException { for (int i = 0; i < cmps.length; i++) { int ix = startFieldIndex + i; int cmp = cmps[i].compare(tupleA.getFieldData(ix), tupleA.getFieldStart(ix), tupleA.getFieldLength(ix), tupleB.getFieldData(ix), tupleB.getFieldStart(ix), tupleB.getFieldLength(ix)); if (cmp != 0) { return cmp; } } return 0; }
private int compareStringWithArg(ATypeTag typeTag2, IPointable arg1, IPointable arg2) throws HyracksDataException { if (typeTag2 == ATypeTag.STRING) { return strBinaryComp.compare(arg1.getByteArray(), arg1.getStartOffset(), arg1.getLength() - 1, arg2.getByteArray(), arg2.getStartOffset(), arg2.getLength() - 1); } throw new IncompatibleTypeException(sourceLoc, COMPARISON, ATypeTag.SERIALIZED_STRING_TYPE_TAG, typeTag2.serialize()); }