@Override public void doNext() throws HyracksDataException { btreeCursor.next(); }
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; } }
@Override public void checkExpectedResults(IIndexCursor cursor, Collection checkTuples, ISerializerDeserializer[] fieldSerdes, int keyFieldCount, Iterator<CheckTuple> checkIter) throws Exception { int actualCount = 0; while (cursor.hasNext()) { cursor.next(); ITupleReference tuple = cursor.getTuple(); RTreeCheckTuple checkTuple = (RTreeCheckTuple) createCheckTupleFromTuple(tuple, fieldSerdes, keyFieldCount); if (!checkTuples.contains(checkTuple)) { fail("Scan or range search returned unexpected answer: " + checkTuple.toString()); } actualCount++; } if (actualCount < checkTuples.size()) { fail("Scan or range search returned fewer answers than expected.\nExpected: " + checkTuples.size() + "\nActual : " + actualCount); } if (actualCount > checkTuples.size()) { fail("Scan or range search returned more answers than expected.\nExpected: " + checkTuples.size() + "\nActual : " + actualCount); } }
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 boolean nextValidTuple() throws HyracksDataException { while (currentCursor.hasNext()) { currentCursor.next(); currentTuple = currentCursor.getTuple(); resultOfSearchCallBackProceed = includeMemoryComponents && accessorIndex == 0 ? searchCallback.proceed(currentTuple) : true; if (!resultOfSearchCallBackProceed) { // We assume that the underlying cursors materialize their results such that // there is no need to reposition the result cursor after reconciliation. searchCallback.reconcile(currentTuple); } if (!isDeleted(currentTuple)) { tupleConsumed = false; return true; } else if (!resultOfSearchCallBackProceed) { // reconcile & tuple deleted case: needs to cancel the effect of reconcile(). searchCallback.cancel(currentTuple); } } return false; }
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()); } } }
@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 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); }
@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); }
@Test public void testNextAfterDestroyFails() 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.next(); } 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); }