protected void pushIntoQueueFromCursorAndReplaceThisElement(PriorityQueueElement e) throws HyracksDataException { int cursorIndex = e.getCursorIndex(); if (rangeCursors[cursorIndex].hasNext()) { rangeCursors[cursorIndex].next(); e.reset(rangeCursors[cursorIndex].getTuple()); outputPriorityQueue.offer(e); return; } rangeCursors[cursorIndex].close(); if (cursorIndex == 0) { includeMutableComponent = false; } }
@Override public void doDestroy() throws HyracksDataException { btreeCursor.destroy(); }
@Override public void search(ILSMIndexOperationContext ictx, IIndexCursor cursor, ISearchPredicate pred) throws HyracksDataException { LSMRTreeOpContext ctx = (LSMRTreeOpContext) ictx; cursor.open(ctx.getSearchInitialState(), pred); }
@Override public void checkExpectedResults(IIndexCursor cursor, Collection checkTuples, ISerializerDeserializer[] fieldSerdes, int keyFieldCount, Iterator<CheckTuple> checkIter) throws Exception { int actualCount = 0; while (cursor.hasNext()) { if (!checkIter.hasNext()) { fail("Ordered scan returned more answers than expected.\nExpected: " + checkTuples.size()); } cursor.next(); CheckTuple expectedTuple = checkIter.next(); ITupleReference tuple = cursor.getTuple(); compareActualAndExpected(tuple, expectedTuple, fieldSerdes); actualCount++; } if (actualCount < checkTuples.size()) { fail("Ordered scan returned fewer answers than expected.\nExpected: " + checkTuples.size() + "\nActual : " + actualCount); } }
@Override public Boolean call() throws Exception { lock.lock(); try { try { while (!insertTaskStarted) { condition.await(); } // begin a search on [101, +inf), blocking on 101 TupleUtils.createIntegerTuple(builder, tuple, 101); predicate.setLowKey(tuple, true); predicate.setHighKey(null, true); accessor.search(cursor, predicate); try { consumeIntTupleRange(101, 101, true, 101); // consume tuples [102, 152], blocking on 151 consumeIntTupleRange(102, 151, true, 152); // consume tuples [153, 300] consumeIntTupleRange(153, 300, false, -1); } finally { cursor.close(); } } finally { cursor.destroy(); } } finally { lock.unlock(); } return true; }
protected boolean isDeleted(ITupleReference key) throws HyracksDataException { keySearchPred.setLowKey(key, true); keySearchPred.setHighKey(key, true); for (int i = 0; i < accessorIndex; i++) { deletedKeysBTreeCursors[i].close(); if (deletedKeysBTreeBloomFilters[i] != null && !deletedKeysBTreeBloomFilters[i].contains(key, hashes)) { continue; } try { deletedKeysBTreeAccessors.get(i).search(deletedKeysBTreeCursors[i], keySearchPred); if (deletedKeysBTreeCursors[i].hasNext()) { return true; } } finally { deletedKeysBTreeCursors[i].close(); } } return false; }
@Test public void testHasNextAfterCloseFails() throws Exception { IIndexAccessor accessor = createAccessor(); IIndexCursor cursor = createCursor(accessor); List<ISearchPredicate> predicates = createSearchPredicates(); open(accessor, cursor, predicates.get(0)); cursor.close(); boolean expectedExceptionThrown = false; try { cursor.hasNext(); } catch (Exception e) { expectedExceptionThrown = true; } cursor.destroy(); destroy(accessor); Assert.assertTrue(expectedExceptionThrown); }
@Test public void testNextAfterCloseFails() throws Exception { IIndexAccessor accessor = createAccessor(); IIndexCursor cursor = createCursor(accessor); List<ISearchPredicate> predicates = createSearchPredicates(); open(accessor, cursor, predicates.get(0)); cursor.close(); boolean expectedExceptionThrown = false; try { cursor.next(); } catch (Exception e) { expectedExceptionThrown = true; } cursor.destroy(); destroy(accessor); Assert.assertTrue(expectedExceptionThrown); }
@Override public void unloadPages() throws HyracksDataException { if (cursorNeedsClose) { btreeCursor.close(); cursorNeedsClose = false; } }
@Test public void testGetTupleReturnsNullAfterDestroy() throws Exception { IIndexAccessor accessor = createAccessor(); IIndexCursor cursor = createCursor(accessor); List<ISearchPredicate> predicates = createSearchPredicates(); open(accessor, cursor, predicates.get(0)); cursor.close(); cursor.destroy(); destroy(accessor); Assert.assertNull(cursor.getTuple()); }
@Test public void testHasNextBeforeOpenFails() throws Exception { IIndexAccessor accessor = createAccessor(); IIndexCursor cursor = createCursor(accessor); boolean expectedExceptionThrown = false; try { cursor.hasNext(); } catch (Exception e) { expectedExceptionThrown = true; } cursor.destroy(); destroy(accessor); Assert.assertTrue(expectedExceptionThrown); }
@Test public void testNextBeforeOpenFails() throws Exception { IIndexAccessor accessor = createAccessor(); IIndexCursor cursor = createCursor(accessor); boolean expectedExceptionThrown = false; try { cursor.next(); } catch (Exception e) { expectedExceptionThrown = true; } cursor.destroy(); destroy(accessor); Assert.assertTrue(expectedExceptionThrown); }
@Override public boolean doHasNext() throws HyracksDataException { return btreeCursor.hasNext(); }
@Override public ITupleReference doGetTuple() { return currentCursor.getTuple(); }
@Override public void doNext() throws HyracksDataException { btreeCursor.next(); }
private void openInvListRangeSearchCursor() throws HyracksDataException { if (btreeCursor.hasNext()) { btreeCursor.next(); tokenTuple.reset(btreeCursor.getTuple()); invIndex.openInvertedListCursor(btreeCursor.getTuple(), invListRangeSearchCursor, (OnDiskInvertedIndexOpContext) opCtx); invListRangeSearchCursor.prepareLoadPages(); invListRangeSearchCursor.loadPages(); resultTuple.setTokenTuple(tokenTuple); isInvListCursorOpen = true; } else { isInvListCursorOpen = false; } } }
@Test public void testDoubleCloseSucceeds() throws Exception { IIndexAccessor accessor = createAccessor(); IIndexCursor cursor = createCursor(accessor); List<ISearchPredicate> predicates = createSearchPredicates(); open(accessor, cursor, predicates.get(0)); cursor.close(); cursor.close(); cursor.destroy(); destroy(accessor); }
/** * Check deleted-keys BTrees whether they contain the key in the checkElement's tuple. */ protected boolean isDeleted(PriorityQueueElement keyElement) throws HyracksDataException { ITupleReference keyTuple = keyElement.getTuple(); int end = keyElement.getCursorIndex(); for (int i = 0; i < end; i++) { if (bloomFilters[i] != null && !bloomFilters[i].contains(keyTuple, hashes)) { continue; } deletedKeysBTreeCursors[i].close(); deletedKeysBTreeAccessors.get(i).search(deletedKeysBTreeCursors[i], deletedKeyBTreeSearchPred); try { if (deletedKeysBTreeCursors[i].hasNext()) { return true; } } finally { deletedKeysBTreeCursors[i].close(); } } return false; }
@Test public void testHasNextAfterDestroyFails() throws Exception { IIndexAccessor accessor = createAccessor(); IIndexCursor cursor = createCursor(accessor); List<ISearchPredicate> predicates = createSearchPredicates(); open(accessor, cursor, predicates.get(0)); cursor.close(); cursor.destroy(); boolean expectedExceptionThrown = false; try { cursor.hasNext(); } catch (Exception e) { expectedExceptionThrown = true; } destroy(accessor); Assert.assertTrue(expectedExceptionThrown); }