@Override public boolean isValid() { return this.iterator.isValid(); }
@Override public boolean hasNext() { return iter.isValid(); }
@Override public boolean hasNext() { return this.innerIterator.isValid(); }
@Override public boolean hasNext() { boolean valid = rocksIterator.isValid(); if (!valid) { rocksIterator.close(); } return valid; }
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 ByteArray next() { if(!this.innerIterator.isValid()) { throw new NoSuchElementException("Iterate to end"); } byte[] keyEntry = this.innerIterator.key(); this.innerIterator.next(); if (RocksDbStorageEngine.this.isPartitionScanSupported()) { keyEntry = StoreBinaryFormat.extractKey(keyEntry); } return new ByteArray(keyEntry); }
@Override public boolean hasChildren(InodeDirectoryView inode) { RocksIterator iter = mDb.newIterator(mEdgesColumn, mReadPrefixSameAsStart); iter.seek(Longs.toByteArray(inode.getId())); return iter.isValid(); }
@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()) { MutableInode<?> inode; try { RocksIterator edgeIter = mDb.newIterator(mEdgesColumn); edgeIter.seekToFirst(); while (edgeIter.isValid()) { byte[] key = edgeIter.key(); byte[] id = new byte[Longs.BYTES];
private boolean fetchnextKey() { if(this.innerIterator.isValid()) { byte[] keyEntry = this.innerIterator.key(); // Check if the next key returned starts with the expected // prefix if(StoreBinaryFormat.extractPartition(keyEntry) != partitionId) { return false; } this.innerIterator.next(); cache = new ByteArray(StoreBinaryFormat.extractKey(keyEntry)); return true; } return false; }
@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(); } } }
protected boolean makeMore() { if(innerIterator.isValid()) { byte[] keyEntry = innerIterator.key(); byte[] valueEntry = innerIterator.value(); innerIterator.next(); if (RocksDbStorageEngine.this.isPartitionScanSupported()) { keyEntry = StoreBinaryFormat.extractKey(keyEntry); } ByteArray key = new ByteArray(keyEntry); for(Versioned<byte[]> val: StoreBinaryFormat.fromByteArray(valueEntry)) { cache.add(new Pair<ByteArray, Versioned<byte[]>>(key, val)); } return true; } return false; }
protected boolean makeMore() { if(innerIterator.isValid()) { byte[] keyEntry = innerIterator.key(); // Check if the next key returned starts with the expected // prefix if(StoreBinaryFormat.extractPartition(keyEntry) != partitionId) { return false; } byte[] valueEntry = innerIterator.value(); innerIterator.next(); ByteArray key = new ByteArray(StoreBinaryFormat.extractKey(keyEntry)); for(Versioned<byte[]> val: StoreBinaryFormat.fromByteArray(valueEntry)) { cache.add(new Pair<ByteArray, Versioned<byte[]>>(key, val)); } return true; } return false; }
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; } } } }