iterator: fix error handling about valid (#411) (#413)

Signed-off-by: qupeng <qupeng@pingcap.com>

src/lib.rs

@@ -34,8 +34,8 @@ pub use metadata::{ColumnFamilyMetaData, LevelMetaData, SstFileMetaData};
 pub use perf_context::{get_perf_level, set_perf_level, IOStatsContext, PerfContext, PerfLevel};
 pub use rocksdb::{
     load_latest_options, run_ldb_tool, set_external_sst_file_global_seq_no, BackupEngine, CFHandle,
-    DBIterator, DBVector, Env, ExternalSstFileInfo, Kv, Range, SeekKey, SequentialFile,
-    SstFileWriter, Writable, WriteBatch, DB,
+    DBIterator, DBVector, Env, ExternalSstFileInfo, Range, SeekKey, SequentialFile, SstFileWriter,
+    Writable, WriteBatch, DB,
 };
 pub use rocksdb_options::{
     BlockBasedOptions, CColumnFamilyDescriptor, ColumnFamilyOptions, CompactOptions,
@@ -51,6 +51,9 @@ pub use table_properties::{
 pub use table_properties_collector::TablePropertiesCollector;
 pub use table_properties_collector_factory::TablePropertiesCollectorFactory;
 
+#[allow(deprecated)]
+pub use rocksdb::Kv;
+
 mod compaction_filter;
 pub mod comparator;
 mod event_listener;

src/perf_context.rs

@@ -422,10 +422,8 @@ mod test {
         let mut ctx = PerfContext::get();
 
         let mut iter = db.iter();
-        assert!(iter.seek(SeekKey::Start));
-        while iter.valid() {
-            iter.next();
-        }
+        assert!(iter.seek(SeekKey::Start).unwrap());
+        while iter.next().unwrap() {}
         assert_eq!(ctx.internal_key_skipped_count(), n);
         assert_eq!(ctx.internal_delete_skipped_count(), n / 2);
         assert_eq!(ctx.seek_internal_seek_time(), 0);
@@ -439,9 +437,9 @@ mod test {
         assert_eq!(get_perf_level(), PerfLevel::EnableTime);
 
         let mut iter = db.iter();
-        assert!(iter.seek(SeekKey::End));
-        while iter.valid() {
-            iter.prev();
+        assert!(iter.seek(SeekKey::End).unwrap());
+        while iter.valid().unwrap() {
+            iter.prev().unwrap();
         }
         assert_eq!(ctx.internal_key_skipped_count(), n + n / 2);
         assert_eq!(ctx.internal_delete_skipped_count(), n / 2);

src/rocksdb.rs

@@ -144,7 +144,7 @@ impl<D: Deref<Target = DB>> DBIterator<D> {
         }
     }
 
-    pub fn seek(&mut self, key: SeekKey) -> bool {
+    pub fn seek(&mut self, key: SeekKey) -> Result<bool, String> {
         unsafe {
             match key {
                 SeekKey::Start => crocksdb_ffi::crocksdb_iter_seek_to_first(self.inner),
@@ -157,7 +157,7 @@ impl<D: Deref<Target = DB>> DBIterator<D> {
         self.valid()
     }
 
-    pub fn seek_for_prev(&mut self, key: SeekKey) -> bool {
+    pub fn seek_for_prev(&mut self, key: SeekKey) -> Result<bool, String> {
         unsafe {
             match key {
                 SeekKey::Start => crocksdb_ffi::crocksdb_iter_seek_to_first(self.inner),
@@ -172,22 +172,24 @@ impl<D: Deref<Target = DB>> DBIterator<D> {
         self.valid()
     }
 
-    pub fn prev(&mut self) -> bool {
+    pub fn prev(&mut self) -> Result<bool, String> {
         unsafe {
             crocksdb_ffi::crocksdb_iter_prev(self.inner);
         }
         self.valid()
     }
 
-    pub fn next(&mut self) -> bool {
+    #[allow(clippy::should_implement_trait)]
+    pub fn next(&mut self) -> Result<bool, String> {
         unsafe {
             crocksdb_ffi::crocksdb_iter_next(self.inner);
         }
         self.valid()
     }
 
+    /// Get the key pointed by the iterator. Must be called when `self.valid() == Ok(true)`.
     pub fn key(&self) -> &[u8] {
-        assert!(self.valid());
+        debug_assert_eq!(self.valid(), Ok(true));
         let mut key_len: size_t = 0;
         let key_len_ptr: *mut size_t = &mut key_len;
         unsafe {
@@ -196,8 +198,9 @@ impl<D: Deref<Target = DB>> DBIterator<D> {
         }
     }
 
+    /// Get the value pointed by the iterator. Must be called when `self.valid() == Ok(true)`.
     pub fn value(&self) -> &[u8] {
-        assert!(self.valid());
+        debug_assert_eq!(self.valid(), Ok(true));
         let mut val_len: size_t = 0;
         let val_len_ptr: *mut size_t = &mut val_len;
         unsafe {
@@ -206,19 +209,24 @@ impl<D: Deref<Target = DB>> DBIterator<D> {
         }
     }
 
+    #[deprecated]
     pub fn kv(&self) -> Option<(Vec<u8>, Vec<u8>)> {
-        if self.valid() {
+        if self.valid().unwrap() {
             Some((self.key().to_vec(), self.value().to_vec()))
         } else {
             None
         }
     }
 
-    pub fn valid(&self) -> bool {
-        unsafe { crocksdb_ffi::crocksdb_iter_valid(self.inner) }
+    pub fn valid(&self) -> Result<bool, String> {
+        let valid = unsafe { crocksdb_ffi::crocksdb_iter_valid(self.inner) };
+        if !valid {
+            self.status()?;
+        }
+        Ok(valid)
     }
 
-    pub fn status(&self) -> Result<(), String> {
+    fn status(&self) -> Result<(), String> {
         unsafe {
             ffi_try!(crocksdb_iter_get_error(self.inner));
         }
@@ -241,17 +249,24 @@ impl<D: Deref<Target = DB>> DBIterator<D> {
     }
 }
 
+#[deprecated]
 pub type Kv = (Vec<u8>, Vec<u8>);
 
+#[deprecated]
 impl<'b, D: Deref<Target = DB>> Iterator for &'b mut DBIterator<D> {
+    #[allow(deprecated)]
     type Item = Kv;
 
-    fn next(&mut self) -> Option<Kv> {
-        let kv = self.kv();
-        if kv.is_some() {
-            DBIterator::next(self);
+    fn next(&mut self) -> Option<Self::Item> {
+        match self.valid() {
+            Ok(true) => {}
+            Ok(false) => return None,
+            Err(e) => panic!("invalid iterator: {}", e),
         }
-        kv
+        let k = self.key().to_vec();
+        let v = self.value().to_vec();
+        let _ = DBIterator::next(self);
+        Some((k, v))
     }
 }
 
@@ -2425,7 +2440,7 @@ mod test {
         db.put(b"k2", b"v2222").expect("");
         db.put(b"k3", b"v3333").expect("");
         let mut iter = db.iter();
-        iter.seek(SeekKey::Start);
+        iter.seek(SeekKey::Start).unwrap();
         for (k, v) in &mut iter {
             println!(
                 "Hello {}: {}",

tests/cases/test_delete_files_in_range.rs

@@ -65,9 +65,9 @@ fn test_delete_files_in_range_with_iter() {
     db.delete_files_in_range(b"key2", b"key7", false).unwrap();
 
     let mut count = 0;
-    assert!(iter.seek(SeekKey::Start));
-    while iter.valid() {
-        iter.next();
+    assert!(iter.seek(SeekKey::Start).unwrap());
+    while iter.valid().unwrap() {
+        iter.next().unwrap();
         count = count + 1;
     }
 
@@ -88,11 +88,11 @@ fn test_delete_files_in_range_with_snap() {
     db.delete_files_in_range(b"key2", b"key7", false).unwrap();
 
     let mut iter = snap.iter();
-    assert!(iter.seek(SeekKey::Start));
+    assert!(iter.seek(SeekKey::Start).unwrap());
 
     let mut count = 0;
-    while iter.valid() {
-        iter.next();
+    while iter.valid().unwrap() {
+        iter.next().unwrap();
         count = count + 1;
     }
 
@@ -158,12 +158,12 @@ fn test_delete_files_in_range_with_delete_range() {
     db.compact_range(None, None);
 
     let mut it = db.iter();
-    it.seek(SeekKey::Start);
-    assert!(it.valid());
+    it.seek(SeekKey::Start).unwrap();
+    assert!(it.valid().unwrap());
     assert_eq!(it.key(), b"4");
-    assert!(it.next());
+    assert!(it.next().unwrap());
     assert_eq!(it.key(), b"5");
-    assert!(!it.next());
+    assert!(!it.next().unwrap());
 }
 
 #[test]
@@ -185,19 +185,18 @@ fn test_delete_files_in_ranges() {
 
     // Check that ["key0", "key5"] have been deleted, but ["key6", "key8"] still exist.
     let mut iter = db.iter();
-    iter.seek(SeekKey::Start);
+    iter.seek(SeekKey::Start).unwrap();
     for i in 6..9 {
-        assert!(iter.valid());
+        assert!(iter.valid().unwrap());
         let k = format!("key{}", i);
         assert_eq!(iter.key(), k.as_bytes());
-        iter.next();
+        iter.next().unwrap();
     }
-    assert!(!iter.valid());
+    assert!(!iter.valid().unwrap());
 
     // Delete the last file.
     let ranges = vec![Range::new(b"key6", b"key8")];
     db.delete_files_in_ranges_cf(cf, &ranges, true).unwrap();
     let mut iter = db.iter();
-    iter.seek(SeekKey::Start);
-    assert!(!iter.valid());
+    assert!(!iter.seek(SeekKey::Start).unwrap());
 }

tests/cases/test_delete_range.rs

@@ -42,10 +42,10 @@ fn gen_sst_from_db(opt: ColumnFamilyOptions, cf: Option<&CFHandle>, path: &str,
     };
     writer.open(path).unwrap();
     let mut iter = db.iter();
-    iter.seek(SeekKey::Start);
-    while iter.valid() {
+    iter.seek(SeekKey::Start).unwrap();
+    while iter.valid().unwrap() {
         writer.put(iter.key(), iter.value()).unwrap();
-        iter.next();
+        iter.next().unwrap();
     }
     writer.finish().unwrap();
 }
@@ -53,11 +53,11 @@ fn gen_sst_from_db(opt: ColumnFamilyOptions, cf: Option<&CFHandle>, path: &str,
 fn gen_crc32_from_db(db: &DB) -> u32 {
     let mut digest = Digest::new(crc32::IEEE);
     let mut iter = db.iter();
-    iter.seek(SeekKey::Start);
-    while iter.valid() {
+    iter.seek(SeekKey::Start).unwrap();
+    while iter.valid().unwrap() {
         digest.write(iter.key());
         digest.write(iter.value());
-        iter.next();
+        iter.next().unwrap();
     }
     digest.sum32()
 }
@@ -65,14 +65,14 @@ fn gen_crc32_from_db(db: &DB) -> u32 {
 fn gen_crc32_from_db_in_range(db: &DB, start_key: &[u8], end_key: &[u8]) -> u32 {
     let mut digest = Digest::new(crc32::IEEE);
     let mut iter = db.iter();
-    iter.seek(SeekKey::Key(start_key));
-    while iter.valid() {
+    iter.seek(SeekKey::Key(start_key)).unwrap();
+    while iter.valid().unwrap() {
         if iter.key() >= end_key {
             break;
         }
         digest.write(iter.key());
         digest.write(iter.value());
-        iter.next();
+        iter.next().unwrap();
     }
     digest.sum32()
 }

tests/cases/test_ingest_external_file.rs

@@ -280,16 +280,16 @@ fn gen_sst_from_cf(opt: ColumnFamilyOptions, db: &DB, cf: &CFHandle, path: &str)
     let mut writer = SstFileWriter::new_cf(env_opt, opt, cf);
     writer.open(path).unwrap();
     let mut iter = db.iter_cf(cf);
-    iter.seek(SeekKey::Start);
-    while iter.valid() {
+    iter.seek(SeekKey::Start).unwrap();
+    while iter.valid().unwrap() {
         writer.put(iter.key(), iter.value()).unwrap();
-        iter.next();
+        iter.next().unwrap();
     }
     let info = writer.finish().unwrap();
     assert_eq!(info.file_path().to_str().unwrap(), path);
-    iter.seek(SeekKey::Start);
+    iter.seek(SeekKey::Start).unwrap();
     assert_eq!(info.smallest_key(), iter.key());
-    iter.seek(SeekKey::End);
+    iter.seek(SeekKey::End).unwrap();
     assert_eq!(info.largest_key(), iter.key());
     assert_eq!(info.sequence_number(), 0);
     assert!(info.file_size() > 0);

tests/cases/test_iterator.rs

@@ -46,20 +46,25 @@ impl SliceTransform for FixedSuffixTransform {
     }
 }
 
+#[allow(deprecated)]
 fn prev_collect<D: Deref<Target = DB>>(iter: &mut DBIterator<D>) -> Vec<Kv> {
     let mut buf = vec![];
-    while iter.valid() {
-        buf.push(iter.kv().unwrap());
-        iter.prev();
+    while iter.valid().unwrap() {
+        let k = iter.key().to_vec();
+        let v = iter.value().to_vec();
+        buf.push((k, v));
+        let _ = iter.prev();
     }
     buf
 }
 
-fn next_collect<D: Deref<Target = DB>>(iter: &mut DBIterator<D>) -> Vec<Kv> {
+fn next_collect<D: Deref<Target = DB>>(iter: &mut DBIterator<D>) -> Vec<(Vec<u8>, Vec<u8>)> {
     let mut buf = vec![];
-    while iter.valid() {
-        buf.push(iter.kv().unwrap());
-        iter.next();
+    while iter.valid().unwrap() {
+        let k = iter.key().to_vec();
+        let v = iter.value().to_vec();
+        buf.push((k, v));
+        let _ = iter.next();
     }
     buf
 }
@@ -91,33 +96,33 @@ pub fn test_iterator() {
 
     let mut iter = db.iter();
 
-    iter.seek(SeekKey::Start);
+    iter.seek(SeekKey::Start).unwrap();
     assert_eq!(iter.collect::<Vec<_>>(), expected);
 
     // Test that it's idempotent
-    iter.seek(SeekKey::Start);
+    iter.seek(SeekKey::Start).unwrap();
     assert_eq!(iter.collect::<Vec<_>>(), expected);
 
     // Test it in reverse a few times
-    iter.seek(SeekKey::End);
+    iter.seek(SeekKey::End).unwrap();
     let mut tmp_vec = prev_collect(&mut iter);
     tmp_vec.reverse();
     assert_eq!(tmp_vec, expected);
 
-    iter.seek(SeekKey::End);
+    iter.seek(SeekKey::End).unwrap();
     let mut tmp_vec = prev_collect(&mut iter);
     tmp_vec.reverse();
     assert_eq!(tmp_vec, expected);
 
     // Try it forward again
-    iter.seek(SeekKey::Start);
+    iter.seek(SeekKey::Start).unwrap();
     assert_eq!(iter.collect::<Vec<_>>(), expected);
 
-    iter.seek(SeekKey::Start);
+    iter.seek(SeekKey::Start).unwrap();
     assert_eq!(iter.collect::<Vec<_>>(), expected);
 
     let mut old_iterator = db.iter();
-    old_iterator.seek(SeekKey::Start);
+    old_iterator.seek(SeekKey::Start).unwrap();
     let p = db.put(&*k4, &*v4);
     assert!(p.is_ok());
     let expected2 = vec![
@@ -129,10 +134,10 @@ pub fn test_iterator() {
     assert_eq!(old_iterator.collect::<Vec<_>>(), expected);
 
     iter = db.iter();
-    iter.seek(SeekKey::Start);
+    iter.seek(SeekKey::Start).unwrap();
     assert_eq!(iter.collect::<Vec<_>>(), expected2);
 
-    iter.seek(SeekKey::Key(k2));
+    iter.seek(SeekKey::Key(k2)).unwrap();
     let expected = vec![
         (k2.to_vec(), v2.to_vec()),
         (k3.to_vec(), v3.to_vec()),
@@ -140,35 +145,23 @@ pub fn test_iterator() {
     ];
     assert_eq!(iter.collect::<Vec<_>>(), expected);
 
-    iter.seek(SeekKey::Key(k2));
+    iter.seek(SeekKey::Key(k2)).unwrap();
     let expected = vec![(k2.to_vec(), v2.to_vec()), (k1.to_vec(), v1.to_vec())];
     assert_eq!(prev_collect(&mut iter), expected);
 
-    iter.seek(SeekKey::Key(b"k0"));
-    assert!(iter.valid());
-    iter.seek(SeekKey::Key(b"k1"));
-    assert!(iter.valid());
-    iter.seek(SeekKey::Key(b"k11"));
-    assert!(iter.valid());
-    iter.seek(SeekKey::Key(b"k5"));
-    assert!(!iter.valid());
-    iter.seek(SeekKey::Key(b"k0"));
-    assert!(iter.valid());
-    iter.seek(SeekKey::Key(b"k1"));
-    assert!(iter.valid());
-    iter.seek(SeekKey::Key(b"k11"));
-    assert!(iter.valid());
-    iter.seek(SeekKey::Key(b"k5"));
-    assert!(!iter.valid());
-
-    iter.seek(SeekKey::Key(b"k4"));
-    assert!(iter.valid());
-    iter.prev();
-    assert!(iter.valid());
-    iter.next();
-    assert!(iter.valid());
-    iter.next();
-    assert!(!iter.valid());
+    assert!(iter.seek(SeekKey::Key(b"k0")).unwrap());
+    assert!(iter.seek(SeekKey::Key(b"k1")).unwrap());
+    assert!(iter.seek(SeekKey::Key(b"k11")).unwrap());
+    assert!(!iter.seek(SeekKey::Key(b"k5")).unwrap());
+    assert!(iter.seek(SeekKey::Key(b"k0")).unwrap());
+    assert!(iter.seek(SeekKey::Key(b"k1")).unwrap());
+    assert!(iter.seek(SeekKey::Key(b"k11")).unwrap());
+    assert!(!iter.seek(SeekKey::Key(b"k5")).unwrap());
+
+    assert!(iter.seek(SeekKey::Key(b"k4")).unwrap());
+    assert!(iter.prev().unwrap());
+    assert!(iter.next().unwrap());
+    assert!(!iter.next().unwrap());
     // Once iterator is invalid, it can't be reverted.
     //iter.prev();
     //assert!(!iter.valid());
@@ -188,7 +181,7 @@ fn test_send_iterator() {
         let (tx, rx) = mpsc::channel();
         let j = thread::spawn(move || {
             rx.recv().unwrap();
-            iter.seek(SeekKey::Start);
+            iter.seek(SeekKey::Start).unwrap();
             assert_eq!(iter.key(), b"k1");
             assert_eq!(iter.value(), b"v1");
         });
@@ -230,36 +223,36 @@ fn test_seek_for_prev() {
         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());
+        iter.seek_for_prev(SeekKey::Key(b"k1-2")).unwrap();
+        assert!(iter.valid().unwrap());
         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());
+        iter.seek_for_prev(SeekKey::Key(b"k1-3")).unwrap();
+        assert!(iter.valid().unwrap());
         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());
+        iter.seek_for_prev(SeekKey::Start).unwrap();
+        assert!(iter.valid().unwrap());
         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());
+        iter.seek_for_prev(SeekKey::End).unwrap();
+        assert!(iter.valid().unwrap());
         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());
+        iter.seek_for_prev(SeekKey::Key(b"k0-0")).unwrap();
+        assert!(!iter.valid().unwrap());
 
         let mut iter = db.iter();
-        iter.seek_for_prev(SeekKey::Key(b"k2-0"));
-        assert!(iter.valid());
+        iter.seek_for_prev(SeekKey::Key(b"k2-0")).unwrap();
+        assert!(iter.valid().unwrap());
         assert_eq!(iter.key(), b"k1-3");
         assert_eq!(iter.value(), b"d");
     }
@@ -280,7 +273,7 @@ fn read_with_upper_bound() {
         let mut readopts = ReadOptions::new();
         readopts.set_iterate_upper_bound(b"k2");
         let mut iter = db.iter_opt(readopts);
-        iter.seek(SeekKey::Start);
+        iter.seek(SeekKey::Start).unwrap();
         let vec = next_collect(&mut iter);
         assert_eq!(vec.len(), 2);
     }
@@ -338,12 +331,12 @@ fn test_total_order_seek() {
     let mut iter = db.iter_opt(ropts);
     // only iterate sst files and memtables that contain keys with the same prefix as b"k1"
     // and the keys is iterated as valid when prefixed as b"k1"
-    iter.seek(SeekKey::Key(b"k1-0"));
+    iter.seek(SeekKey::Key(b"k1-0")).unwrap();
     let mut key_count = 0;
-    while iter.valid() {
+    while iter.valid().unwrap() {
         assert_eq!(keys[key_count], iter.key());
         key_count = key_count + 1;
-        iter.next();
+        iter.next().unwrap();
     }
     assert!(key_count == 3);
 
@@ -351,25 +344,25 @@ fn test_total_order_seek() {
     // only iterate sst files and memtables that contain keys with the same prefix as b"k1"
     // but it still can next/prev to the keys which is not prefixed as b"k1" with
     // prefix_same_as_start
-    iter.seek(SeekKey::Key(b"k1-0"));
+    iter.seek(SeekKey::Key(b"k1-0")).unwrap();
     let mut key_count = 0;
-    while iter.valid() {
+    while iter.valid().unwrap() {
         assert_eq!(keys[key_count], iter.key());
         key_count = key_count + 1;
-        iter.next();
+        iter.next().unwrap();
     }
     assert!(key_count == 4);
 
     let mut ropts = ReadOptions::new();
     ropts.set_total_order_seek(true);
     let mut iter = db.iter_opt(ropts);
-    iter.seek(SeekKey::Key(b"k1-0"));
+    iter.seek(SeekKey::Key(b"k1-0")).unwrap();
     let mut key_count = 0;
-    while iter.valid() {
+    while iter.valid().unwrap() {
         // iterator all sst files and memtables
         assert_eq!(keys[key_count], iter.key());
         key_count = key_count + 1;
-        iter.next();
+        iter.next().unwrap();
     }
     assert!(key_count == 9);
 }
@@ -403,12 +396,12 @@ fn test_fixed_suffix_seek() {
     db.flush(true).unwrap();
 
     let mut iter = db.iter();
-    iter.seek(SeekKey::Key(b"k-24yfae-8"));
+    iter.seek(SeekKey::Key(b"k-24yfae-8")).unwrap();
     let vec = prev_collect(&mut iter);
     assert!(vec.len() == 2);
 
     let mut iter = db.iter();
-    iter.seek(SeekKey::Key(b"k-24yfa-9"));
+    iter.seek(SeekKey::Key(b"k-24yfa-9")).unwrap();
     let vec = prev_collect(&mut iter);
     assert!(vec.len() == 0);
 }

tests/cases/test_prefix_extractor.rs

@@ -86,13 +86,13 @@ fn test_prefix_extractor_compatibility() {
         db.put_opt(b"k1-8", b"c", &wopts).unwrap();
 
         let mut iter = db.iter();
-        iter.seek(SeekKey::Key(b"k1-0"));
+        iter.seek(SeekKey::Key(b"k1-0")).unwrap();
         let mut key_count = 0;
-        while iter.valid() {
+        while iter.valid().unwrap() {
             // If sst file has no prefix bloom, don't use prefix seek model.
             assert_eq!(keys[key_count], iter.key());
             key_count = key_count + 1;
-            iter.next();
+            iter.next().unwrap();
         }
         assert!(key_count == 9);
     }

tests/cases/test_rocksdb_options.rs

@@ -626,12 +626,12 @@ fn test_read_options() {
 
     let keys = vec![b"k1", b"k2", b"k3"];
     let mut iter = db.iter_opt(read_opts);
-    iter.seek(SeekKey::Key(b"k1"));
+    iter.seek(SeekKey::Key(b"k1")).unwrap();
     let mut key_count = 0;
-    while iter.valid() {
+    while iter.valid().unwrap() {
         assert_eq!(keys[key_count], iter.key());
         key_count = key_count + 1;
-        iter.next();
+        iter.next().unwrap();
     }
     assert!(key_count == 3);
 }
@@ -649,11 +649,11 @@ fn test_readoptions_lower_bound() {
     let lower_bound = b"k2";
     read_opts.set_iterate_lower_bound(lower_bound.as_ref());
     let mut iter = db.iter_opt(read_opts);
-    iter.seek(SeekKey::Key(b"k3"));
+    iter.seek(SeekKey::Key(b"k3")).unwrap();
     let mut count = 0;
-    while iter.valid() {
+    while iter.valid().unwrap() {
         count += 1;
-        iter.prev();
+        iter.prev().unwrap();
     }
     assert_eq!(count, 2);
 }
@@ -731,15 +731,15 @@ fn test_vector_memtable_factory_options() {
     db.flush(true).unwrap();
 
     let mut iter = db.iter();
-    iter.seek(SeekKey::Start);
-    assert!(iter.valid());
+    iter.seek(SeekKey::Start).unwrap();
+    assert!(iter.valid().unwrap());
     assert_eq!(iter.key(), b"k1");
     assert_eq!(iter.value(), b"v1");
-    assert!(iter.next());
+    assert!(iter.next().unwrap());
     assert_eq!(iter.key(), b"k2");
     assert_eq!(iter.value(), b"v2");
-    assert!(!iter.next());
-    assert!(!iter.valid());
+    assert!(!iter.next().unwrap());
+    assert!(!iter.valid().unwrap());
 }
 
 #[test]

tests/cases/test_slice_transform.rs

@@ -77,8 +77,8 @@ fn test_slice_transform() {
     ];
 
     for key in invalid_seeks {
-        it.seek(SeekKey::Key(&key));
-        assert!(!it.valid());
+        it.seek(SeekKey::Key(&key)).unwrap();
+        assert!(!it.valid().unwrap());
     }
 
     let valid_seeks = vec![
@@ -88,8 +88,8 @@ fn test_slice_transform() {
     ];
 
     for (key, expect_key) in valid_seeks {
-        it.seek(SeekKey::Key(&key));
-        assert!(it.valid());
+        it.seek(SeekKey::Key(&key)).unwrap();
+        assert!(it.valid().unwrap());
         assert_eq!(it.key(), &*expect_key);
     }
 

tests/cases/test_table_properties.rs

@@ -282,7 +282,7 @@ fn test_table_properties_with_table_filter() {
     let mut iter = db.iter_opt(ropts);
     let key = b"key";
     let key5 = b"key5";
-    assert!(iter.seek(SeekKey::from(key.as_ref())));
+    assert!(iter.seek(SeekKey::from(key.as_ref())).unwrap());
     // First sst will be skipped
     assert_eq!(iter.key(), key5.as_ref());
 }