public RocksdbKeysIterator(RocksIterator innerIterator) { this.innerIterator = innerIterator; // Caller of the RocksIterator should seek it before the first use. this.innerIterator.seekToFirst(); }
public RocksdbEntriesIterator(RocksIterator innerIterator) { this.innerIterator = innerIterator; // Caller of the RocksIterator should seek it before the first use. this.innerIterator.seekToFirst(); cache = new ArrayList<Pair<ByteArray, Versioned<byte[]>>>(); }
@Override public void seekToFirst() { iterator.seekToFirst(); status(); }
@Override public void seekToLast() { iterator.seekToFirst(); status(); }
private static int getStartValue(RocksDB db, ColumnFamilyHandle handler) { int startValue = 0; SortedMap<Integer, Integer> values = new TreeMap<Integer, Integer>(); RocksIterator itr = db.newIterator(handler); itr.seekToFirst(); while(itr.isValid()) { Integer key = Integer.valueOf(new String(itr.key())); Integer value = Integer.valueOf(new String(itr.value())); values.put(key, value); itr.next(); } LOG.info("Load previous db: size={}, values={}", values.size(), values); if (!values.isEmpty()) { Integer key = values.lastKey(); startValue = values.get(key); startValue++; } LOG.info("Start value={}", startValue); return startValue; }
@Override public Set<byte[]> keys() throws RuntimeException { resetDbLock.readLock().lock(); try { if (logger.isTraceEnabled()) logger.trace("~> RocksDbDataSource.keys(): " + name); try (RocksIterator iterator = db.newIterator()) { Set<byte[]> result = new HashSet<>(); for (iterator.seekToFirst(); iterator.isValid(); iterator.next()) { result.add(iterator.key()); } if (logger.isTraceEnabled()) logger.trace("<~ RocksDbDataSource.keys(): " + name + ", " + result.size()); return result; } catch (Exception e) { logger.error("Error iterating db '{}'", name, e); hintOnTooManyOpenFiles(e); throw new RuntimeException(e); } } finally { resetDbLock.readLock().unlock(); } }
@Override public Set<MutableInode<?>> allInodes() { Set<MutableInode<?>> inodes = new HashSet<>(); RocksIterator iter = mDb.newIterator(mInodesColumn); iter.seekToFirst(); while (iter.isValid()) { inodes.add(getMutable(Longs.fromByteArray(iter.key())).get()); iter.next(); } return inodes; }
@Override public Collection<K> listKeys() { Collection<K> keys = new ArrayList<>(); RocksIterator itr = rocksDb.newIterator(columnFamily); itr.seekToFirst(); while (itr.isValid()) { keys.add((K) serializer.deserialize(itr.key())); itr.next(); } return keys; }
@Override public Iterator<String[]> iterator() { final RocksIterator rocksIterator = getRocksIterator(); rocksIterator.seekToFirst(); return new Iterator<String[]>() { int counter; @Override public boolean hasNext() { boolean valid = rocksIterator.isValid(); if (!valid) { rocksIterator.close(); } return valid; } @Override public String[] next() { counter++; if (counter % 100000 == 0) { logger.info("scanned {} rows from rocksDB", counter); } String[] result = rowEncoder.decode(new KV(rocksIterator.key(), rocksIterator.value())); rocksIterator.next(); return result; } @Override public void remove() { throw new UnsupportedOperationException("not support operation"); } }; }
@Override public Iterator<Block> iterator() { RocksIterator iter = mDb.newIterator(mBlockMetaColumn, new ReadOptions().setPrefixSameAsStart(true)); iter.seekToFirst(); return new Iterator<Block>() { @Override public boolean hasNext() { return iter.isValid(); } @Override public Block next() { try { return new Block(Longs.fromByteArray(iter.key()), BlockMeta.parseFrom(iter.value())); } catch (Exception e) { throw new RuntimeException(e); } finally { iter.next(); } } }; }
@Override public Set<EdgeEntry> allEdges() { Set<EdgeEntry> edges = new HashSet<>(); RocksIterator iter = mDb.newIterator(mEdgesColumn); iter.seekToFirst(); while (iter.isValid()) { long parentId = RocksUtils.readLong(iter.key(), 0); String childName = new String(iter.key(), Longs.BYTES, iter.key().length - Longs.BYTES); long childId = Longs.fromByteArray(iter.value()); edges.add(new EdgeEntry(parentId, childName, childId)); iter.next(); } return edges; }
StringBuilder sb = new StringBuilder(); RocksIterator inodeIter = mDb.newIterator(mInodesColumn); inodeIter.seekToFirst(); while (inodeIter.isValid()) { MutableInode<?> inode; edgeIter.seekToFirst(); while (edgeIter.isValid()) { byte[] key = edgeIter.key();
@Override public <T> List<Pair<String, T>> fetchTop(int size, Type type) throws FailStoreException { RocksIterator iterator = null; try { List<Pair<String, T>> list = new ArrayList<Pair<String, T>>(size); iterator = db.newIterator(); for (iterator.seekToFirst(); iterator.isValid(); iterator.next()) { iterator.status(); String key = new String(iterator.key(), "UTF-8"); T value = JSON.parse(new String(iterator.value(), "UTF-8"), type); Pair<String, T> pair = new Pair<String, T>(key, value); list.add(pair); if (list.size() >= size) { break; } } return list; } catch (Exception e) { throw new FailStoreException(e); } finally { if (iterator != null) { iterator.dispose(); } } }
@Override public <T> List<Pair<String, T>> fetchTop(int size, Type type) throws FailStoreException { RocksIterator iterator = null; try { List<Pair<String, T>> list = new ArrayList<Pair<String, T>>(size); iterator = db.newIterator(); for (iterator.seekToFirst(); iterator.isValid(); iterator.next()) { iterator.status(); String key = new String(iterator.key(), "UTF-8"); T value = JSON.parse(new String(iterator.value(), "UTF-8"), type); Pair<String, T> pair = new Pair<String, T>(key, value); list.add(pair); if (list.size() >= size) { break; } } return list; } catch (Exception e) { throw new FailStoreException(e); } finally { if (iterator != null) { iterator.dispose(); } } }
private void seek() { if (this.keyBegin == null) { // Seek to the first if no `keyBegin` this.itor.seekToFirst(); } else { /* * Seek to `keyBegin`: * if set SCAN_GT_BEGIN/SCAN_GTE_BEGIN (key > / >= 'xx') * or if set SCAN_PREFIX_WITH_BEGIN (key prefix with 'xx') */ this.itor.seek(this.keyBegin); // Skip `keyBegin` if set SCAN_GT_BEGIN (key > 'xx') if (this.match(Session.SCAN_GT_BEGIN) && !this.match(Session.SCAN_GTE_BEGIN)) { while (this.itor.isValid() && Bytes.equals(this.itor.key(), this.keyBegin)) { this.itor.next(); } } } }
@Override public void seekToLast() { iterator.seekToFirst(); status(); }
public CloseableIterator<GeoWaveMetadata> iterator() { final RocksIterator it = db.newIterator(); it.seekToFirst(); return new RocksDBMetadataIterator(it, requiresTimestamp, visibilityEnabled); }
@Override public synchronized KeyValueIterator<Bytes, byte[]> all() { validateStoreOpen(); // query rocksdb final RocksIterator innerIter = db.newIterator(); innerIter.seekToFirst(); final RocksDbIterator rocksDbIterator = new RocksDbIterator(name, innerIter); openIterators.add(rocksDbIterator); return rocksDbIterator; }
public RocksDBIterator(RocksDB db) { this.db = db; this.cursor = db.newIterator(); this.cursor.seekToFirst(); this.isOpen = true; readNextKV(true); }
RangeIterator(ColumnFamily table, RocksIterator it, RangeRequest range, long maxTimestamp) { this.table = table; this.it = it; this.request = range; this.maxTimestamp = maxTimestamp; byte[] start = range.getStartInclusive(); if (start.length == 0) { it.seekToFirst(); } else { it.seek(RocksDbKeyValueServices.getKey(start, maxTimestamp - 1)); } }