org.rocksdb.RocksIterator

Here are the examples of the java api org.rocksdb.RocksIterator taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

106 Examples 7

19 Source : RocksdbBOEntityIterator.java
with Apache License 2.0
from zhugf

public clreplaced RocksdbBOEnreplacedyIterator extends AbsBOEnreplacedyIterator implements BOEnreplacedyIterator {

    private RocksIterator rocksIterator;

    public RocksdbBOEnreplacedyIterator(BORepository repository, AbsBOEnreplacedy boEnreplacedy, RocksIterator rocksIterator) {
        super(repository, boEnreplacedy);
        this.rocksIterator = rocksIterator;
    }

    public boolean hasNext() {
        return rocksIterator.isValid();
    }

    public String next() {
        rocksIterator.next();
        if (rocksIterator.isValid()) {
            lastId = new String(rocksIterator.key(), StringUtil.UTF8);
        }
        return lastId;
    }

    public String getData() {
        return new String(rocksIterator.value(), StringUtil.UTF8);
    }

    @Override
    public void close() {
        rocksIterator.close();
    }
}

19 Source : RockDBIterator.java
with GNU Lesser General Public License v3.0
from vision-consensus

public clreplaced RockDBIterator implements DBIterator {

    private RocksIterator iterator;

    public RockDBIterator(RocksIterator iterator) {
        this.iterator = iterator;
    }

    @Override
    public void seek(byte[] key) {
        iterator.seek(key);
    }

    @Override
    public void seekToFirst() {
        iterator.seekToFirst();
    }

    @Override
    public boolean hasNext() {
        return iterator.isValid();
    }

    @Override
    public byte[] getKey() {
        return iterator.key();
    }

    @Override
    public byte[] getValue() {
        return iterator.value();
    }

    @Override
    public void next() {
        iterator.next();
    }

    @Override
    public void close() throws IOException {
        iterator.close();
    }
}

19 Source : RocksDBLogStorage.java
with Apache License 2.0
from sofastack

@Override
public long getFirstLogIndex() {
    this.readLock.lock();
    RocksIterator it = null;
    try {
        if (this.hasLoadFirstLogIndex) {
            return this.firstLogIndex;
        }
        checkState();
        it = this.db.newIterator(this.defaultHandle, this.totalOrderReadOptions);
        it.seekToFirst();
        if (it.isValid()) {
            final long ret = Bits.getLong(it.key(), 0);
            saveFirstLogIndex(ret);
            setFirstLogIndex(ret);
            return ret;
        }
        return 1L;
    } finally {
        if (it != null) {
            it.close();
        }
        this.readLock.unlock();
    }
}

19 Source : RocksIteratorWrapper.java
with Apache License 2.0
from ljygz

/**
 * This is a wrapper around {@link RocksIterator} to check the iterator status for all the methods mentioned
 * to require this check in the wiki doreplacedentation: seek, next, seekToFirst, seekToLast, seekForPrev, and prev.
 * This is required because the iterator may preplaced the blocks or files it had difficulties in reading (because
 * of IO error, data corruption or other issues) and continue with the next available keys. The status flag may not be
 * OK, even if the iterator is valid. More information can be found
 * <a href="https://github.com/facebook/rocksdb/wiki/Iterator#error-handling">here</a>.
 */
public clreplaced RocksIteratorWrapper implements RocksIteratorInterface, Closeable {

    private RocksIterator iterator;

    public RocksIteratorWrapper(@Nonnull RocksIterator iterator) {
        this.iterator = iterator;
    }

    @Override
    public boolean isValid() {
        return this.iterator.isValid();
    }

    @Override
    public void seekToFirst() {
        iterator.seekToFirst();
        status();
    }

    @Override
    public void seekToLast() {
        iterator.seekToFirst();
        status();
    }

    @Override
    public void seek(byte[] target) {
        iterator.seek(target);
        status();
    }

    @Override
    public void seekForPrev(byte[] target) {
        iterator.seekForPrev(target);
        status();
    }

    @Override
    public void next() {
        iterator.next();
        status();
    }

    @Override
    public void prev() {
        iterator.prev();
        status();
    }

    @Override
    public void status() {
        try {
            iterator.status();
        } catch (RocksDBException ex) {
            throw new FlinkRuntimeException("Internal exception found in RocksDB", ex);
        }
    }

    public byte[] key() {
        return iterator.key();
    }

    public byte[] value() {
        return iterator.value();
    }

    @Override
    public void close() {
        iterator.close();
    }
}

19 Source : RocksDBColumnarKeyValueStorage.java
with Apache License 2.0
from hyperledger

@Override
public void clear(final ColumnFamilyHandle segmentHandle) {
    try (final RocksIterator rocksIterator = db.newIterator(segmentHandle)) {
        rocksIterator.seekToFirst();
        if (rocksIterator.isValid()) {
            final byte[] firstKey = rocksIterator.key();
            rocksIterator.seekToLast();
            if (rocksIterator.isValid()) {
                final byte[] lastKey = rocksIterator.key();
                db.deleteRange(segmentHandle, firstKey, lastKey);
                db.delete(segmentHandle, lastKey);
            }
        }
    } catch (final RocksDBException e) {
        throw new StorageException(e);
    }
}

19 Source : RocksDBColumnarKeyValueStorage.java
with Apache License 2.0
from hyperledger

@Override
public Stream<byte[]> streamKeys(final ColumnFamilyHandle segmentHandle) {
    final RocksIterator rocksIterator = db.newIterator(segmentHandle);
    rocksIterator.seekToFirst();
    return RocksDbKeyIterator.create(rocksIterator).toStream();
}

19 Source : RocksDbKeyIterator.java
with Apache License 2.0
from hyperledger

public static RocksDbKeyIterator create(final RocksIterator rocksIterator) {
    return new RocksDbKeyIterator(rocksIterator);
}

19 Source : ZSet.java
with Apache License 2.0
from frost373

@Override
public Entry getEntry(RocksIterator iterator) throws KitDBException {
    try (CloseLock ignored = checkClose()) {
        byte[] key_bs = iterator.key();
        if (key_bs == null) {
            return null;
        }
        SData sData = SDataD.build(key_bs).convertValue();
        Entry entry = new Entry(ArrayKits.bytesToLong(iterator.value()), sData.value);
        return entry;
    }
}

19 Source : RSet.java
with Apache License 2.0
from frost373

@Override
public Entry getEntry(RocksIterator iterator) throws KitDBException {
    try (CloseLock ignored = checkClose()) {
        byte[] key_bs = iterator.key();
        if (key_bs == null) {
            return null;
        }
        SData sData = SDataD.build(key_bs).convertValue();
        Entry entry = new Entry(sData.value);
        return entry;
    }
}

19 Source : RMap.java
with Apache License 2.0
from frost373

@Override
public Entry getEntry(RocksIterator iterator) throws KitDBException {
    try (CloseLock ignored = checkClose()) {
        byte[] key_bs = iterator.key();
        if (key_bs == null) {
            return null;
        }
        KeyD keyD = KeyD.build(key_bs);
        Entry entry = new Entry(new String(keyD.key, charset), iterator.value());
        return entry;
    }
}

19 Source : RList.java
with Apache License 2.0
from frost373

public Entry getEntry(RocksIterator iterator) throws KitDBException {
    try (CloseLock ignored = checkClose()) {
        byte[] key_bs = iterator.key();
        if (key_bs == null) {
            return null;
        }
        ValueK key = ValueKD.build(key_bs).convertValue();
        Entry entry = new Entry(key.index, iterator.value());
        return entry;
    }
}

19 Source : RIterator.java
with Apache License 2.0
from frost373

public clreplaced RIterator<R extends RCollection> implements AutoCloseable {

    private final RocksIterator iterator;

    private final R rCollection;

    private final byte[] seekHead;

    private boolean finish = false;

    public RIterator(RocksIterator iterator, R rCollection, byte[] seekHead) {
        this.iterator = iterator;
        this.rCollection = rCollection;
        this.seekHead = seekHead;
    }

    public boolean hasNext() {
        if (finish)
            return false;
        byte[] key = iterator.key();
        if (key == null || !BytesUtil.checkHead(seekHead, key)) {
            finish = true;
            return false;
        }
        return iterator.isValid();
    }

    public <E extends REntry> E next() throws KitDBException {
        if (!iterator.isValid())
            return null;
        E entry = rCollection.getEntry(iterator);
        iterator.next();
        return entry;
    }

    @Override
    public void close() {
        if (iterator != null) {
            iterator.close();
        }
    }
}

19 Source : KeyIterator.java
with Apache License 2.0
from frost373

public clreplaced KeyIterator implements AutoCloseable {

    private final RocksIterator iterator;

    private final byte[] seekHead;

    private boolean finish = false;

    private byte[] now;

    private byte[] next;

    public KeyIterator(RocksIterator iterator, byte[] seekHead) {
        this.iterator = iterator;
        this.seekHead = seekHead;
    }

    public boolean hasNext() {
        if (finish)
            return false;
        byte[] key = iterator.key();
        if (key == null || !BytesUtil.checkHead(seekHead, key)) {
            finish = true;
            return false;
        }
        return iterator.isValid();
    }

    public String next() {
        if (!iterator.isValid())
            return null;
        byte[] cKey = iterator.key();
        if (cKey == null) {
            return null;
        }
        iterator.next();
        return new String(ArrayKits.sub(cKey, 1, cKey.length), RBase.charset);
    }

    public byte[] getSeek() {
        return seekHead;
    }

    @Override
    public void close() {
        if (iterator != null) {
            iterator.close();
        }
    }
}

19 Source : Collection.java
with GNU General Public License v3.0
from coti-io

private T getDeserializedValue(RocksIterator iterator) {
    return getDeserializedValue(new Hash(iterator.key()), iterator.value());
}

19 Source : RocksDbIterator.java
with Apache License 2.0
from ConsenSys

@MustBeClosed
public static <K, V> RocksDbIterator<K, V> create(final RocksDbColumn<K, V> column, final RocksIterator rocksIt, final Predicate<K> continueTest, final Supplier<Boolean> isDatabaseClosed) {
    return new RocksDbIterator<>(column, rocksIt, continueTest, isDatabaseClosed);
}

19 Source : TestRDBStoreIterator.java
with Apache License 2.0
from apache

/**
 * This test prescribe expected behaviour from the RDBStoreIterator which wraps
 * RocksDB's own iterator. Ozone internally in TypedTableIterator uses, the
 * RDBStoreIterator to provide iteration over table elements in a typed manner.
 * The tests are to ensure we access RocksDB via the iterator properly.
 */
public clreplaced TestRDBStoreIterator {

    private RocksIterator rocksDBIteratorMock;

    private RDBTable rocksTableMock;

    @Before
    public void setup() {
        rocksDBIteratorMock = mock(RocksIterator.clreplaced);
        rocksTableMock = mock(RDBTable.clreplaced);
    }

    @Test
    public void testForeachRemainingCallsConsumerWithAllElements() {
        when(rocksDBIteratorMock.isValid()).thenReturn(true, true, true, true, true, true, true, false);
        when(rocksDBIteratorMock.key()).thenReturn(new byte[] { 0x00 }, new byte[] { 0x00 }, new byte[] { 0x01 }, new byte[] { 0x02 }).thenThrow(new NoSuchElementException());
        when(rocksDBIteratorMock.value()).thenReturn(new byte[] { 0x7f }, new byte[] { 0x7f }, new byte[] { 0x7e }, new byte[] { 0x7d }).thenThrow(new NoSuchElementException());
        Consumer<ByteArrayKeyValue> consumerStub = mock(Consumer.clreplaced);
        RDBStoreIterator iter = new RDBStoreIterator(rocksDBIteratorMock);
        iter.forEachRemaining(consumerStub);
        ArgumentCaptor<ByteArrayKeyValue> capture = ArgumentCaptor.forClreplaced(ByteArrayKeyValue.clreplaced);
        verify(consumerStub, times(3)).accept(capture.capture());
        replacedertArrayEquals(new byte[] { 0x00 }, capture.getAllValues().get(0).getKey());
        replacedertArrayEquals(new byte[] { 0x7f }, capture.getAllValues().get(0).getValue());
        replacedertArrayEquals(new byte[] { 0x01 }, capture.getAllValues().get(1).getKey());
        replacedertArrayEquals(new byte[] { 0x7e }, capture.getAllValues().get(1).getValue());
        replacedertArrayEquals(new byte[] { 0x02 }, capture.getAllValues().get(2).getKey());
        replacedertArrayEquals(new byte[] { 0x7d }, capture.getAllValues().get(2).getValue());
    }

    @Test
    public void testHasNextDependsOnIsvalid() {
        when(rocksDBIteratorMock.isValid()).thenReturn(true, true, false);
        RDBStoreIterator iter = new RDBStoreIterator(rocksDBIteratorMock);
        replacedertTrue(iter.hasNext());
        replacedertFalse(iter.hasNext());
    }

    @Test
    public void testNextCallsIsValidThenGetsTheValueAndStepsToNext() {
        when(rocksDBIteratorMock.isValid()).thenReturn(true);
        RDBStoreIterator iter = new RDBStoreIterator(rocksDBIteratorMock);
        InOrder verifier = inOrder(rocksDBIteratorMock);
        iter.next();
        verifier.verify(rocksDBIteratorMock).isValid();
        verifier.verify(rocksDBIteratorMock).key();
        verifier.verify(rocksDBIteratorMock).value();
        verifier.verify(rocksDBIteratorMock).next();
    }

    @Test
    public void testConstructorSeeksToFirstElement() {
        new RDBStoreIterator(rocksDBIteratorMock);
        verify(rocksDBIteratorMock, times(1)).seekToFirst();
    }

    @Test
    public void testSeekToFirstSeeks() {
        RDBStoreIterator iter = new RDBStoreIterator(rocksDBIteratorMock);
        iter.seekToFirst();
        verify(rocksDBIteratorMock, times(2)).seekToFirst();
    }

    @Test
    public void testSeekToLastSeeks() {
        RDBStoreIterator iter = new RDBStoreIterator(rocksDBIteratorMock);
        iter.seekToLast();
        verify(rocksDBIteratorMock, times(1)).seekToLast();
    }

    @Test
    public void testSeekReturnsTheActualKey() {
        when(rocksDBIteratorMock.isValid()).thenReturn(true);
        when(rocksDBIteratorMock.key()).thenReturn(new byte[] { 0x00 });
        when(rocksDBIteratorMock.value()).thenReturn(new byte[] { 0x7f });
        RDBStoreIterator iter = new RDBStoreIterator(rocksDBIteratorMock);
        ByteArrayKeyValue val = iter.seek(new byte[] { 0x55 });
        InOrder verifier = inOrder(rocksDBIteratorMock);
        // at construct time
        verify(rocksDBIteratorMock, times(1)).seekToFirst();
        verify(rocksDBIteratorMock, never()).seekToLast();
        verifier.verify(rocksDBIteratorMock, times(1)).seek(any(byte[].clreplaced));
        verifier.verify(rocksDBIteratorMock, times(1)).isValid();
        verifier.verify(rocksDBIteratorMock, times(1)).key();
        verifier.verify(rocksDBIteratorMock, times(1)).value();
        replacedertArrayEquals(new byte[] { 0x00 }, val.getKey());
        replacedertArrayEquals(new byte[] { 0x7f }, val.getValue());
    }

    @Test
    public void testGettingTheKeyIfIteratorIsValid() {
        when(rocksDBIteratorMock.isValid()).thenReturn(true);
        when(rocksDBIteratorMock.key()).thenReturn(new byte[] { 0x00 });
        RDBStoreIterator iter = new RDBStoreIterator(rocksDBIteratorMock);
        byte[] key = iter.key();
        InOrder verifier = inOrder(rocksDBIteratorMock);
        verifier.verify(rocksDBIteratorMock, times(1)).isValid();
        verifier.verify(rocksDBIteratorMock, times(1)).key();
        replacedertArrayEquals(new byte[] { 0x00 }, key);
    }

    @Test
    public void testGettingTheValueIfIteratorIsValid() {
        when(rocksDBIteratorMock.isValid()).thenReturn(true);
        when(rocksDBIteratorMock.key()).thenReturn(new byte[] { 0x00 });
        when(rocksDBIteratorMock.value()).thenReturn(new byte[] { 0x7f });
        RDBStoreIterator iter = new RDBStoreIterator(rocksDBIteratorMock);
        ByteArrayKeyValue val = iter.value();
        InOrder verifier = inOrder(rocksDBIteratorMock);
        verifier.verify(rocksDBIteratorMock, times(1)).isValid();
        verifier.verify(rocksDBIteratorMock, times(1)).key();
        replacedertArrayEquals(new byte[] { 0x00 }, val.getKey());
        replacedertArrayEquals(new byte[] { 0x7f }, val.getValue());
    }

    @Test
    public void testRemovingFromDBActuallyDeletesFromTable() throws Exception {
        byte[] testKey = new byte[] { 0x00 };
        when(rocksDBIteratorMock.isValid()).thenReturn(true);
        when(rocksDBIteratorMock.key()).thenReturn(testKey);
        RDBStoreIterator iter = new RDBStoreIterator(rocksDBIteratorMock, rocksTableMock);
        iter.removeFromDB();
        InOrder verifier = inOrder(rocksDBIteratorMock, rocksTableMock);
        verifier.verify(rocksDBIteratorMock, times(1)).isValid();
        verifier.verify(rocksTableMock, times(1)).delete(testKey);
    }

    @Test(expected = UnsupportedOperationException.clreplaced)
    public void testRemoveFromDBWithoutDBTableSet() throws Exception {
        RDBStoreIterator iter = new RDBStoreIterator(rocksDBIteratorMock);
        iter.removeFromDB();
    }

    @Test
    public void testCloseCloses() throws Exception {
        RDBStoreIterator iter = new RDBStoreIterator(rocksDBIteratorMock);
        iter.close();
        verify(rocksDBIteratorMock, times(1)).close();
    }
}

19 Source : RocksDBStoreIterator.java
with Apache License 2.0
from apache

/**
 * RocksDB store iterator.
 */
public clreplaced RocksDBStoreIterator implements MetaStoreIterator<MetadataStore.KeyValue> {

    private RocksIterator rocksDBIterator;

    public RocksDBStoreIterator(RocksIterator iterator) {
        this.rocksDBIterator = iterator;
        rocksDBIterator.seekToFirst();
    }

    @Override
    public boolean hasNext() {
        return rocksDBIterator.isValid();
    }

    @Override
    public MetadataStore.KeyValue next() {
        if (rocksDBIterator.isValid()) {
            MetadataStore.KeyValue value = MetadataStore.KeyValue.create(rocksDBIterator.key(), rocksDBIterator.value());
            rocksDBIterator.next();
            return value;
        }
        throw new NoSuchElementException("RocksDB Store has no more elements");
    }

    @Override
    public void seekToFirst() {
        rocksDBIterator.seekToFirst();
    }

    @Override
    public void seekToLast() {
        rocksDBIterator.seekToLast();
    }
}

19 Source : RocksDBStore.java
with Apache License 2.0
from apache

@Override
public ImmutablePair<byte[], byte[]> peekAround(int offset, byte[] from) throws IOException, IllegalArgumentException {
    RocksIterator it = null;
    try {
        it = db.newIterator();
        if (from == null) {
            it.seekToFirst();
        } else {
            it.seek(from);
        }
        if (!it.isValid()) {
            return null;
        }
        switch(offset) {
            case 0:
                break;
            case 1:
                it.next();
                break;
            case -1:
                it.prev();
                break;
            default:
                throw new IllegalArgumentException("Position can only be -1, 0 " + "or 1, but found " + offset);
        }
        return it.isValid() ? new ImmutablePair<>(it.key(), it.value()) : null;
    } finally {
        if (it != null) {
            it.close();
        }
    }
}

19 Source : RocksDBStore.java
with Apache License 2.0
from apache

@Override
public void iterate(byte[] from, EntryConsumer consumer) throws IOException {
    RocksIterator it = null;
    try {
        it = db.newIterator();
        if (from != null) {
            it.seek(from);
        } else {
            it.seekToFirst();
        }
        while (it.isValid()) {
            if (!consumer.consume(it.key(), it.value())) {
                break;
            }
            it.next();
        }
    } finally {
        if (it != null) {
            it.close();
        }
    }
}

19 Source : RocksDBStore.java
with Apache License 2.0
from apache

@Override
public boolean isEmpty() throws IOException {
    RocksIterator it = null;
    try {
        it = db.newIterator();
        it.seekToFirst();
        return !it.isValid();
    } finally {
        if (it != null) {
            it.close();
        }
    }
}

19 Source : RocksDBDAO.java
with Apache License 2.0
from apache

/**
 * Perform a prefix delete and return stream of key-value pairs retrieved.
 *
 * @param columnFamilyName Column Family Name
 * @param prefix Prefix Key
 * @param <T> Type of value stored
 */
public <T extends Serializable> void prefixDelete(String columnFamilyName, String prefix) {
    ValidationUtils.checkArgument(!closed);
    LOG.info("Prefix DELETE (query=" + prefix + ") on " + columnFamilyName);
    final RocksIterator it = getRocksDB().newIterator(managedHandlesMap.get(columnFamilyName));
    it.seek(prefix.getBytes());
    // Find first and last keys to be deleted
    String firstEntry = null;
    String lastEntry = null;
    while (it.isValid() && new String(it.key()).startsWith(prefix)) {
        String result = new String(it.key());
        it.next();
        if (firstEntry == null) {
            firstEntry = result;
        }
        lastEntry = result;
    }
    it.close();
    if (null != firstEntry) {
        try {
            // This will not delete the last entry
            getRocksDB().deleteRange(managedHandlesMap.get(columnFamilyName), firstEntry.getBytes(), lastEntry.getBytes());
            // Delete the last entry
            getRocksDB().delete(lastEntry.getBytes());
        } catch (RocksDBException e) {
            LOG.error("Got exception performing range delete");
            throw new HoodieException(e);
        }
    }
}

18 Source : RockStoreIterator.java
with GNU Lesser General Public License v3.0
from vision-consensus

@Slf4j
public final clreplaced RockStoreIterator implements DBIterator {

    private RocksIterator dbIterator;

    private boolean first = true;

    public RockStoreIterator(RocksIterator dbIterator) {
        this.dbIterator = dbIterator;
    }

    @Override
    public void close() throws IOException {
        dbIterator.close();
    }

    @Override
    public boolean hasNext() {
        boolean hasNext = false;
        // true is first item
        try {
            if (first) {
                dbIterator.seekToFirst();
                first = false;
            }
            if (!(hasNext = dbIterator.isValid())) {
                // false is last item
                dbIterator.close();
            }
        } catch (Exception e) {
            System.out.println("e:" + e);
            try {
                dbIterator.close();
            } catch (Exception e1) {
                System.out.println("e1:" + e1);
            }
        }
        return hasNext;
    }

    @Override
    public Entry<byte[], byte[]> next() {
        if (!dbIterator.isValid()) {
            throw new NoSuchElementException();
        }
        byte[] key = dbIterator.key();
        byte[] value = dbIterator.value();
        dbIterator.next();
        return new Entry<byte[], byte[]>() {

            @Override
            public byte[] getKey() {
                return key;
            }

            @Override
            public byte[] getValue() {
                return value;
            }

            @Override
            public byte[] setValue(byte[] value) {
                throw new UnsupportedOperationException();
            }
        };
    }
}

18 Source : RocksKVIterator.java
with Apache License 2.0
from sofastack

/**
 * @author jiachun.fjc
 */
public clreplaced RocksKVIterator implements KVIterator {

    private final RocksRawKVStore rocksRawKVStore;

    private final RocksIterator it;

    private final Lock dbReadLock;

    private final long dbVersion;

    public RocksKVIterator(RocksRawKVStore rocksRawKVStore, RocksIterator it, Lock dbReadLock, long dbVersion) {
        this.rocksRawKVStore = rocksRawKVStore;
        this.it = it;
        this.dbReadLock = dbReadLock;
        this.dbVersion = dbVersion;
    }

    @Override
    public boolean isValid() {
        final Lock readLock = this.dbReadLock;
        readLock.lock();
        try {
            ensureSafety();
            return it.isValid();
        } finally {
            readLock.unlock();
        }
    }

    @Override
    public void seekToFirst() {
        final Lock readLock = this.dbReadLock;
        readLock.lock();
        try {
            ensureSafety();
            it.seekToFirst();
        } finally {
            readLock.unlock();
        }
    }

    @Override
    public void seekToLast() {
        final Lock readLock = this.dbReadLock;
        readLock.lock();
        try {
            ensureSafety();
            it.seekToLast();
        } finally {
            readLock.unlock();
        }
    }

    @Override
    public void seek(final byte[] target) {
        final Lock readLock = this.dbReadLock;
        readLock.lock();
        try {
            ensureSafety();
            it.seek(target);
        } finally {
            readLock.unlock();
        }
    }

    @Override
    public void seekForPrev(final byte[] target) {
        final Lock readLock = this.dbReadLock;
        readLock.lock();
        try {
            ensureSafety();
            it.seekForPrev(target);
        } finally {
            readLock.unlock();
        }
    }

    @Override
    public void next() {
        final Lock readLock = this.dbReadLock;
        readLock.lock();
        try {
            ensureSafety();
            it.next();
        } finally {
            readLock.unlock();
        }
    }

    @Override
    public void prev() {
        final Lock readLock = this.dbReadLock;
        readLock.lock();
        try {
            ensureSafety();
            it.prev();
        } finally {
            readLock.unlock();
        }
    }

    @Override
    public byte[] key() {
        final Lock readLock = this.dbReadLock;
        readLock.lock();
        try {
            ensureSafety();
            return it.key();
        } finally {
            readLock.unlock();
        }
    }

    @Override
    public byte[] value() {
        final Lock readLock = this.dbReadLock;
        readLock.lock();
        try {
            ensureSafety();
            return it.value();
        } finally {
            readLock.unlock();
        }
    }

    @Override
    public void close() throws Exception {
        final Lock readLock = this.dbReadLock;
        readLock.lock();
        try {
            ensureSafety();
            it.close();
        } finally {
            readLock.unlock();
        }
    }

    private void ensureSafety() {
        if (this.dbVersion != this.rocksRawKVStore.getDatabaseVersion()) {
            throw new InvalidIteratorVersion("current iterator is belong to the older version of db: " + this.dbVersion + ", the newest db version: " + this.rocksRawKVStore.getDatabaseVersion());
        }
    }
}

18 Source : RocksDBLogStorage.java
with Apache License 2.0
from sofastack

private void load(final ConfigurationManager confManager) {
    checkState();
    try (final RocksIterator it = this.db.newIterator(this.confHandle, this.totalOrderReadOptions)) {
        it.seekToFirst();
        while (it.isValid()) {
            final byte[] ks = it.key();
            final byte[] bs = it.value();
            // LogEntry index
            if (ks.length == 8) {
                final LogEntry entry = this.logEntryDecoder.decode(bs);
                if (entry != null) {
                    if (entry.getType() == EntryType.ENTRY_TYPE_CONFIGURATION) {
                        final ConfigurationEntry confEntry = new ConfigurationEntry();
                        confEntry.setId(new LogId(entry.getId().getIndex(), entry.getId().getTerm()));
                        confEntry.setConf(new Configuration(entry.getPeers(), entry.getLearners()));
                        if (entry.getOldPeers() != null) {
                            confEntry.setOldConf(new Configuration(entry.getOldPeers(), entry.getOldLearners()));
                        }
                        if (confManager != null) {
                            confManager.add(confEntry);
                        }
                    }
                } else {
                    LOG.warn("Fail to decode conf entry at index {}, the log data is: {}.", Bits.getLong(ks, 0), BytesUtil.toHex(bs));
                }
            } else {
                if (Arrays.equals(FIRST_LOG_IDX_KEY, ks)) {
                    setFirstLogIndex(Bits.getLong(bs, 0));
                    truncatePrefixInBackground(0L, this.firstLogIndex);
                } else {
                    LOG.warn("Unknown entry in configuration storage key={}, value={}.", BytesUtil.toHex(ks), BytesUtil.toHex(bs));
                }
            }
            it.next();
        }
    }
}

18 Source : RocksDBLogStorage.java
with Apache License 2.0
from sofastack

@Override
public long getLastLogIndex() {
    this.readLock.lock();
    checkState();
    try (final RocksIterator it = this.db.newIterator(this.defaultHandle, this.totalOrderReadOptions)) {
        it.seekToLast();
        if (it.isValid()) {
            return Bits.getLong(it.key(), 0);
        }
        return 0L;
    } finally {
        this.readLock.unlock();
    }
}

18 Source : RDB.java
with Apache License 2.0
from ShiCloud

public List<byte[]> getByPrefix(final ColumnFamilyHandle cfh, final byte[] prefixKey) {
    List<byte[]> values = new ArrayList<>();
    try {
        RocksIterator iterator = this.newIterator(cfh);
        for (iterator.seek(prefixKey); iterator.isValid(); iterator.next()) {
            if (new String(iterator.key()).startsWith(new String(prefixKey))) {
                values.add(iterator.value());
            }
        }
        log.debug("[RocksDB] -> succ while get by prefix, prefixKey:{}", new String(prefixKey));
    } catch (Exception e) {
        log.error("[RocksDB] ->  error while get by prefix, prefixKey:{}, err:{}", new String(prefixKey), e);
    }
    return values;
}

18 Source : RDB.java
with Apache License 2.0
from ShiCloud

public int getCountByPrefix(final ColumnFamilyHandle cfh, final byte[] prefixKey) {
    int count = 0;
    try {
        RocksIterator iterator = this.newIterator(cfh);
        for (iterator.seek(prefixKey); iterator.isValid(); iterator.next()) {
            if (new String(iterator.key()).startsWith(new String(prefixKey))) {
                count++;
            }
        }
        log.debug("[RocksDB] -> succ while get count by prefix, prefixKey:{}", new String(prefixKey));
    } catch (Exception e) {
        log.error("[RocksDB] ->  error while get count by prefix, prefixKey:{}, err:{}", new String(prefixKey), e);
    }
    return count;
}

18 Source : RocksDBMap.java
with Apache License 2.0
from nitrite

@Override
@SuppressWarnings({ "unchecked", "rawtypes" })
public K ceilingKey(K k) {
    try (RocksIterator iterator = rocksDB.newIterator(columnFamilyHandle)) {
        byte[] key = objectFormatter.encodeKey(k);
        iterator.seek(key);
        if (!iterator.isValid()) {
            iterator.seekToFirst();
        }
        ByteBuffer keyBuffer = ByteBuffer.wrap(key);
        while (iterator.isValid()) {
            byte[] nextKey = iterator.key();
            ByteBuffer nextKeyBuffer = ByteBuffer.wrap(nextKey);
            if (bytewiseComparator.compare(nextKeyBuffer, keyBuffer) >= 0) {
                Comparable k2 = (Comparable) objectFormatter.decodeKey(nextKey, k.getClreplaced());
                return (K) k2;
            }
            iterator.next();
        }
    }
    return null;
}

18 Source : RocksDBMap.java
with Apache License 2.0
from nitrite

@Override
public long size() {
    if (size.get() == 0) {
        // first time size calculation after db opening
        try (RocksIterator iterator = rocksDB.newIterator(columnFamilyHandle)) {
            iterator.seekToFirst();
            while (iterator.isValid()) {
                size.incrementAndGet();
                iterator.next();
            }
        }
    }
    // calculation already done and counter already started
    return size.get();
}

18 Source : RocksDBMap.java
with Apache License 2.0
from nitrite

@Override
@SuppressWarnings({ "unchecked", "rawtypes" })
public K higherKey(K k) {
    try (RocksIterator iterator = rocksDB.newIterator(columnFamilyHandle)) {
        byte[] key = objectFormatter.encodeKey(k);
        iterator.seek(key);
        if (!iterator.isValid()) {
            iterator.seekToFirst();
        }
        ByteBuffer keyBuffer = ByteBuffer.wrap(key);
        while (iterator.isValid()) {
            byte[] nextKey = iterator.key();
            ByteBuffer nextKeyBuffer = ByteBuffer.wrap(nextKey);
            if (bytewiseComparator.compare(nextKeyBuffer, keyBuffer) > 0) {
                Comparable k2 = (Comparable) objectFormatter.decodeKey(nextKey, k.getClreplaced());
                return (K) k2;
            }
            iterator.next();
        }
    }
    return null;
}

18 Source : RockStoreIterator.java
with GNU Lesser General Public License v3.0
from ledgeryi

@Slf4j
public final clreplaced RockStoreIterator implements DBIterator {

    private RocksIterator dbIterator;

    private boolean first = true;

    public RockStoreIterator(RocksIterator dbIterator) {
        this.dbIterator = dbIterator;
    }

    @Override
    public void close() throws IOException {
        dbIterator.close();
    }

    @Override
    public boolean hasNext() {
        boolean hasNext = false;
        // true is first item
        try {
            if (first) {
                dbIterator.seekToFirst();
                first = false;
            }
            if (!(hasNext = dbIterator.isValid())) {
                // false is last item
                dbIterator.close();
            }
        } catch (Exception e) {
            log.error("e:" + e);
            try {
                dbIterator.close();
            } catch (Exception e1) {
                log.error("e1:" + e1);
            }
        }
        return hasNext;
    }

    @Override
    public Entry<byte[], byte[]> next() {
        if (!dbIterator.isValid()) {
            throw new NoSuchElementException();
        }
        byte[] key = dbIterator.key();
        byte[] value = dbIterator.value();
        dbIterator.next();
        return new Entry<byte[], byte[]>() {

            @Override
            public byte[] getKey() {
                return key;
            }

            @Override
            public byte[] getValue() {
                return value;
            }

            @Override
            public byte[] setValue(byte[] value) {
                throw new UnsupportedOperationException();
            }
        };
    }
}

18 Source : RocksDBLookupTable.java
with Apache License 2.0
from Kyligence

@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");
        }
    };
}

18 Source : RocksDBKeyValueStorage.java
with Apache License 2.0
from hyperledger

@Override
public Stream<byte[]> streamKeys() {
    final RocksIterator rocksIterator = db.newIterator();
    rocksIterator.seekToFirst();
    return RocksDbKeyIterator.create(rocksIterator).toStream();
}

18 Source : RockStoreIterator.java
with GNU Lesser General Public License v3.0
from gscsocial

@Slf4j
public final clreplaced RockStoreIterator implements DBIterator {

    private RocksIterator dbIterator;

    private boolean first = true;

    public RockStoreIterator(RocksIterator dbIterator) {
        this.dbIterator = dbIterator;
    }

    @Override
    public void close() throws IOException {
        dbIterator.close();
    }

    @Override
    public boolean hasNext() {
        boolean hasNext = false;
        // true is first item
        try {
            if (first) {
                dbIterator.seekToFirst();
                first = false;
            }
            if (!(hasNext = dbIterator.isValid())) {
                // false is last item
                dbIterator.close();
            }
        } catch (Exception e) {
            // System.out.println("e:" + e);
            try {
                dbIterator.close();
            } catch (Exception e1) {
            // System.out.println("e1:" + e1);
            }
        }
        return hasNext;
    }

    @Override
    public Entry<byte[], byte[]> next() {
        if (!dbIterator.isValid()) {
            throw new NoSuchElementException();
        }
        byte[] key = dbIterator.key();
        byte[] value = dbIterator.value();
        dbIterator.next();
        return new Entry<byte[], byte[]>() {

            @Override
            public byte[] getKey() {
                return key;
            }

            @Override
            public byte[] getValue() {
                return value;
            }

            @Override
            public byte[] setValue(byte[] value) {
                throw new UnsupportedOperationException();
            }
        };
    }
}

18 Source : ZSet.java
with Apache License 2.0
from frost373

/**
 * 返回指定区间分数的成员
 */
public List<Entry> range(String key, long start, long end, int limit) throws KitDBException {
    try (CloseLock ignored = checkClose()) {
        byte[] key_b = getKey(key);
        List<Entry> entries = new ArrayList<>();
        MetaV metaV = getMeta(key_b);
        ZData zData = new ZData(key_b.length, key_b, metaV.getVersion(), start, "".getBytes());
        byte[] seek = zData.getSeek();
        byte[] head = zData.getHead();
        int count = 0;
        try (final RocksIterator iterator = newIterator(SstColumnFamily.DEFAULT)) {
            iterator.seek(seek);
            long index = 0;
            while (iterator.isValid() && index <= end && count < limit) {
                byte[] key_bs = iterator.key();
                if (!BytesUtil.checkHead(head, key_bs))
                    break;
                ZData izData = ZDataD.build(key_bs).convertValue();
                index = izData.getScore();
                if (index > end) {
                    break;
                }
                entries.add(new Entry(index, izData.value));
                count++;
                iterator.next();
            }
        }
        return entries;
    }
}

18 Source : RMap.java
with Apache License 2.0
from frost373

@Override
public RIterator<RMap> iterator(String key) throws KitDBException {
    try (CloseLock ignored = checkClose()) {
        byte[] key_b = getKey(key);
        Meta metaV = getMeta(key_b);
        if (metaV == null) {
            return null;
        }
        Key k_seek = new Key(key_b.length, key_b, metaV.getVersion(), null);
        RocksIterator iterator = newIterator(SstColumnFamily.DEFAULT);
        iterator.seek(k_seek.getHead());
        RIterator<RMap> rIterator = new RIterator<>(iterator, this, k_seek.getHead());
        return rIterator;
    }
}

18 Source : RList.java
with Apache License 2.0
from frost373

public List<byte[]> range(String key, long start, long end) throws KitDBException {
    try (CloseLock ignored = checkClose()) {
        byte[] key_b = getKey(key);
        List<byte[]> list = new ArrayList<>();
        MetaV metaV = getMeta(key_b);
        if (metaV == null) {
            return list;
        }
        ValueK valueK_seek = new ValueK(key_b.length, key_b, metaV.getVersion(), start);
        try (final RocksIterator iterator = newIterator(SstColumnFamily.DEFAULT)) {
            ValueKD valueKD = valueK_seek.convertValueBytes();
            byte[] heads = valueKD.toHeadBytes();
            iterator.seek(valueKD.toBytes());
            long index = 0;
            while (iterator.isValid() && index < end) {
                byte[] key_bs = iterator.key();
                if (!BytesUtil.checkHead(heads, key_bs))
                    break;
                ValueK valueK = ValueKD.build(key_bs).convertValue();
                index = valueK.getIndex();
                list.add(iterator.value());
                iterator.next();
            }
        } catch (Exception e) {
            throw e;
        }
        return list;
    }
}

18 Source : RKv.java
with Apache License 2.0
from frost373

public List<String> keys(String key_, int start, int limit) throws KitDBException {
    try (CloseLock ignored = checkClose()) {
        byte[] keyb_ = getKey(key_);
        List<String> list = new ArrayList<>();
        int index = 0;
        int count = 0;
        try (final RocksIterator iterator = newIterator(SstColumnFamily.DEFAULT)) {
            byte[] head = ArrayKits.addAll(HEAD_B, keyb_);
            iterator.seek(head);
            while (iterator.isValid() && count < limit) {
                byte[] key = iterator.key();
                if (!BytesUtil.checkHead(head, key))
                    break;
                if (index >= start) {
                    list.add(new String(ArrayKits.sub(key, 1, key.length), charset));
                    count++;
                }
                index++;
                iterator.next();
            }
        }
        return list;
    }
}

18 Source : RCollection.java
with Apache License 2.0
from frost373

protected KeyIterator getKeyIterator(byte[] head) {
    RocksIterator iterator = newIterator(SstColumnFamily.META);
    iterator.seek(head);
    KeyIterator keyIterator = new KeyIterator(iterator, head);
    return keyIterator;
}

18 Source : CacheManagerFilesIterator.java
with Apache License 2.0
from dremio

/**
 * Iterator which returns cached files information.
 *
 * Number of cached files can be at
 */
public clreplaced CacheManagerFilesIterator implements Iterator<Object> {

    private final boolean isCachedFileSystem;

    private List<CacheManagerFilesInfo> filesInfoList = new ArrayList<>();

    private int curPos;

    private CacheManagerStatsProvider cacheManagerStatsProvider;

    private RocksIterator fileIterator;

    CacheManagerFilesIterator(SabotContext sabotContext, OperatorContext operatorContext) {
        isCachedFileSystem = (sabotContext.getFileSystemWrapper() instanceof CacheManagerStatsProvider);
        if (isCachedFileSystem) {
            cacheManagerStatsProvider = (CacheManagerStatsProvider) sabotContext.getFileSystemWrapper();
            fileIterator = cacheManagerStatsProvider.getCachedFilesIterator();
            filesInfoList = cacheManagerStatsProvider.getCachedFilesStats(fileIterator);
        }
    }

    @Override
    public boolean hasNext() {
        if (!isCachedFileSystem || fileIterator == null) {
            return false;
        }
        if (curPos == filesInfoList.size()) {
            filesInfoList = cacheManagerStatsProvider.getCachedFilesStats(fileIterator);
            if (filesInfoList.isEmpty()) {
                return false;
            }
            curPos = 0;
        }
        return true;
    }

    @Override
    public Object next() {
        if (!isCachedFileSystem || fileIterator == null) {
            return null;
        }
        return filesInfoList.get(curPos++);
    }

    @Override
    public void remove() {
        throw new UnsupportedOperationException();
    }
}

18 Source : CacheManagerDatasetIterator.java
with Apache License 2.0
from dremio

/**
 * Iterator which returns cache manager dataset information
 */
public clreplaced CacheManagerDatasereplacederator implements Iterator<Object> {

    private final boolean isCachedFileSystem;

    private List<CacheManagerDatasetInfo> datasetInfoList = new ArrayList<>();

    private int curPos;

    private CacheManagerStatsProvider cacheManagerStatsProvider;

    private RocksIterator dsIterator;

    CacheManagerDatasereplacederator(SabotContext sabotContext, OperatorContext operatorContext) {
        isCachedFileSystem = (sabotContext.getFileSystemWrapper() instanceof CacheManagerStatsProvider);
        if (isCachedFileSystem) {
            cacheManagerStatsProvider = (CacheManagerStatsProvider) sabotContext.getFileSystemWrapper();
            dsIterator = cacheManagerStatsProvider.getDatasereplacederator();
            if (dsIterator != null) {
                datasetInfoList = cacheManagerStatsProvider.getDatasetStats(dsIterator);
            }
        }
    }

    @Override
    public boolean hasNext() {
        if (!isCachedFileSystem || dsIterator == null) {
            return false;
        }
        if (curPos == datasetInfoList.size()) {
            datasetInfoList = cacheManagerStatsProvider.getDatasetStats(dsIterator);
            if (datasetInfoList.isEmpty()) {
                return false;
            }
            curPos = 0;
        }
        return true;
    }

    @Override
    public Object next() {
        if (!isCachedFileSystem || dsIterator == null) {
            return null;
        }
        return datasetInfoList.get(curPos++);
    }

    @Override
    public void remove() {
        throw new UnsupportedOperationException();
    }
}

18 Source : BackupEngineTest.java
with Apache License 2.0
from didi

@Test
public void backupDb() throws RocksDBException {
    // String originPath = dbFolder.getRoot().getAbsolutePath();
    // String backupPath = backupFolder.getRoot().getAbsolutePath();
    String originPath = "/tmp/rocksdb";
    String backupPath = "/tmp/rocksdb_backup";
    System.out.println("originPath=" + originPath);
    System.out.println("backupPath=" + backupPath);
    // Open empty database.
    try (final Options opt = new Options().setCreateIfMissing(true);
        final RocksDB db = RocksDB.open(opt, originPath)) {
        // Fill database with some test values
        prepareDatabase(db);
        try (RocksIterator it = db.newIterator()) {
            for (it.seekToFirst(); it.isValid(); it.next()) {
                System.out.println(originPath + ":" + new String(it.key()) + ":" + new String(it.value()));
            }
        }
        // Create two backups
        try (final BackupableDBOptions bopt = new BackupableDBOptions(backupPath);
            final BackupEngine be = BackupEngine.open(opt.getEnv(), bopt)) {
            be.createNewBackup(db, false);
            be.createNewBackup(db, true);
            verifyNumberOfValidBackups(be, 2);
        }
    }
}

18 Source : BackupEngineTest.java
with Apache License 2.0
from didi

@Test
public void backupDb2() throws RocksDBException {
    // String originPath = dbFolder.getRoot().getAbsolutePath();
    // String backupPath = backupFolder.getRoot().getAbsolutePath();
    String originPath = "/tmp/rocksdb";
    String originPath2 = "/tmp/rocksdb2";
    String backupPath = "/tmp/rocksdb_backup";
    System.out.println("originPath=" + originPath);
    System.out.println("backupPath=" + backupPath);
    // Open empty database.
    try (final Options opt = new Options().setCreateIfMissing(true);
        final RocksDB db = RocksDB.open(opt, originPath)) {
        // Fill database with some test values
        prepareDatabase(db);
        try (RocksIterator it = db.newIterator()) {
            for (it.seekToFirst(); it.isValid(); it.next()) {
                System.out.println(originPath + ":" + new String(it.key()) + ":" + new String(it.value()));
            }
        }
        // Create two backups
        try (final BackupableDBOptions bopt = new BackupableDBOptions(backupPath);
            final BackupEngine be = BackupEngine.open(opt.getEnv(), bopt)) {
            be.createNewBackup(db, true);
            be.createNewBackup(db, true);
            // restore the backup
            final List<BackupInfo> backupInfo = verifyNumberOfValidBackups(be, 2);
            // restore db from first backup
            be.restoreDbFromBackup(backupInfo.get(0).backupId(), originPath2, originPath2, new RestoreOptions(true));
            // Open database again.
            RocksDB db2 = RocksDB.open(opt, originPath2);
            try (RocksIterator it = db2.newIterator()) {
                for (it.seekToFirst(); it.isValid(); it.next()) {
                    System.out.println(originPath2 + ":" + new String(it.key()) + ":" + new String(it.value()));
                }
            }
            db2.close();
        }
    }
}

18 Source : Collection.java
with GNU General Public License v3.0
from coti-io

public void forEach(Consumer<T> consumer) {
    try (RocksIterator iterator = gereplacederator()) {
        iterator.seekToFirst();
        while (iterator.isValid()) {
            T deserialized = getDeserializedValue(iterator);
            consumer.accept(deserialized);
            iterator.next();
        }
    }
}

18 Source : Collection.java
with GNU General Public License v3.0
from coti-io

public boolean isEmpty() {
    try (RocksIterator iterator = databaseConnector.gereplacederator(columnFamilyName)) {
        iterator.seekToFirst();
        return !iterator.isValid();
    }
}

18 Source : Collection.java
with GNU General Public License v3.0
from coti-io

public void forEachWithLasreplacederation(BiConsumer<T, Boolean> biConsumer) {
    try (RocksIterator iterator = gereplacederator()) {
        iterator.seekToFirst();
        while (iterator.isValid()) {
            T deserialized = getDeserializedValue(iterator);
            iterator.next();
            boolean isLasreplacederation = !iterator.isValid();
            biConsumer.accept(deserialized, isLasreplacederation);
        }
    }
}

18 Source : RocksDbInstance.java
with Apache License 2.0
from ConsenSys

@SuppressWarnings("MustBeClosedChecker")
@MustBeClosed
private <K, V> Stream<ColumnEntry<K, V>> createStream(RocksDbColumn<K, V> column, Consumer<RocksIterator> setupIterator, Predicate<K> continueTest) {
    final ColumnFamilyHandle handle = columnHandles.get(column);
    final RocksIterator rocksDbIterator = db.newIterator(handle);
    setupIterator.accept(rocksDbIterator);
    return RocksDbIterator.create(column, rocksDbIterator, continueTest, closed::get).toStream();
}

18 Source : DBScanner.java
with Apache License 2.0
from apache

private static List<Object> displayTable(RocksIterator iterator, DBColumnFamilyDefinition dbColumnFamilyDefinition) throws IOException {
    List<Object> outputs = new ArrayList<>();
    iterator.seekToFirst();
    while (iterator.isValid() && limit > 0) {
        StringBuilder result = new StringBuilder();
        if (withKey) {
            Object key = dbColumnFamilyDefinition.getKeyCodec().fromPersistedFormat(iterator.key());
            Gson gson = new GsonBuilder().setPrettyPrinting().create();
            result.append(gson.toJson(key));
            result.append(" -> ");
        }
        Object o = dbColumnFamilyDefinition.getValueCodec().fromPersistedFormat(iterator.value());
        outputs.add(o);
        Gson gson = new GsonBuilder().setPrettyPrinting().create();
        result.append(gson.toJson(o));
        System.out.println(result.toString());
        limit--;
        iterator.next();
    }
    return outputs;
}

18 Source : RDBStoreIterator.java
with Apache License 2.0
from apache

/**
 * RocksDB store iterator.
 */
public clreplaced RDBStoreIterator implements TableIterator<byte[], ByteArrayKeyValue> {

    private static final Logger LOG = LoggerFactory.getLogger(RDBStoreIterator.clreplaced);

    private RocksIterator rocksDBIterator;

    private RDBTable rocksDBTable;

    private ByteArrayKeyValue currentEntry;

    public RDBStoreIterator(RocksIterator iterator) {
        this.rocksDBIterator = iterator;
        seekToFirst();
    }

    public RDBStoreIterator(RocksIterator iterator, RDBTable table) {
        this(iterator);
        this.rocksDBTable = table;
    }

    @Override
    public void forEachRemaining(Consumer<? super ByteArrayKeyValue> action) {
        while (hasNext()) {
            action.accept(next());
        }
    }

    private void setCurrentEntry() {
        if (rocksDBIterator.isValid()) {
            currentEntry = ByteArrayKeyValue.create(rocksDBIterator.key(), rocksDBIterator.value());
        } else {
            currentEntry = null;
        }
    }

    @Override
    public boolean hasNext() {
        return rocksDBIterator.isValid();
    }

    @Override
    public ByteArrayKeyValue next() {
        setCurrentEntry();
        if (currentEntry != null) {
            rocksDBIterator.next();
            return currentEntry;
        }
        throw new NoSuchElementException("RocksDB Store has no more elements");
    }

    @Override
    public void seekToFirst() {
        rocksDBIterator.seekToFirst();
        setCurrentEntry();
    }

    @Override
    public void seekToLast() {
        rocksDBIterator.seekToLast();
        setCurrentEntry();
    }

    @Override
    public ByteArrayKeyValue seek(byte[] key) {
        rocksDBIterator.seek(key);
        setCurrentEntry();
        return currentEntry;
    }

    @Override
    public byte[] key() {
        if (rocksDBIterator.isValid()) {
            return rocksDBIterator.key();
        }
        return null;
    }

    @Override
    public ByteArrayKeyValue value() {
        if (rocksDBIterator.isValid()) {
            return ByteArrayKeyValue.create(rocksDBIterator.key(), rocksDBIterator.value());
        }
        return null;
    }

    @Override
    public void removeFromDB() throws IOException {
        if (rocksDBTable == null) {
            throw new UnsupportedOperationException("remove");
        }
        if (currentEntry != null) {
            rocksDBTable.delete(currentEntry.getKey());
        } else {
            LOG.info("Unable to delete currentEntry as it does not exist.");
        }
    }

    @Override
    public void close() throws IOException {
        rocksDBIterator.close();
    }
}

17 Source : DBConvert.java
with GNU Lesser General Public License v3.0
from vision-consensus

public boolean convertLevelToRocks(DB level, RocksDB rocks) {
    // convert
    DBIterator levelIterator = level.iterator();
    try {
        for (levelIterator.seekToFirst(); levelIterator.hasNext(); levelIterator.next()) {
            byte[] key = levelIterator.peekNext().getKey();
            byte[] value = levelIterator.peekNext().getValue();
            srcDbKeyCount++;
            srcDbKeySum = byteArrayToIntWithOne(srcDbKeySum, key);
            srcDbValueSum = byteArrayToIntWithOne(srcDbValueSum, value);
            rocks.put(key, value);
        }
    } catch (RocksDBException e) {
        logger.error(e.getMessage());
        return false;
    } finally {
        try {
            levelIterator.close();
        } catch (IOException e1) {
            logger.error(e1.getMessage());
        }
    }
    // check
    try (final RocksIterator rocksIterator = rocks.newIterator()) {
        for (rocksIterator.seekToLast(); rocksIterator.isValid(); rocksIterator.prev()) {
            byte[] key = rocksIterator.key();
            byte[] value = rocksIterator.value();
            dstDbKeyCount++;
            dstDbKeySum = byteArrayToIntWithOne(dstDbKeySum, key);
            dstDbValueSum = byteArrayToIntWithOne(dstDbValueSum, value);
        }
    }
    return dstDbKeyCount == srcDbKeyCount && dstDbKeySum == srcDbKeySum && dstDbValueSum == srcDbValueSum;
}

See More Examples