support compact range options (#51)

librocksdb_sys/src/lib.rs

@@ -43,6 +43,7 @@ pub enum DBRestoreOptions {}
 pub enum DBSliceTransform {}
 pub enum DBRateLimiter {}
 pub enum DBLogger {}
+pub enum DBCompactOptions {}
 
 pub fn new_bloom_filter(bits: c_int) -> *mut DBFilterPolicy {
     unsafe { crocksdb_filterpolicy_create_bloom(bits) }
@@ -584,8 +585,7 @@ extern "C" {
                              cf: *mut DBCFHandle,
                              options: *const DBFlushOptions,
                              err: *mut *mut c_char);
-    pub fn crocksdb_sync_wal(db: *mut DBInstance,
-                             err: *mut *mut c_char);
+    pub fn crocksdb_sync_wal(db: *mut DBInstance, err: *mut *mut c_char);
 
     pub fn crocksdb_approximate_sizes(db: *mut DBInstance,
                                       num_ranges: c_int,
@@ -602,6 +602,10 @@ extern "C" {
                                          range_limit_key: *const *const u8,
                                          range_limit_key_len: *const size_t,
                                          sizes: *mut uint64_t);
+    pub fn crocksdb_compactoptions_create() -> *mut DBCompactOptions;
+    pub fn crocksdb_compactoptions_destroy(opt: *mut DBCompactOptions);
+    pub fn crocksdb_compactoptions_set_exclusive_manual_compaction(opt: *mut DBCompactOptions,
+                                                                   v: bool);
     pub fn crocksdb_compact_range(db: *mut DBInstance,
                                   start_key: *const u8,
                                   start_key_len: size_t,
@@ -613,6 +617,13 @@ extern "C" {
                                      start_key_len: size_t,
                                      limit_key: *const u8,
                                      limit_key_len: size_t);
+    pub fn crocksdb_compact_range_cf_opt(db: *mut DBInstance,
+                                         cf: *mut DBCFHandle,
+                                         compact_options: *mut DBCompactOptions,
+                                         start_key: *const u8,
+                                         start_key_len: size_t,
+                                         limit_key: *const u8,
+                                         limit_key_len: size_t);
     pub fn crocksdb_delete_file_in_range(db: *mut DBInstance,
                                          range_start_key: *const u8,
                                          range_start_key_len: size_t,

src/lib.rs

@@ -35,5 +35,5 @@ pub use merge_operator::MergeOperands;
 pub use rocksdb::{DB, DBIterator, DBVector, Kv, SeekKey, Writable, WriteBatch, CFHandle, Range,
                   BackupEngine, SstFileWriter};
 pub use rocksdb_options::{BlockBasedOptions, Options, ReadOptions, WriteOptions, RestoreOptions,
-                          IngestExternalFileOptions, EnvOptions, HistogramData};
+                          IngestExternalFileOptions, EnvOptions, HistogramData, CompactOptions};
 pub use slice_transform::SliceTransform;

src/rocksdb.rs

@@ -17,7 +17,7 @@ use crocksdb_ffi::{self, DBWriteBatch, DBCFHandle, DBInstance, DBBackupEngine,
                    DBStatisticsTickerType, DBStatisticsHistogramType};
 use libc::{self, c_int, c_void, size_t};
 use rocksdb_options::{Options, ReadOptions, UnsafeSnap, WriteOptions, FlushOptions, EnvOptions,
-                      RestoreOptions, IngestExternalFileOptions, HistogramData};
+                      RestoreOptions, IngestExternalFileOptions, HistogramData, CompactOptions};
 use std::{fs, ptr, slice};
 use std::collections::BTreeMap;
 use std::collections::btree_map::Entry;
@@ -834,6 +834,24 @@ impl DB {
         }
     }
 
+    pub fn compact_range_cf_opt(&self,
+                                cf: &CFHandle,
+                                compact_options: &CompactOptions,
+                                start_key: Option<&[u8]>,
+                                end_key: Option<&[u8]>) {
+        unsafe {
+            let (start, s_len) = start_key.map_or((ptr::null(), 0), |k| (k.as_ptr(), k.len()));
+            let (end, e_len) = end_key.map_or((ptr::null(), 0), |k| (k.as_ptr(), k.len()));
+            crocksdb_ffi::crocksdb_compact_range_cf_opt(self.inner,
+                                                        cf.inner,
+                                                        compact_options.inner,
+                                                        start,
+                                                        s_len,
+                                                        end,
+                                                        e_len);
+        }
+    }
+
     pub fn delete_file_in_range(&self, start_key: &[u8], end_key: &[u8]) -> Result<(), String> {
         unsafe {
             ffi_try!(crocksdb_delete_file_in_range(self.inner,

src/rocksdb_options.rs

@@ -19,7 +19,7 @@ use comparator::{self, ComparatorCallback, compare_callback};
 use crocksdb_ffi::{self, DBOptions, DBWriteOptions, DBBlockBasedTableOptions, DBReadOptions,
                    DBRestoreOptions, DBCompressionType, DBRecoveryMode, DBSnapshot, DBInstance,
                    DBFlushOptions, DBStatisticsTickerType, DBStatisticsHistogramType,
-                   DBRateLimiter, DBInfoLogLevel};
+                   DBRateLimiter, DBInfoLogLevel, DBCompactOptions};
 use libc::{self, c_int, size_t, c_void};
 use merge_operator::{self, MergeOperatorCallback, full_merge_callback, partial_merge_callback};
 use merge_operator::MergeFn;
@@ -262,6 +262,30 @@ impl WriteOptions {
     }
 }
 
+pub struct CompactOptions {
+    pub inner: *mut DBCompactOptions,
+}
+
+impl CompactOptions {
+    pub fn new() -> CompactOptions {
+        unsafe { CompactOptions { inner: crocksdb_ffi::crocksdb_compactoptions_create() } }
+    }
+
+    pub fn set_exclusive_manual_compaction(&mut self, v: bool) {
+        unsafe {
+            crocksdb_ffi::crocksdb_compactoptions_set_exclusive_manual_compaction(self.inner, v);
+        }
+    }
+}
+
+impl Drop for CompactOptions {
+    fn drop(&mut self) {
+        unsafe {
+            crocksdb_ffi::crocksdb_compactoptions_destroy(self.inner);
+        }
+    }
+}
+
 pub struct Options {
     pub inner: *mut DBOptions,
     filter: Option<CompactionFilterHandle>,

tests/test_rocksdb_options.rs

@@ -11,7 +11,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use rocksdb::{DB, Options, BlockBasedOptions, WriteOptions, SliceTransform, Writable};
+use rocksdb::{DB, Options, BlockBasedOptions, WriteOptions, SliceTransform, Writable,
+              CompactOptions};
 use rocksdb::crocksdb_ffi::{DBStatisticsHistogramType as HistogramType,
                             DBStatisticsTickerType as TickerType, DBInfoLogLevel as InfoLogLevel};
 use std::path::Path;
@@ -275,6 +276,20 @@ fn test_set_level_compaction_dynamic_level_bytes() {
     DB::open(opts, path.path().to_str().unwrap()).unwrap();
 }
 
+#[test]
+fn test_compact_options() {
+    let path = TempDir::new("_rust_rocksdb_compact_options").expect("");
+    let db = DB::open_default(path.path().to_str().unwrap()).unwrap();
+    db.put(b"k1", b"v1").unwrap();
+    db.put(b"k2", b"v2").unwrap();
+    db.flush(true).unwrap();
+
+    let mut compact_opts = CompactOptions::new();
+    compact_opts.set_exclusive_manual_compaction(false);
+    let cf = db.cf_handle("default").unwrap();
+    db.compact_range_cf_opt(cf, &compact_opts, None, None);
+}
+
 #[test]
 fn test_direct_read_write() {
     let path = TempDir::new("_rust_rocksdb_direct_read_write").expect("");