@Override public Cell next() throws IOException { return delegate.next(); }
@Override public Cell next() throws IOException { if(this.current == null) { return null; } Cell kvReturn = this.current.next(); Cell kvNext = this.current.peek(); if (kvNext == null) { this.scannersForDelayedClose.add(this.current); this.current = null; this.current = pollRealKV(); } else { KeyValueScanner topScanner = this.heap.peek(); // no need to add current back to the heap if it is the only scanner left if (topScanner != null && this.comparator.compare(kvNext, topScanner.peek()) >= 0) { this.heap.add(this.current); this.current = null; this.current = pollRealKV(); } } return kvReturn; }
@Override public Cell next() throws IOException { if (this.current == null) { return null; } Cell kvReturn = this.current.next(); Cell kvNext = this.current.peek(); if (kvNext == null || this.comparator.kvComparator.compareRows(kvNext, kvReturn) > 0) { if (this.current.seekToPreviousRow(kvReturn)) { this.heap.add(this.current); } else { this.scannersForDelayedClose.add(this.current); } this.current = null; this.current = pollRealKV(); } else { KeyValueScanner topScanner = this.heap.peek(); if (topScanner != null && this.comparator.compare(this.current, topScanner) > 0) { this.heap.add(this.current); this.current = null; this.current = pollRealKV(); } } return kvReturn; }
static void doScan(MemStore ms, int iteration) throws IOException { long nanos = System.nanoTime(); KeyValueScanner s = ms.getScanners(0).get(0); s.seek(KeyValueUtil.createFirstOnRow(new byte[]{})); System.out.println(iteration + " create/seek took: " + (System.nanoTime() - nanos)/1000); int cnt=0; while(s.next() != null) ++cnt; System.out.println(iteration + " took usec: " + (System.nanoTime() - nanos) / 1000 + " for: " + cnt); }
protected void verifyScanAcrossSnapshot2(KeyValue kv1, KeyValue kv2) throws IOException { List<KeyValueScanner> memstorescanners = this.memstore.getScanners(mvcc.getReadPoint()); assertEquals(2, memstorescanners.size()); final KeyValueScanner scanner0 = memstorescanners.get(0); final KeyValueScanner scanner1 = memstorescanners.get(1); scanner0.seek(KeyValueUtil.createFirstOnRow(HConstants.EMPTY_START_ROW)); scanner1.seek(KeyValueUtil.createFirstOnRow(HConstants.EMPTY_START_ROW)); Cell n0 = scanner0.next(); Cell n1 = scanner1.next(); assertTrue(kv1.equals(n0) || kv1.equals(n1)); assertTrue(kv2.equals(n0) || kv2.equals(n1) || kv2.equals(scanner0.next()) || kv2.equals(scanner1.next())); assertNull(scanner0.next()); assertNull(scanner1.next()); }
Cell prev = null; try { while ((curCell = segmentScanner.next()) != null) { cells[idx++] = curCell; if(action == MemStoreCompactionStrategy.Action.FLATTEN_COUNT_UNIQUE_KEYS) {
@Test public void testCountOfCellsAfterFlatteningByScan() throws IOException { String[] keys1 = { "A", "B", "C" }; // A, B, C addRowsByKeysWith50Cols(memstore, keys1); // this should only flatten as there are no duplicates ((CompactingMemStore) memstore).flushInMemory(); while (((CompactingMemStore) memstore).isMemStoreFlushingInMemory()) { Threads.sleep(10); } List<KeyValueScanner> scanners = memstore.getScanners(Long.MAX_VALUE); // seek int count = 0; for(int i = 0; i < scanners.size(); i++) { scanners.get(i).seek(KeyValue.LOWESTKEY); while (scanners.get(i).next() != null) { count++; } } assertEquals("the count should be ", 150, count); for(int i = 0; i < scanners.size(); i++) { scanners.get(i).close(); } }
Cell prev = null; try { while ((curCell = segmentScanner.next()) != null) { assert(curCell instanceof ExtendedCell); if (((ExtendedCell)curCell).getChunkId() == ExtendedCell.CELL_NOT_BASED_ON_CHUNK) {
protected void assertScannerResults(KeyValueScanner scanner, KeyValue[] expected) throws IOException { scanner.seek(KeyValueUtil.createFirstOnRow(new byte[]{})); List<Cell> returned = Lists.newArrayList(); while (true) { Cell next = scanner.next(); if (next == null) break; returned.add(next); } assertTrue( "Got:\n" + Joiner.on("\n").join(returned) + "\nExpected:\n" + Joiner.on("\n").join(expected), Iterables.elementsEqual(Arrays.asList(expected), returned)); assertNull(scanner.peek()); }
private void internalRun() throws IOException { for (long i = 0; i < NUM_TRIES && caughtException.get() == null; i++) { MultiVersionConcurrencyControl.WriteEntry w = mvcc.begin(); // Insert the sequence value (i) byte[] v = Bytes.toBytes(i); KeyValue kv = new KeyValue(row, f, q1, i, v); kv.setSequenceId(w.getWriteNumber()); memstore.add(kv, null); mvcc.completeAndWait(w); // Assert that we can read back KeyValueScanner s = this.memstore.getScanners(mvcc.getReadPoint()).get(0); s.seek(kv); Cell ret = s.next(); assertNotNull("Didnt find own write at all", ret); assertEquals("Didnt read own writes", kv.getTimestamp(), ret.getTimestamp()); } } }
assertTrue(scan.seek(kv)); assertEquals(kvs[0], scan.peek()); assertEquals(kvs[0], scan.next()); assertEquals(kvs[1], scan.peek()); assertEquals(kvs[1], scan.next()); assertEquals(kvs[2], scan.peek()); assertEquals(kvs[2], scan.next()); assertEquals(null, scan.peek()); assertEquals(null, scan.next());
/** * Same a {@link KeyValueScanner#next()} except that we filter out the next {@link KeyValue} until we find one that * passes the filter. * * @return the next {@link KeyValue} or <tt>null</tt> if no next {@link KeyValue} is present and passes all the * filters. */ @Override public KeyValue next() throws IOException { seekToNextUnfilteredKeyValue(); return delegate.next(); }
while ((currentKV = KeyValueUtil.ensureKeyValue(scanner.next())) != null && j < kvLimit) {
public Result getCurrentRowState() { KeyValueScanner scanner = this.memstore.getScanner(); List<KeyValue> kvs = new ArrayList<KeyValue>(); while (scanner.peek() != null) { try { kvs.add(scanner.next()); } catch (IOException e) { // this should never happen - something has gone terribly arwy if it has throw new RuntimeException("Local MemStore threw IOException!"); } } return new Result(kvs); }
while ((currentKv = KeyValueUtil.ensureKeyValue(scanner.next())) != null && j < kvLimit) {
private boolean seekToNextUnfilteredKeyValue() throws IOException { while (true) { KeyValue peeked = delegate.peek(); // no more key values, so we are done if (peeked == null) { return false; } // filter the peeked value to see if it should be served ReturnCode code = filter.filterKeyValue(peeked); switch (code) { // included, so we are done case INCLUDE: case INCLUDE_AND_NEXT_COL: return true; // not included, so we need to go to the next row case SKIP: case NEXT_COL: case NEXT_ROW: delegate.next(); break; // use a seek hint to find out where we should go case SEEK_NEXT_USING_HINT: delegate.seek(filter.getNextKeyHint(peeked)); } } }
KeyValue first = KeyValue.createFirstOnRow(row); assertTrue("Didn't have any data in the scanner", scanner.seek(first)); assertTrue("Didn't get delete family first (no qualifier == sort first)", df == scanner.next()); assertTrue("Didn't get point delete before corresponding put", d == scanner.next()); assertTrue("Didn't get larger ts Put", kv == scanner.next()); assertTrue("Didn't get delete column before corresponding put(delete sorts first)", dc == scanner.next()); assertTrue("Didn't get smaller ts Put", kv2 == scanner.next()); assertNull("Have more data in the scanner", scanner.next());
@Test public void testCorrectOverwritting() throws Exception { IndexMemStore store = new IndexMemStore(IndexMemStore.COMPARATOR); long ts = 10; KeyValue kv = new KeyValue(row, family, qual, ts, Type.Put, val); kv.setMemstoreTS(2); KeyValue kv2 = new KeyValue(row, family, qual, ts, Type.Put, val2); kv2.setMemstoreTS(0); store.add(kv, true); // adding the exact same kv shouldn't change anything stored if not overwritting store.add(kv2, false); KeyValueScanner scanner = store.getScanner(); KeyValue first = KeyValue.createFirstOnRow(row); scanner.seek(first); assertTrue("Overwrote kv when specifically not!", kv == scanner.next()); scanner.close(); // now when we overwrite, we should get the newer one store.add(kv2, true); scanner = store.getScanner(); scanner.seek(first); assertTrue("Didn't overwrite kv when specifically requested!", kv2 == scanner.next()); scanner.close(); }
static void doScan(MemStore ms, int iteration) throws IOException { long nanos = System.nanoTime(); KeyValueScanner s = ms.getScanners(0).get(0); s.seek(KeyValueUtil.createFirstOnRow(new byte[]{})); System.out.println(iteration + " create/seek took: " + (System.nanoTime() - nanos)/1000); int cnt=0; while(s.next() != null) ++cnt; System.out.println(iteration + " took usec: " + (System.nanoTime() - nanos) / 1000 + " for: " + cnt); }