Add wrapper to set options dynamically (#194)

librocksdb_sys/crocksdb/c.cc

@@ -1187,6 +1187,24 @@ void crocksdb_enable_file_deletions(
   SaveError(errptr, db->rep->EnableFileDeletions(force));
 }
 
+crocksdb_options_t* crocksdb_get_db_options(crocksdb_t* db) {
+  auto opts = new crocksdb_options_t;
+  opts->rep = Options(db->rep->GetDBOptions(), ColumnFamilyOptions());
+  return opts;
+}
+
+void crocksdb_set_db_options(crocksdb_t* db,
+                             const char** names,
+                             const char** values,
+                             size_t num_options,
+                             char** errptr) {
+  std::unordered_map<std::string, std::string> options;
+  for (size_t i = 0; i < num_options; i++) {
+    options.emplace(names[i], values[i]);
+  }
+  SaveError(errptr, db->rep->SetDBOptions(options));
+}
+
 crocksdb_options_t* crocksdb_get_options_cf(
     const crocksdb_t* db,
     crocksdb_column_family_handle_t* column_family) {
@@ -1195,6 +1213,19 @@ crocksdb_options_t* crocksdb_get_options_cf(
   return options;
 }
 
+void crocksdb_set_options_cf(crocksdb_t* db,
+                             crocksdb_column_family_handle_t* cf,
+                             const char** names,
+                             const char** values,
+                             size_t num_options,
+                             char** errptr) {
+  std::unordered_map<std::string, std::string> options;
+  for (size_t i = 0; i < num_options; i++) {
+    options.emplace(names[i], values[i]);
+  }
+  SaveError(errptr, db->rep->SetOptions(cf->rep, options));
+}
+
 void crocksdb_destroy_db(
     const crocksdb_options_t* options,
     const char* name,
@@ -2278,6 +2309,10 @@ void crocksdb_options_set_max_background_jobs(crocksdb_options_t* opt, int n) {
   opt->rep.max_background_jobs = n;
 }
 
+int crocksdb_options_get_max_background_jobs(const crocksdb_options_t* opt) {
+  return opt->rep.max_background_jobs;
+}
+
 void crocksdb_options_set_max_log_file_size(crocksdb_options_t* opt, size_t v) {
   opt->rep.max_log_file_size = v;
 }
@@ -2340,6 +2375,10 @@ void crocksdb_options_set_disable_auto_compactions(crocksdb_options_t* opt, int
   opt->rep.disable_auto_compactions = disable;
 }
 
+int crocksdb_options_get_disable_auto_compactions(const crocksdb_options_t* opt) {
+  return opt->rep.disable_auto_compactions;
+}
+
 void crocksdb_options_set_delete_obsolete_files_period_micros(
     crocksdb_options_t* opt, uint64_t v) {
   opt->rep.delete_obsolete_files_period_micros = v;

librocksdb_sys/crocksdb/crocksdb/c.h

@@ -433,9 +433,27 @@ extern C_ROCKSDB_LIBRARY_API void crocksdb_disable_file_deletions(crocksdb_t* db
 extern C_ROCKSDB_LIBRARY_API void crocksdb_enable_file_deletions(
     crocksdb_t* db, unsigned char force, char** errptr);
 
+extern C_ROCKSDB_LIBRARY_API crocksdb_options_t*
+crocksdb_get_db_options(crocksdb_t* db);
+
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_set_db_options(crocksdb_t* db,
+                        const char** names,
+                        const char** values,
+                        size_t num_options,
+                        char** errptr);
+
 extern C_ROCKSDB_LIBRARY_API crocksdb_options_t* crocksdb_get_options_cf(
     const crocksdb_t* db, crocksdb_column_family_handle_t* column_family);
 
+extern C_ROCKSDB_LIBRARY_API void
+crocksdb_set_options_cf(crocksdb_t* db,
+                        crocksdb_column_family_handle_t* cf,
+                        const char** names,
+                        const char** values,
+                        size_t num_options,
+                        char** errptr);
+
 /* Management operations */
 
 extern C_ROCKSDB_LIBRARY_API void crocksdb_destroy_db(
@@ -844,6 +862,8 @@ crocksdb_options_set_max_write_buffer_number_to_maintain(crocksdb_options_t *,
                                                          int);
 extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_max_background_jobs(
     crocksdb_options_t*, int);
+extern C_ROCKSDB_LIBRARY_API int crocksdb_options_get_max_background_jobs(
+    const crocksdb_options_t*);
 extern C_ROCKSDB_LIBRARY_API void
 crocksdb_options_set_max_log_file_size(crocksdb_options_t *, size_t);
 extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_log_file_time_to_roll(
@@ -921,6 +941,8 @@ crocksdb_options_set_max_sequential_skip_in_iterations(crocksdb_options_t*,
                                                       uint64_t);
 extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_disable_auto_compactions(
     crocksdb_options_t*, int);
+extern C_ROCKSDB_LIBRARY_API int crocksdb_options_get_disable_auto_compactions(
+    const crocksdb_options_t*);
 extern C_ROCKSDB_LIBRARY_API void
 crocksdb_options_set_delete_obsolete_files_period_micros(crocksdb_options_t*,
                                                         uint64_t);

librocksdb_sys/src/lib.rs

@@ -316,7 +316,23 @@ macro_rules! ffi_try {
 // TODO audit the use of boolean arguments, b/c I think they need to be u8
 // instead...
 extern "C" {
+    pub fn crocksdb_get_db_options(db: *mut DBInstance) -> *mut Options;
+    pub fn crocksdb_set_db_options(
+        db: *mut DBInstance,
+        names: *const *const c_char,
+        values: *const *const c_char,
+        num_options: size_t,
+        errptr: *mut *mut c_char,
+    );
     pub fn crocksdb_get_options_cf(db: *mut DBInstance, cf: *mut DBCFHandle) -> *mut Options;
+    pub fn crocksdb_set_options_cf(
+        db: *mut DBInstance,
+        cf: *mut DBCFHandle,
+        names: *const *const c_char,
+        values: *const *const c_char,
+        num_options: size_t,
+        errptr: *mut *mut c_char,
+    );
     pub fn crocksdb_options_create() -> *mut Options;
     pub fn crocksdb_options_copy(opts: *const Options) -> *mut Options;
     pub fn crocksdb_options_destroy(opts: *mut Options);
@@ -457,7 +473,9 @@ extern "C" {
     );
     pub fn crocksdb_set_bottommost_compression(options: *mut Options, c: DBCompressionType);
     pub fn crocksdb_options_set_max_background_jobs(options: *mut Options, max_bg_jobs: c_int);
+    pub fn crocksdb_options_get_max_background_jobs(options: *const Options) -> c_int;
     pub fn crocksdb_options_set_disable_auto_compactions(options: *mut Options, v: c_int);
+    pub fn crocksdb_options_get_disable_auto_compactions(options: *const Options) -> c_int;
     pub fn crocksdb_options_set_report_bg_io_stats(options: *mut Options, v: c_int);
     pub fn crocksdb_options_set_compaction_readahead_size(options: *mut Options, v: size_t);
     pub fn crocksdb_options_set_wal_recovery_mode(options: *mut Options, mode: DBRecoveryMode);

src/rocksdb.rs

@@ -494,7 +494,6 @@ impl DB {
         })
     }
 
-
     pub fn destroy(opts: &DBOptions, path: &str) -> Result<(), String> {
         let cpath = CString::new(path.as_bytes()).unwrap();
         unsafe {
@@ -1195,6 +1194,35 @@ impl DB {
         self.opts.get_statistics_histogram(hist_type)
     }
 
+    pub fn get_db_options(&self) -> DBOptions {
+        unsafe {
+            let inner = crocksdb_ffi::crocksdb_get_db_options(self.inner);
+            DBOptions::from_raw(inner)
+        }
+    }
+
+    pub fn set_db_options(&self, options: &[(&str, &str)]) -> Result<(), String> {
+        unsafe {
+            let name_strs: Vec<_> = options
+                .iter()
+                .map(|&(n, _)| CString::new(n.as_bytes()).unwrap())
+                .collect();
+            let name_ptrs: Vec<_> = name_strs.iter().map(|s| s.as_ptr()).collect();
+            let value_strs: Vec<_> = options
+                .iter()
+                .map(|&(_, v)| CString::new(v.as_bytes()).unwrap())
+                .collect();
+            let value_ptrs: Vec<_> = value_strs.iter().map(|s| s.as_ptr()).collect();
+            ffi_try!(crocksdb_set_db_options(
+                self.inner,
+                name_ptrs.as_ptr() as *const *const c_char,
+                value_ptrs.as_ptr() as *const *const c_char,
+                options.len() as size_t
+            ));
+            Ok(())
+        }
+    }
+
     pub fn get_options(&self) -> ColumnFamilyOptions {
         let cf = self.cf_handle("default").unwrap();
         unsafe {
@@ -1210,6 +1238,29 @@ impl DB {
         }
     }
 
+    pub fn set_options_cf(&self, cf: &CFHandle, options: &[(&str, &str)]) -> Result<(), String> {
+        unsafe {
+            let name_strs: Vec<_> = options
+                .iter()
+                .map(|&(n, _)| CString::new(n.as_bytes()).unwrap())
+                .collect();
+            let name_ptrs: Vec<_> = name_strs.iter().map(|s| s.as_ptr()).collect();
+            let value_strs: Vec<_> = options
+                .iter()
+                .map(|&(_, v)| CString::new(v.as_bytes()).unwrap())
+                .collect();
+            let value_ptrs: Vec<_> = value_strs.iter().map(|s| s.as_ptr()).collect();
+            ffi_try!(crocksdb_set_options_cf(
+                self.inner,
+                cf.inner,
+                name_ptrs.as_ptr() as *const *const c_char,
+                value_ptrs.as_ptr() as *const *const c_char,
+                options.len() as size_t
+            ));
+            Ok(())
+        }
+    }
+
     pub fn ingest_external_file(
         &self,
         opt: &IngestExternalFileOptions,
@@ -2521,4 +2572,27 @@ mod test {
         assert!(count > 0);
         assert!(size > 0);
     }
+
+    #[test]
+    fn test_set_options() {
+        let mut opts = DBOptions::new();
+        opts.create_if_missing(true);
+        let path = TempDir::new("_rust_rocksdb_set_option").expect("");
+
+        let db = DB::open(opts, path.path().to_str().unwrap()).unwrap();
+        let cf = db.cf_handle("default").unwrap();
+
+        let db_opts = db.get_db_options();
+        assert_eq!(db_opts.get_max_background_jobs(), 2);
+        db.set_db_options(&[("max_background_jobs", "8")]).unwrap();
+        let db_opts = db.get_db_options();
+        assert_eq!(db_opts.get_max_background_jobs(), 8);
+
+        let cf_opts = db.get_options_cf(cf);
+        assert_eq!(cf_opts.get_disable_auto_compactions(), false);
+        db.set_options_cf(cf, &[("disable_auto_compactions", "true")])
+            .unwrap();
+        let cf_opts = db.get_options_cf(cf);
+        assert_eq!(cf_opts.get_disable_auto_compactions(), true);
+    }
 }

src/rocksdb_options.rs

@@ -565,6 +565,10 @@ impl DBOptions {
         DBOptions::default()
     }
 
+    pub unsafe fn from_raw(inner: *mut Options) -> DBOptions {
+        DBOptions { inner: inner }
+    }
+
     pub fn increase_parallelism(&mut self, parallelism: i32) {
         unsafe {
             crocksdb_ffi::crocksdb_options_increase_parallelism(self.inner, parallelism);
@@ -649,6 +653,10 @@ impl DBOptions {
         }
     }
 
+    pub fn get_max_background_jobs(&self) -> i32 {
+        unsafe { crocksdb_ffi::crocksdb_options_get_max_background_jobs(self.inner) as i32 }
+    }
+
     pub fn set_max_subcompactions(&mut self, n: u32) {
         unsafe {
             crocksdb_ffi::crocksdb_options_set_max_subcompactions(self.inner, n);
@@ -744,7 +752,6 @@ impl DBOptions {
         unsafe {
             let value = crocksdb_ffi::crocksdb_options_statistics_get_string(self.inner);
 
-
             if value.is_null() {
                 return None;
             }
@@ -1028,7 +1035,6 @@ impl ColumnFamilyOptions {
         }
     }
 
-
     pub fn compression(&mut self, t: DBCompressionType) {
         unsafe {
             crocksdb_ffi::crocksdb_options_set_compression(self.inner, t);
@@ -1101,7 +1107,6 @@ impl ColumnFamilyOptions {
         }
     }
 
-
     pub fn set_block_cache_size_mb(&mut self, cache_size: u64) {
         unsafe {
             crocksdb_ffi::crocksdb_options_optimize_for_point_lookup(self.inner, cache_size);
@@ -1233,6 +1238,10 @@ impl ColumnFamilyOptions {
         }
     }
 
+    pub fn get_disable_auto_compactions(&self) -> bool {
+        unsafe { crocksdb_ffi::crocksdb_options_get_disable_auto_compactions(self.inner) == 1 }
+    }
+
     pub fn set_block_based_table_factory(&mut self, factory: &BlockBasedOptions) {
         unsafe {
             crocksdb_ffi::crocksdb_options_set_block_based_table_factory(self.inner, factory.inner);