@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 int compare(IFrameTupleAccessor accessor0, int tIndex0, ITuplePointerAccessor bufferAccessor) throws HyracksDataException { int tStart0 = accessor0.getTupleStartOffset(tIndex0); int fStartOffset0 = accessor0.getFieldSlotsLength() + tStart0; for (int i = 0; i < keys0.length; ++i) { int fIdx0 = keys0[i]; int fStart0 = accessor0.getFieldStartOffset(tIndex0, fIdx0); int fEnd0 = accessor0.getFieldEndOffset(tIndex0, fIdx0); int fLen0 = fEnd0 - fStart0; int fStart1 = bufferAccessor.getAbsFieldStartOffset(keys1[i]); int fLen1 = bufferAccessor.getFieldLength(keys1[i]); int c = comparators[i].compare(accessor0.getBuffer().array(), fStart0 + fStartOffset0, fLen0, bufferAccessor.getBuffer().array(), fStart1, fLen1); if (c != 0) { return c; } } 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 compareTuple(IFrameTupleAccessor frameTupleAccessor, int tid, int[] nmkey, HeapEntry maxEntry) throws HyracksDataException { int cmpNormalizedKey = NormalizedKeyUtils.compareNormalizeKeys(nmkey, 0, maxEntry.nmk, 0, normalizedKeyTotalLength); if (cmpNormalizedKey != 0 || normalizedKeyDecisive) { return cmpNormalizedKey; } bufferAccessor2.reset(maxEntry.tuplePointer); byte[] b1 = frameTupleAccessor.getBuffer().array(); byte[] b2 = bufferAccessor2.getBuffer().array(); for (int f = 0; f < comparators.length; ++f) { int fIdx = sortFields[f]; int s1 = frameTupleAccessor.getAbsoluteFieldStartOffset(tid, fIdx); int l1 = frameTupleAccessor.getFieldLength(tid, fIdx); int s2 = bufferAccessor2.getAbsFieldStartOffset(fIdx); int l2 = bufferAccessor2.getFieldLength(fIdx); int c = comparators[f].compare(b1, s1, l1, b2, s2, l2); if (c != 0) { return c; } } return 0; }
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; }