support more read/write options (#109)

librocksdb_sys/crocksdb/c.cc

@@ -2637,11 +2637,21 @@ void crocksdb_readoptions_set_tailing(
   opt->rep.tailing = v;
 }
 
+void crocksdb_readoptions_set_managed(crocksdb_readoptions_t *opt,
+                                      unsigned char v) {
+  opt->rep.managed = v;
+}
+
 void crocksdb_readoptions_set_readahead_size(
     crocksdb_readoptions_t* opt, size_t v) {
   opt->rep.readahead_size = v;
 }
 
+void crocksdb_readoptions_set_max_skippable_internal_keys(
+    crocksdb_readoptions_t *opt, uint64_t n) {
+  opt->rep.max_skippable_internal_keys = n;
+}
+
 void crocksdb_readoptions_set_total_order_seek(crocksdb_readoptions_t* opt,
     unsigned char v) {
   opt->rep.total_order_seek = v;
@@ -2652,6 +2662,21 @@ void crocksdb_readoptions_set_prefix_same_as_start(crocksdb_readoptions_t* opt,
   opt->rep.prefix_same_as_start = v;
 }
 
+void crocksdb_readoptions_set_pin_data(crocksdb_readoptions_t *opt,
+                                       unsigned char v) {
+  opt->rep.pin_data = v;
+}
+
+void crocksdb_readoptions_set_background_purge_on_iterator_cleanup(
+    crocksdb_readoptions_t *opt, unsigned char v) {
+  opt->rep.background_purge_on_iterator_cleanup = v;
+}
+
+void crocksdb_readoptions_set_ignore_range_deletions(
+    crocksdb_readoptions_t *opt, unsigned char v) {
+  opt->rep.ignore_range_deletions = v;
+}
+
 crocksdb_writeoptions_t* crocksdb_writeoptions_create() {
   return new crocksdb_writeoptions_t;
 }
@@ -2669,6 +2694,21 @@ void crocksdb_writeoptions_disable_wal(crocksdb_writeoptions_t* opt, int disable
   opt->rep.disableWAL = disable;
 }
 
+void crocksdb_writeoptions_set_ignore_missing_column_families(
+    crocksdb_writeoptions_t *opt, unsigned char v) {
+  opt->rep.ignore_missing_column_families = v;
+}
+
+void crocksdb_writeoptions_set_no_slowdown(crocksdb_writeoptions_t *opt,
+                                           unsigned char v) {
+  opt->rep.no_slowdown = v;
+}
+
+void crocksdb_writeoptions_set_low_pri(crocksdb_writeoptions_t *opt,
+                                       unsigned char v) {
+  opt->rep.low_pri = v;
+}
+
 crocksdb_compactoptions_t* crocksdb_compactoptions_create() {
   return new crocksdb_compactoptions_t;
 }

librocksdb_sys/crocksdb/crocksdb/c.h

@@ -1081,12 +1081,25 @@ extern C_ROCKSDB_LIBRARY_API void crocksdb_readoptions_set_read_tier(
     crocksdb_readoptions_t*, int);
 extern C_ROCKSDB_LIBRARY_API void crocksdb_readoptions_set_tailing(
     crocksdb_readoptions_t*, unsigned char);
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_readoptions_set_managed(crocksdb_readoptions_t *, unsigned char);
 extern C_ROCKSDB_LIBRARY_API void crocksdb_readoptions_set_readahead_size(
     crocksdb_readoptions_t*, size_t);
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_readoptions_set_max_skippable_internal_keys(crocksdb_readoptions_t *,
+                                                     uint64_t);
 extern C_ROCKSDB_LIBRARY_API void crocksdb_readoptions_set_total_order_seek(
     crocksdb_readoptions_t*, unsigned char);
 extern C_ROCKSDB_LIBRARY_API void crocksdb_readoptions_set_prefix_same_as_start(
     crocksdb_readoptions_t*, unsigned char);
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_readoptions_set_pin_data(crocksdb_readoptions_t *, unsigned char);
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_readoptions_set_background_purge_on_iterator_cleanup(
+    crocksdb_readoptions_t *, unsigned char);
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_readoptions_set_ignore_range_deletions(crocksdb_readoptions_t *,
+                                                unsigned char);
 
 /* Write options */
 
@@ -1098,6 +1111,13 @@ extern C_ROCKSDB_LIBRARY_API void crocksdb_writeoptions_set_sync(
     crocksdb_writeoptions_t*, unsigned char);
 extern C_ROCKSDB_LIBRARY_API void crocksdb_writeoptions_disable_wal(
     crocksdb_writeoptions_t* opt, int disable);
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_writeoptions_set_ignore_missing_column_families(
+    crocksdb_writeoptions_t *, unsigned char);
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_writeoptions_set_no_slowdown(crocksdb_writeoptions_t *, unsigned char);
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_writeoptions_set_low_pri(crocksdb_writeoptions_t *, unsigned char);
 
 /* Compact range options */
 

librocksdb_sys/src/lib.rs

@@ -400,6 +400,10 @@ extern "C" {
     pub fn crocksdb_writeoptions_destroy(writeopts: *mut DBWriteOptions);
     pub fn crocksdb_writeoptions_set_sync(writeopts: *mut DBWriteOptions, v: bool);
     pub fn crocksdb_writeoptions_disable_wal(writeopts: *mut DBWriteOptions, v: c_int);
+    pub fn crocksdb_writeoptions_set_ignore_missing_column_families(writeopts: *mut DBWriteOptions,
+                                                                    v: bool);
+    pub fn crocksdb_writeoptions_set_no_slowdown(writeopts: *mut DBWriteOptions, v: bool);
+    pub fn crocksdb_writeoptions_set_low_pri(writeopts: *mut DBWriteOptions, v: bool);
     pub fn crocksdb_put(db: *mut DBInstance,
                         writeopts: *mut DBWriteOptions,
                         k: *const u8,
@@ -426,8 +430,16 @@ extern "C" {
                                                         kLen: size_t);
     pub fn crocksdb_readoptions_set_read_tier(readopts: *mut DBReadOptions, tier: c_int);
     pub fn crocksdb_readoptions_set_tailing(readopts: *mut DBReadOptions, v: bool);
+    pub fn crocksdb_readoptions_set_managed(readopts: *mut DBReadOptions, v: bool);
+    pub fn crocksdb_readoptions_set_readahead_size(readopts: *mut DBReadOptions, size: size_t);
+    pub fn crocksdb_readoptions_set_max_skippable_internal_keys(readopts: *mut DBReadOptions,
+                                                                n: uint64_t);
     pub fn crocksdb_readoptions_set_total_order_seek(readopts: *mut DBReadOptions, v: bool);
     pub fn crocksdb_readoptions_set_prefix_same_as_start(readopts: *mut DBReadOptions, v: bool);
+    pub fn crocksdb_readoptions_set_pin_data(readopts: *mut DBReadOptions, v: bool);
+    pub fn crocksdb_readoptions_set_background_purge_on_iterator_cleanup
+    (readopts: *mut DBReadOptions, v: bool);
+    pub fn crocksdb_readoptions_set_ignore_range_deletions(readopts: *mut DBReadOptions, v: bool);
 
     pub fn crocksdb_get(db: *const DBInstance,
                         readopts: *const DBReadOptions,

src/rocksdb_options.rs

@@ -192,6 +192,13 @@ impl ReadOptions {
     // TODO add snapshot wrapper structs with proper destructors;
     // that struct needs an "iterator" impl too.
     #[allow(dead_code)]
+
+    pub fn set_verify_checksums(&mut self, v: bool) {
+        unsafe {
+            crocksdb_ffi::crocksdb_readoptions_set_verify_checksums(self.inner, v);
+        }
+    }
+
     pub fn fill_cache(&mut self, v: bool) {
         unsafe {
             crocksdb_ffi::crocksdb_readoptions_set_fill_cache(self.inner, v);
@@ -211,6 +218,36 @@ impl ReadOptions {
         }
     }
 
+    pub fn set_read_tier(&mut self, tier: c_int) {
+        unsafe {
+            crocksdb_ffi::crocksdb_readoptions_set_read_tier(self.inner, tier);
+        }
+    }
+
+    pub fn set_tailing(&mut self, v: bool) {
+        unsafe {
+            crocksdb_ffi::crocksdb_readoptions_set_tailing(self.inner, v);
+        }
+    }
+
+    pub fn set_managed(&mut self, v: bool) {
+        unsafe {
+            crocksdb_ffi::crocksdb_readoptions_set_managed(self.inner, v);
+        }
+    }
+
+    pub fn set_readahead_size(&mut self, size: size_t) {
+        unsafe {
+            crocksdb_ffi::crocksdb_readoptions_set_readahead_size(self.inner, size);
+        }
+    }
+
+    pub fn set_max_skippable_internal_keys(&mut self, n: u64) {
+        unsafe {
+            crocksdb_ffi::crocksdb_readoptions_set_max_skippable_internal_keys(self.inner, n);
+        }
+    }
+
     pub fn set_total_order_seek(&mut self, v: bool) {
         unsafe {
             crocksdb_ffi::crocksdb_readoptions_set_total_order_seek(self.inner, v);
@@ -223,6 +260,25 @@ impl ReadOptions {
         }
     }
 
+    pub fn set_pin_data(&mut self, v: bool) {
+        unsafe {
+            crocksdb_ffi::crocksdb_readoptions_set_pin_data(self.inner, v);
+        }
+    }
+
+    pub fn set_background_purge_on_iterator_cleanup(&mut self, v: bool) {
+        unsafe {
+            crocksdb_ffi::crocksdb_readoptions_set_background_purge_on_iterator_cleanup(self.inner,
+                                                                                        v);
+        }
+    }
+
+    pub fn set_ignore_range_deletions(&mut self, v: bool) {
+        unsafe {
+            crocksdb_ffi::crocksdb_readoptions_set_ignore_range_deletions(self.inner, v);
+        }
+    }
+
     pub unsafe fn get_inner(&self) -> *const DBReadOptions {
         self.inner
     }
@@ -269,6 +325,24 @@ impl WriteOptions {
             }
         }
     }
+
+    pub fn set_ignore_missing_column_families(&mut self, v: bool) {
+        unsafe {
+            crocksdb_ffi::crocksdb_writeoptions_set_ignore_missing_column_families(self.inner, v);
+        }
+    }
+
+    pub fn set_no_slowdown(&mut self, v: bool) {
+        unsafe {
+            crocksdb_ffi::crocksdb_writeoptions_set_no_slowdown(self.inner, v);
+        }
+    }
+
+    pub fn set_low_pri(&mut self, v: bool) {
+        unsafe {
+            crocksdb_ffi::crocksdb_writeoptions_set_low_pri(self.inner, v);
+        }
+    }
 }
 
 pub struct CompactOptions {

tests/test_rocksdb_options.rs

@@ -11,8 +11,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use rocksdb::{DB, ColumnFamilyOptions, DBOptions, BlockBasedOptions, WriteOptions, SliceTransform,
-              Writable, CompactOptions};
+use rocksdb::{DB, ColumnFamilyOptions, DBOptions, BlockBasedOptions, WriteOptions, ReadOptions,
+              SliceTransform, Writable, CompactOptions, SeekKey};
 use rocksdb::crocksdb_ffi::{DBStatisticsHistogramType as HistogramType,
                             DBStatisticsTickerType as TickerType, DBInfoLogLevel as InfoLogLevel,
                             CompactionPriority, DBCompressionType};
@@ -462,3 +462,55 @@ fn test_db_paths() {
     opts.set_db_paths(&[(tmp_path.path(), 1073741824 as u64)]);
     DB::open(opts, path.path().to_str().unwrap()).unwrap();
 }
+
+#[test]
+fn test_write_options() {
+    let path = TempDir::new("_rust_rocksdb_write_options").expect("");
+    let db = DB::open_default(path.path().to_str().unwrap()).unwrap();
+
+    let mut write_opts = WriteOptions::new();
+    write_opts.set_sync(true);
+    write_opts.disable_wal(true);
+    write_opts.set_ignore_missing_column_families(true);
+    write_opts.set_no_slowdown(true);
+    write_opts.set_low_pri(true);
+    db.put_opt(b"k1", b"a", &write_opts).unwrap();
+    db.put_opt(b"k2", b"b", &write_opts).unwrap();
+    db.put_opt(b"k3", b"c", &write_opts).unwrap();
+    assert_eq!(db.get(b"k1").unwrap().unwrap(), b"a");
+    assert_eq!(db.get(b"k2").unwrap().unwrap(), b"b");
+    assert_eq!(db.get(b"k3").unwrap().unwrap(), b"c");
+}
+
+#[test]
+fn test_read_options() {
+    let path = TempDir::new("_rust_rocksdb_write_options").expect("");
+    let db = DB::open_default(path.path().to_str().unwrap()).unwrap();
+
+    let mut read_opts = ReadOptions::new();
+    read_opts.set_verify_checksums(true);
+    read_opts.fill_cache(true);
+    read_opts.set_tailing(true);
+    read_opts.set_managed(true);
+    read_opts.set_pin_data(true);
+    read_opts.set_background_purge_on_iterator_cleanup(true);
+    read_opts.set_ignore_range_deletions(true);
+    read_opts.set_max_skippable_internal_keys(0);
+    read_opts.set_readahead_size(0);
+    read_opts.set_read_tier(0);
+
+    db.put(b"k1", b"a").unwrap();
+    db.put(b"k2", b"b").unwrap();
+    db.put(b"k3", b"c").unwrap();
+
+    let keys = vec![b"k1", b"k2", b"k3"];
+    let mut iter = db.iter_opt(read_opts);
+    iter.seek(SeekKey::Key(b"k1"));
+    let mut key_count = 0;
+    while iter.valid() {
+        assert_eq!(keys[key_count], iter.key());
+        key_count = key_count + 1;
+        iter.next();
+    }
+    assert!(key_count == 3);
+}
\ No newline at end of file