Merge remote-tracking branch 'ngaut/master' into siddontang/delete-file-in-range

src/rocksdb.rs

@@ -68,19 +68,15 @@ impl<'a> From<&'a [u8]> for SeekKey<'a> {
 }
 
 impl<'a> DBIterator<'a> {
-    fn new(db: &'a DB, readopts: &ReadOptions, key: SeekKey) -> DBIterator<'a> {
+    fn new(db: &'a DB, readopts: &ReadOptions) -> DBIterator<'a> {
         unsafe {
             let iterator = rocksdb_ffi::rocksdb_create_iterator(db.inner,
                                                                 readopts.inner);
 
-            let mut rv = DBIterator {
+            DBIterator {
                 db: db,
                 inner: iterator,
-            };
-
-            rv.seek(key);
-
-            rv
+            }
         }
     }
 
@@ -176,7 +172,7 @@ impl<'a> DBIterator<'a> {
 
 pub type Kv = (Vec<u8>, Vec<u8>);
 
-impl<'a> Iterator for DBIterator<'a> {
+impl<'b, 'a> Iterator for &'b mut DBIterator<'a> {
     type Item = Kv;
 
     fn next(&mut self) -> Option<Kv> {
@@ -206,10 +202,10 @@ impl<'a> Snapshot<'a> {
         }
     }
 
-    pub fn iter(&self, key: SeekKey) -> DBIterator {
+    pub fn iter(&self) -> DBIterator {
         let mut readopts = ReadOptions::new();
         readopts.set_snapshot(self);
-        DBIterator::new(self.db, &readopts, key)
+        DBIterator::new(self.db, &readopts)
     }
 
     pub fn get(&self, key: &[u8]) -> Result<Option<DBVector>, String> {
@@ -579,9 +575,9 @@ impl DB {
         self.cfs.get(name)
     }
 
-    pub fn iter(&self, key: SeekKey) -> DBIterator {
+    pub fn iter(&self) -> DBIterator {
         let opts = ReadOptions::new();
-        DBIterator::new(&self, &opts, key)
+        DBIterator::new(&self, &opts)
     }
 
     pub fn iter_cf(&self,
@@ -1127,8 +1123,9 @@ mod test {
         db.put(b"k1", b"v1111").expect("");
         db.put(b"k2", b"v2222").expect("");
         db.put(b"k3", b"v3333").expect("");
-        let iter = db.iter(SeekKey::Start);
-        for (k, v) in iter {
+        let mut iter = db.iter();
+        iter.seek(SeekKey::Start);
+        for (k, v) in &mut iter {
             println!("Hello {}: {}",
                      str::from_utf8(&*k).unwrap(),
                      str::from_utf8(&*v).unwrap());

test/test_iterator.rs

 use rocksdb::{DB, Writable, SeekKey, DBIterator, Kv};
 use tempdir::TempDir;
 
-fn prev_collect<'a>(mut iter: DBIterator<'a>) -> Vec<Kv> {
+fn prev_collect<'a>(iter: &mut DBIterator<'a>) -> Vec<Kv> {
     let mut buf = vec![];
     while iter.valid() {
         buf.push(iter.kv().unwrap());
@@ -33,32 +33,35 @@ pub fn test_iterator() {
                         (k2.to_vec(), v2.to_vec()),
                         (k3.to_vec(), v3.to_vec())];
 
-    let mut iter = db.iter(SeekKey::Start);
+    let mut iter = db.iter();
+    
+    iter.seek(SeekKey::Start);
     assert_eq!(iter.collect::<Vec<_>>(), expected);
 
     // Test that it's idempotent
-    iter = db.iter(SeekKey::Start);
+    iter.seek(SeekKey::Start);
     assert_eq!(iter.collect::<Vec<_>>(), expected);
 
     // Test it in reverse a few times
-    iter = db.iter(SeekKey::End);
-    let mut tmp_vec = prev_collect(iter);
+    iter.seek(SeekKey::End);
+    let mut tmp_vec = prev_collect(&mut iter);
     tmp_vec.reverse();
     assert_eq!(tmp_vec, expected);
 
-    iter = db.iter(SeekKey::End);
-    let mut tmp_vec = prev_collect(iter);
+    iter.seek(SeekKey::End);
+    let mut tmp_vec = prev_collect(&mut iter);
     tmp_vec.reverse();
     assert_eq!(tmp_vec, expected);
 
     // Try it forward again
-    iter = db.iter(SeekKey::Start);
+    iter.seek(SeekKey::Start);
     assert_eq!(iter.collect::<Vec<_>>(), expected);
 
-    iter = db.iter(SeekKey::Start);
+    iter.seek(SeekKey::Start);
     assert_eq!(iter.collect::<Vec<_>>(), expected);
 
-    let old_iterator = db.iter(SeekKey::Start);
+    let mut old_iterator = db.iter();
+    old_iterator.seek(SeekKey::Start);
     let p = db.put(&*k4, &*v4);
     assert!(p.is_ok());
     let expected2 = vec![(k1.to_vec(), v1.to_vec()),
@@ -67,20 +70,21 @@ pub fn test_iterator() {
                          (k4.to_vec(), v4.to_vec())];
     assert_eq!(old_iterator.collect::<Vec<_>>(), expected);
 
-    iter = db.iter(SeekKey::Start);
+    iter = db.iter();
+    iter.seek(SeekKey::Start);
     assert_eq!(iter.collect::<Vec<_>>(), expected2);
 
-    iter = db.iter(SeekKey::Key(k2));
+    iter.seek(SeekKey::Key(k2));
     let expected = vec![(k2.to_vec(), v2.to_vec()),
                         (k3.to_vec(), v3.to_vec()),
                         (k4.to_vec(), v4.to_vec())];
     assert_eq!(iter.collect::<Vec<_>>(), expected);
 
-    iter = db.iter(SeekKey::Key(k2));
+    iter.seek(SeekKey::Key(k2));
     let expected = vec![(k2.to_vec(), v2.to_vec()), (k1.to_vec(), v1.to_vec())];
-    assert_eq!(prev_collect(iter), expected);
+    assert_eq!(prev_collect(&mut iter), expected);
 
-    iter = db.iter(SeekKey::Key(b"k0"));
+    iter.seek(SeekKey::Key(b"k0"));
     assert!(iter.valid());
     iter.seek(SeekKey::Key(b"k1"));
     assert!(iter.valid());