private RocksIterator getRocksIterator() { return rocksDB.newIterator(); }
static RocksIteratorWrapper getRocksIterator( RocksDB db, ColumnFamilyHandle columnFamilyHandle) { return new RocksIteratorWrapper(db.newIterator(columnFamilyHandle)); }
public static RocksIteratorWrapper getRocksIterator(RocksDB db) { return new RocksIteratorWrapper(db.newIterator()); }
protected RocksIterator getRocksDbIterator() { return this.getRocksDB().newIterator(storeHandle); }
@SuppressWarnings("unchecked") private static RocksIteratorWrapper getRocksIterator( RocksDB db, ColumnFamilyHandle columnFamilyHandle, StateSnapshotTransformer<byte[]> stateSnapshotTransformer, ReadOptions readOptions) { RocksIterator rocksIterator = db.newIterator(columnFamilyHandle, readOptions); return stateSnapshotTransformer == null ? new RocksIteratorWrapper(rocksIterator) : new RocksTransformingIteratorWrapper(rocksIterator, stateSnapshotTransformer); }
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; }
@Nonnull private RocksBytesIterator orderedBytesIterator() { flushWriteBatch(); return new RocksBytesIterator( new RocksIteratorWrapper( db.newIterator(columnFamilyHandle))); }
@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 Iterable<Long> getChildIds(Long inodeId) { RocksIterator iter = mDb.newIterator(mEdgesColumn, mReadPrefixSameAsStart); iter.seek(Longs.toByteArray(inodeId)); return () -> new Iterator<Long>() { @Override public boolean hasNext() { return iter.isValid(); } @Override public Long next() { try { return Longs.fromByteArray(iter.value()); } catch (Exception e) { throw new RuntimeException(e); } finally { iter.next(); } } }; }
@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 boolean hasChildren(InodeDirectoryView inode) { RocksIterator iter = mDb.newIterator(mEdgesColumn, mReadPrefixSameAsStart); iter.seek(Longs.toByteArray(inode.getId())); return iter.isValid(); }
@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 List<BlockLocation> getLocations(long id) { RocksIterator iter = mDb.newIterator(mBlockLocationsColumn, new ReadOptions().setPrefixSameAsStart(true)); iter.seek(Longs.toByteArray(id)); List<BlockLocation> locations = new ArrayList<>(); for (; iter.isValid(); iter.next()) { try { locations.add(BlockLocation.parseFrom(iter.value())); } catch (Exception e) { throw new RuntimeException(e); } } return locations; }
@Override public Status scan(final String table, final String startkey, final int recordcount, final Set<String> fields, final Vector<HashMap<String, ByteIterator>> result) { try { if (!COLUMN_FAMILIES.containsKey(table)) { createColumnFamily(table); } final ColumnFamilyHandle cf = COLUMN_FAMILIES.get(table).getHandle(); try(final RocksIterator iterator = rocksDb.newIterator(cf)) { int iterations = 0; for (iterator.seek(startkey.getBytes(UTF_8)); iterator.isValid() && iterations < recordcount; iterator.next()) { final HashMap<String, ByteIterator> values = new HashMap<>(); deserializeValues(iterator.value(), fields, values); result.add(values); iterations++; } } return Status.OK; } catch(final RocksDBException e) { LOGGER.error(e.getMessage(), e); return Status.ERROR; } }
@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; }
RocksIterator inodeIter = mDb.newIterator(mInodesColumn); inodeIter.seekToFirst(); while (inodeIter.isValid()) { RocksIterator edgeIter = mDb.newIterator(mEdgesColumn); edgeIter.seekToFirst(); while (edgeIter.isValid()) {
@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(); } } }
void scanRange(RocksDbKey start, RocksDbKey end, RocksDbScanCallback fn) { try (ReadOptions ro = new ReadOptions()) { ro.setTotalOrderSeek(true); RocksIterator iterator = db.newIterator(ro); for (iterator.seek(start.getRaw()); iterator.isValid(); iterator.next()) { RocksDbKey key = new RocksDbKey(iterator.key()); if (key.compareTo(end) >= 0) { // past limit, quit return; } RocksDbValue val = new RocksDbValue(iterator.value()); if (!fn.cb(key, val)) { // if cb returns false, we are done with this section of rows return; } } } }