Struct rocksdb::DBRawIterator [−][src]
An iterator over a database or column family, with specifiable ranges and direction.
This iterator is different to the standard DBIterator
as it aims Into
replicate the underlying iterator API within RocksDB itself. This should
give access to more performance and flexibility but departs from the
widely recognised Rust idioms.
use rocksdb::{DB, Options}; let path = "_path_for_rocksdb_storage4"; { let db = DB::open_default(path).unwrap(); let mut iter = db.raw_iterator(); // Forwards iteration iter.seek_to_first(); while iter.valid() { println!("Saw {:?} {:?}", iter.key(), iter.value()); iter.next(); } // Reverse iteration iter.seek_to_last(); while iter.valid() { println!("Saw {:?} {:?}", iter.key(), iter.value()); iter.prev(); } // Seeking iter.seek(b"my key"); while iter.valid() { println!("Saw {:?} {:?}", iter.key(), iter.value()); iter.next(); } // Reverse iteration from key // Note, use seek_for_prev when reversing because if this key doesn't exist, // this will make the iterator start from the previous key rather than the next. iter.seek_for_prev(b"my key"); while iter.valid() { println!("Saw {:?} {:?}", iter.key(), iter.value()); iter.prev(); } } let _ = DB::destroy(&Options::default(), path);
Implementations
impl<'a> DBRawIterator<'a>
[src]
pub fn valid(&self) -> bool
[src]
Returns true
if the iterator is valid. An iterator is invalidated when
it reaches the end of its defined range, or when it encounters an error.
To check whether the iterator encountered an error after valid
has
returned false
, use the status
method. status
will never
return an error when valid
is true
.
pub fn status(&self) -> Result<(), Error>
[src]
Returns an error Result
if the iterator has encountered an error
during operation. When an error is encountered, the iterator is
invalidated and valid
will return false
when called.
Performing a seek will discard the current status.
pub fn seek_to_first(&mut self)
[src]
Seeks to the first key in the database.
Examples
use rocksdb::{DB, Options}; let path = "_path_for_rocksdb_storage5"; { let db = DB::open_default(path).unwrap(); let mut iter = db.raw_iterator(); // Iterate all keys from the start in lexicographic order iter.seek_to_first(); while iter.valid() { println!("{:?} {:?}", iter.key(), iter.value()); iter.next(); } // Read just the first key iter.seek_to_first(); if iter.valid() { println!("{:?} {:?}", iter.key(), iter.value()); } else { // There are no keys in the database } } let _ = DB::destroy(&Options::default(), path);
pub fn seek_to_last(&mut self)
[src]
Seeks to the last key in the database.
Examples
use rocksdb::{DB, Options}; let path = "_path_for_rocksdb_storage6"; { let db = DB::open_default(path).unwrap(); let mut iter = db.raw_iterator(); // Iterate all keys from the end in reverse lexicographic order iter.seek_to_last(); while iter.valid() { println!("{:?} {:?}", iter.key(), iter.value()); iter.prev(); } // Read just the last key iter.seek_to_last(); if iter.valid() { println!("{:?} {:?}", iter.key(), iter.value()); } else { // There are no keys in the database } } let _ = DB::destroy(&Options::default(), path);
pub fn seek<K: AsRef<[u8]>>(&mut self, key: K)
[src]
Seeks to the specified key or the first key that lexicographically follows it.
This method will attempt to seek to the specified key. If that key does not exist, it will find and seek to the key that lexicographically follows it instead.
Examples
use rocksdb::{DB, Options}; let path = "_path_for_rocksdb_storage7"; { let db = DB::open_default(path).unwrap(); let mut iter = db.raw_iterator(); // Read the first key that starts with 'a' iter.seek(b"a"); if iter.valid() { println!("{:?} {:?}", iter.key(), iter.value()); } else { // There are no keys in the database } } let _ = DB::destroy(&Options::default(), path);
pub fn seek_for_prev<K: AsRef<[u8]>>(&mut self, key: K)
[src]
Seeks to the specified key, or the first key that lexicographically precedes it.
Like .seek()
this method will attempt to seek to the specified key.
The difference with .seek()
is that if the specified key do not exist, this method will
seek to key that lexicographically precedes it instead.
Examples
use rocksdb::{DB, Options}; let path = "_path_for_rocksdb_storage8"; { let db = DB::open_default(path).unwrap(); let mut iter = db.raw_iterator(); // Read the last key that starts with 'a' iter.seek_for_prev(b"b"); if iter.valid() { println!("{:?} {:?}", iter.key(), iter.value()); } else { // There are no keys in the database } } let _ = DB::destroy(&Options::default(), path);
pub fn next(&mut self)
[src]
Seeks to the next key.
pub fn prev(&mut self)
[src]
Seeks to the previous key.
pub fn key(&self) -> Option<&[u8]>
[src]
Returns a slice of the current key.
pub fn value(&self) -> Option<&[u8]>
[src]
Returns a slice of the current value.
Trait Implementations
impl<'a> Drop for DBRawIterator<'a>
[src]
impl<'a> Into<DBRawIterator<'a>> for DBIterator<'a>
[src]
fn into(self) -> DBRawIterator<'a>
[src]
impl<'a> Send for DBRawIterator<'a>
[src]
impl<'a> Sync for DBRawIterator<'a>
[src]
Auto Trait Implementations
impl<'a> RefUnwindSafe for DBRawIterator<'a>
impl<'a> Unpin for DBRawIterator<'a>
impl<'a> UnwindSafe for DBRawIterator<'a>
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,