@Override public boolean doHasNext() throws HyracksDataException { return btreeCursor.hasNext(); }
protected void consumeCursorTuples(IIndexCursor cursor) throws HyracksDataException { while (cursor.hasNext()) { cursor.next(); } } }
@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); } }
@SuppressWarnings("rawtypes") @Override public String printInvList(ISerializerDeserializer[] serdes) throws HyracksDataException { StringBuilder strBuilder = new StringBuilder(); try { while (btreeCursor.hasNext()) { btreeCursor.next(); ITupleReference tuple = btreeCursor.getTuple(); ByteArrayInputStream inStream = new ByteArrayInputStream(tuple.getFieldData(1), tuple.getFieldStart(1), tuple.getFieldLength(1)); DataInput dataIn = new DataInputStream(inStream); Object o = serdes[0].deserialize(dataIn); strBuilder.append(o.toString() + " "); } } finally { btreeCursor.close(); } btreeAccessor.search(btreeCursor, btreePred); return strBuilder.toString(); }
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; } }
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; }
/** * 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; }
private <T> void search(IIndexAccessor indexAccessor, RangePredicate rangePred, List<T> results, IValueExtractor<T> valueExtractor, TxnId txnId) throws HyracksDataException, RemoteException, AlgebricksException { IIndexCursor rangeCursor = indexAccessor.createSearchCursor(false); try { indexAccessor.search(rangeCursor, rangePred); try { while (rangeCursor.hasNext()) { rangeCursor.next(); T result = valueExtractor.getValue(txnId, rangeCursor.getTuple()); if (result != null) { results.add(result); } } } finally { rangeCursor.close(); } } finally { rangeCursor.destroy(); } }
protected ITupleReference getNext(IIndexCursor cursor) throws HyracksDataException { Assert.assertTrue(cursor.hasNext()); cursor.next(); return cursor.getTuple(); } }
protected ITupleReference getNext(IIndexCursor cursor) throws HyracksDataException { Assert.assertTrue(cursor.hasNext()); cursor.next(); return cursor.getTuple(); }
private void flushLoadBtree(BTreeAccessor memBTreeAccessor, ILSMDiskComponentBulkLoader componentBulkLoader, RangePredicate btreeNullPredicate) throws HyracksDataException { IIndexCursor btreeScanCursor = memBTreeAccessor.createSearchCursor(false); try { memBTreeAccessor.search(btreeScanCursor, btreeNullPredicate); try { while (btreeScanCursor.hasNext()) { btreeScanCursor.next(); ITupleReference frameTuple = btreeScanCursor.getTuple(); componentBulkLoader.delete(frameTuple); } } finally { btreeScanCursor.close(); } } finally { btreeScanCursor.destroy(); } }
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; } } }
private void consumeIntTupleRange(int begin, int end, boolean blockOnHigh, int expectedAfterBlock) throws Exception { if (end < begin) { throw new IllegalArgumentException("Invalid range: [" + begin + ", " + end + "]"); } for (int i = begin; i <= end; i++) { if (blockOnHigh == true && i == end) { this.blockOnHigh = true; this.expectedAfterBlock = expectedAfterBlock; } TupleUtils.createIntegerTuple(builder, tuple, i); if (!cursor.hasNext()) { Assert.fail("Failed to consume entire tuple range since cursor is exhausted."); } cursor.next(); Assert.assertEquals(0, cmp.compare(tuple, cursor.getTuple())); } }
private void countTuples(BTreeAccessor memBTreeAccessor, RangePredicate btreeNullPredicate, MutableLong numBTreeTuples) throws HyracksDataException { IIndexCursor btreeCountingCursor = memBTreeAccessor.createCountingSearchCursor(); try { memBTreeAccessor.search(btreeCountingCursor, btreeNullPredicate); try { while (btreeCountingCursor.hasNext()) { btreeCountingCursor.next(); ITupleReference countTuple = btreeCountingCursor.getTuple(); numBTreeTuples.setValue( IntegerPointable.getInteger(countTuple.getFieldData(0), countTuple.getFieldStart(0))); } } finally { btreeCountingCursor.close(); } } finally { btreeCountingCursor.destroy(); } }
@Override protected void writeSearchResults(int tupleIndex) throws Exception { while (cursor.hasNext()) { tb.reset(); cursor.next(); if (retainInput) { frameTuple.reset(accessor, tupleIndex); for (int i = 0; i < frameTuple.getFieldCount(); i++) { dos.write(frameTuple.getFieldData(i), frameTuple.getFieldStart(i), frameTuple.getFieldLength(i)); tb.addFieldEndOffset(); } } ITupleReference tuple = cursor.getTuple(); tupleUpdater.updateTuple(tuple); for (int i = 0; i < tuple.getFieldCount(); i++) { dos.write(tuple.getFieldData(i), tuple.getFieldStart(i), tuple.getFieldLength(i)); tb.addFieldEndOffset(); } FrameUtils.appendToWriter(writer, appender, tb.getFieldEndOffsets(), tb.getByteArray(), 0, tb.getSize()); } } }
@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); }
@Override public int size() throws HyracksDataException { if (numElements < 0) { btreePred.setLowKeyComparator(tokenFieldsCmp); btreePred.setHighKeyComparator(tokenFieldsCmp); btreePred.setLowKey(tokenTuple, true); btreePred.setHighKey(tokenTuple, true); // Perform the count. btreeAccessor.search(countingCursor, btreePred); try { while (countingCursor.hasNext()) { countingCursor.next(); ITupleReference countTuple = countingCursor.getTuple(); numElements = IntegerPointable.getInteger(countTuple.getFieldData(0), countTuple.getFieldStart(0)); } } finally { countingCursor.close(); } } return numElements; }
@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 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); }
@Test public void testNormalLifeCycle() throws Exception { IIndexAccessor accessor = createAccessor(); IIndexCursor cursor = createCursor(accessor); List<ISearchPredicate> predicates = createSearchPredicates(); for (ISearchPredicate predicate : predicates) { open(accessor, cursor, predicate); while (cursor.hasNext()) { cursor.next(); } cursor.close(); } cursor.destroy(); destroy(accessor); }