protected int compare(MultiComparator cmp, ITupleReference tupleA, ITupleReference tupleB) throws HyracksDataException { return cmp.compare(tupleA, tupleB); }
private boolean fitInPage(ITupleReference key, MultiComparator comparator, IBTreeFrame frame) throws HyracksDataException { ITupleReference rightmostTuple = frame.getRightmostTuple(); int cmp = comparator.compare(key, rightmostTuple); if (cmp > 0) { return false; } ITupleReference leftmostTuple = frame.getLeftmostTuple(); return comparator.compare(key, leftmostTuple) >= 0; }
private void validateWithPrevious(MultiComparator invListCmp, ITupleReference invListElement, ArrayTupleReference prevTuple) throws HyracksDataException { if (invListCmp.compare(invListElement, prevTuple) <= 0) { throw new HyracksDataException("Index validation failed."); } }
@Override public boolean proceed(ITupleReference tuple) throws HyracksDataException { Assert.assertEquals(0, cmp.compare(SearchTask.this.tuple, tuple)); return false; }
@Override public void after(ITupleReference tuple) throws HyracksDataException { Assert.assertEquals(0, cmp.compare(AbstractModificationOperationCallbackTest.this.tuple, tuple)); } }
@Override public void before(ITupleReference tuple) throws HyracksDataException { Assert.assertEquals(0, cmp.compare(AbstractModificationOperationCallbackTest.this.tuple, tuple)); }
@Override public void found(ITupleReference before, ITupleReference after) throws HyracksDataException { if (isFoundNull) { Assert.assertEquals(null, before); } else { Assert.assertEquals(0, cmp.compare(AbstractModificationOperationCallbackTest.this.tuple, before)); } Assert.assertEquals(0, cmp.compare(AbstractModificationOperationCallbackTest.this.tuple, after)); }
@Override public int compare(ITupleReference o1, ITupleReference o2) { try { return cmp.compare(o1, o2); } catch (HyracksDataException e) { throw new IllegalArgumentException(e); } } }
@Override public int compare(ITupleReference o1, ITupleReference o2) { try { return cmp.compare(o1, o2); } catch (HyracksDataException e) { throw new IllegalArgumentException(e); } } }
protected void verifyTuple(ITupleReference tuple) throws HyracksDataException { if (lastTupleBuilder.getSize() > 0 && allCmp.compare(tuple, lastTuple) <= 0) { HyracksDataException.create(ErrorCode.UNSORTED_LOAD_INPUT); } }
protected void verifyInputTuple(ITupleReference tuple, ITupleReference prevTuple) throws HyracksDataException { // New tuple should be strictly greater than last tuple. int cmpResult = cmp.compare(tuple, prevTuple); if (cmpResult < 0) { throw HyracksDataException.create(ErrorCode.UNSORTED_LOAD_INPUT); } if (cmpResult == 0) { throw HyracksDataException.create(ErrorCode.DUPLICATE_LOAD_INPUT); } }
@Override public boolean proceed(ITupleReference tuple) throws HyracksDataException { Assert.assertEquals(0, cmp.compare(SearchTask.this.expectedTupleToBeLocked, tuple)); return false; }
@Override public void before(ITupleReference tuple) throws HyracksDataException { Assert.assertEquals(0, cmp.compare(this.tuple, tuple)); }
@Override public void reconcile(ITupleReference tuple) throws HyracksDataException { Assert.assertEquals(0, cmp.compare(SearchTask.this.tuple, tuple)); if (blockOnHigh) { try { TupleUtils.createIntegerTuple(builder, SearchTask.this.tuple, expectedAfterBlock); } catch (HyracksDataException e) { e.printStackTrace(); } condition.signal(); condition.awaitUninterruptibly(); blockOnHigh = false; } }
@Override public void cancel(ITupleReference tuple) { try { TupleUtils.createIntegerTuple(builder, SearchTask.this.tuple, blockingValue); Assert.assertEquals(0, cmp.compare(tuple, SearchTask.this.tuple)); TupleUtils.createIntegerTuple(builder, SearchTask.this.tuple, expectedAfterBlock); } catch (HyracksDataException e) { e.printStackTrace(); } }
private boolean setAntiMatterTuple(ITupleReference diskTuple, int cursorIndex) throws HyracksDataException { if (originalTuple == null || cmp.compare(diskTuple, originalTuple) != 0) { // This could happen sometimes... // Consider insert tuple A into the memory component, and then delete it immediately. // We would have -A in the memory component, but there is no tuple A in the previous disk components. // But in this case, we can simply ignore it for the scan purpose return false; } buildTuple(antiMatterTupleBuilder, originalTuple, cursorIndex, ANTIMATTER_TUPLE_FLAG); outputTuple.reset(antiMatterTupleBuilder.getFieldEndOffsets(), antiMatterTupleBuilder.getByteArray()); return true; }
@Override public void complete(ITupleReference tuple) throws HyracksDataException { Assert.assertEquals(0, cmp.compare(SearchTask.this.expectedTupleToBeLocked, tuple)); expectedTupleToBeLockedValue++; TupleUtils.createIntegerTuple(expectedTupleToBeLockedBuilder, expectedTupleToBeLocked, expectedTupleToBeLockedValue); }
@Override public void cancel(ITupleReference tuple) throws HyracksDataException { boolean found = false; for (int i : deleteSet) { TupleUtils.createIntegerTuple(expectedTupleToBeCanceledBuilder, expectedTupleToBeCanceled, i); if (cmp.compare(SearchTask.this.expectedTupleToBeCanceled, tuple) == 0) { found = true; break; } } Assert.assertTrue(found); }
@Override public void reconcile(ITupleReference tuple) throws HyracksDataException { Assert.assertEquals(0, cmp.compare(SearchTask.this.expectedTupleToBeLocked, tuple)); if (blockOnHigh) { TupleUtils.createIntegerTuple(builder, SearchTask.this.tuple, expectedAfterBlock); condition.signal(); condition.awaitUninterruptibly(); blockOnHigh = false; } }
@Override public void found(ITupleReference before, ITupleReference after) throws HyracksDataException { if (isFoundNull) { Assert.assertEquals(null, before); } else { Assert.assertEquals(0, cmp.compare(this.tuple, before)); Assert.assertEquals(isUpdated, ((IBTreeIndexTupleReference) before).isUpdated()); } Assert.assertEquals(0, cmp.compare(this.tuple, after)); }