@Override public void process() { try { scanner.seek(keyValue); } catch (IOException e) { LOG.error("", e); setErr(e); } finally { latch.countDown(); } }
@Override public boolean seek(Cell key) throws IOException { return delegate.seek(key); }
public static boolean doRealSeek(KeyValueScanner scanner, Cell kv, boolean forward) throws IOException { return forward ? scanner.reseek(kv) : scanner.seek(kv); }
handlers.add(seekHandler); } else { scanner.seek(kv); latch.countDown();
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); }
+ ", but row is bigger than that"); scanner.seek(seekKey); Cell c = scanner.peek(); if (c != null) {
@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(); } }
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()); } } }
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()); }
assertNotNull(inStream); scanner.seek(KeyValue.LOWESTKEY);
scanner.seek(KeyValue.LOWESTKEY);
@Override public boolean seek(KeyValue key) throws IOException { if (filter.filterAllRemaining()) { return false; } // see if we can seek to the next key if (!delegate.seek(key)) { return false; } return seekToNextUnfilteredKeyValue(); }
KeyValue currentKv; scanner.seek(KeyValue.LOWESTKEY); List<Iterator<Cell>> codecIterators = new ArrayList<>(); for(EncodedDataBlock codec : codecs) {
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)); } } }
@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(); }
@Override public void process() { try { scanner.seek(keyValue); } catch (IOException e) { LOG.error("", e); setErr(e); } finally { latch.countDown(); } }
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); }
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());