seek for prev (#70)

librocksdb_sys/src/lib.rs

@@ -319,6 +319,7 @@ extern "C" {
     pub fn crocksdb_iter_seek_to_first(iter: *mut DBIterator);
     pub fn crocksdb_iter_seek_to_last(iter: *mut DBIterator);
     pub fn crocksdb_iter_seek(iter: *mut DBIterator, key: *const u8, klen: size_t);
+    pub fn crocksdb_iter_seek_for_prev(iter: *mut DBIterator, key: *const u8, klen: size_t);
     pub fn crocksdb_iter_next(iter: *mut DBIterator);
     pub fn crocksdb_iter_prev(iter: *mut DBIterator);
     pub fn crocksdb_iter_key(iter: *const DBIterator, klen: *mut size_t) -> *mut u8;

src/rocksdb.rs

@@ -109,6 +109,19 @@ impl<'a> DBIterator<'a> {
         self.valid()
     }
 
+    pub fn seek_for_prev(&mut self, key: SeekKey) -> bool {
+        unsafe {
+            match key {
+                SeekKey::Start => crocksdb_ffi::crocksdb_iter_seek_to_first(self.inner),
+                SeekKey::End => crocksdb_ffi::crocksdb_iter_seek_to_last(self.inner),
+                SeekKey::Key(key) => {
+                    crocksdb_ffi::crocksdb_iter_seek_for_prev(self.inner, key.as_ptr(), key.len() as size_t)
+                }
+            }
+        }
+        self.valid()
+    }
+
     pub fn prev(&mut self) -> bool {
         unsafe {
             crocksdb_ffi::crocksdb_iter_prev(self.inner);

test/test_iterator.rs

@@ -112,6 +112,54 @@ pub fn test_iterator() {
     assert!(!iter.valid());
 }
 
+#[test]
+fn test_seek_for_prev() {
+    let path = TempDir::new("_rust_rocksdb_seek_for_prev").expect("");
+    let mut opts = Options::new();
+    opts.create_if_missing(true);
+    {
+        let db = DB::open(opts, path.path().to_str().unwrap()).unwrap();
+        let writeopts = WriteOptions::new();
+        db.put_opt(b"k1-0", b"a", &writeopts).unwrap();
+        db.put_opt(b"k1-1", b"b", &writeopts).unwrap();
+        db.put_opt(b"k1-3", b"d", &writeopts).unwrap();
+
+        let mut iter = db.iter();
+        iter.seek_for_prev(SeekKey::Key(b"k1-2"));
+        assert!(iter.valid());
+        assert_eq!(iter.key(), b"k1-1");
+        assert_eq!(iter.value(), b"b");
+
+        let mut iter = db.iter();
+        iter.seek_for_prev(SeekKey::Key(b"k1-3"));
+        assert!(iter.valid());
+        assert_eq!(iter.key(), b"k1-3");
+        assert_eq!(iter.value(), b"d");
+
+        let mut iter = db.iter();
+        iter.seek_for_prev(SeekKey::Start);
+        assert!(iter.valid());
+        assert_eq!(iter.key(), b"k1-0");
+        assert_eq!(iter.value(), b"a");
+
+        let mut iter = db.iter();
+        iter.seek_for_prev(SeekKey::End);
+        assert!(iter.valid());
+        assert_eq!(iter.key(), b"k1-3");
+        assert_eq!(iter.value(), b"d");
+
+        let mut iter = db.iter();
+        iter.seek_for_prev(SeekKey::Key(b"k0-0"));
+        assert!(!iter.valid());
+
+        let mut iter = db.iter();
+        iter.seek_for_prev(SeekKey::Key(b"k2-0"));
+        assert!(iter.valid());
+        assert_eq!(iter.key(), b"k1-3");
+        assert_eq!(iter.value(), b"d");
+    }
+}
+
 #[test]
 fn read_with_upper_bound() {
     let path = TempDir::new("_rust_rocksdb_read_with_upper_bound_test").expect("");