Merge pull request #14 from siddontang/siddontang/delete-file-in-range

librocksdb_sys/src/lib.rs

@@ -456,6 +456,19 @@ extern "C" {
                                         range_limit_key: *const *const u8,
                                         range_limit_key_len: *const size_t,
                                         sizes: *mut uint64_t);
+    pub fn rocksdb_delete_file_in_range(db: DBInstance,
+                                        range_start_key: *const u8,
+                                        range_start_key_len: size_t,
+                                        range_limit_key: *const u8,
+                                        range_limit_key_len: size_t,
+                                        err: *mut *const i8);
+    pub fn rocksdb_delete_file_in_range_cf(db: DBInstance,
+                                           cf: DBCFHandle,
+                                           range_start_key: *const u8,
+                                           range_start_key_len: size_t,
+                                           range_limit_key: *const u8,
+                                           range_limit_key_len: size_t,
+                                           err: *mut *const i8);
     pub fn rocksdb_property_value(db: DBInstance,
                                   propname: *const c_char)
                                   -> *mut c_char;
@@ -538,6 +551,14 @@ mod test {
             assert_eq!(sizes.len(), 1);
             assert!(sizes[0] > 0);
 
+            rocksdb_delete_file_in_range(db,
+                                         b"\x00\x00".as_ptr(),
+                                         2,
+                                         b"\xff\x00".as_ptr(),
+                                         2,
+                                         &mut err);
+            assert!(err.is_null(), error_message(err));
+
             let propname = CString::new("rocksdb.total-sst-files-size")
                 .unwrap();
             let value = rocksdb_property_value(db, propname.as_ptr());

src/rocksdb.rs

@@ -831,6 +831,48 @@ impl DB {
         sizes
     }
 
+    pub fn delete_file_in_range(&self,
+                                start_key: &[u8],
+                                end_key: &[u8])
+                                -> Result<(), String> {
+        unsafe {
+            let mut err: *const i8 = 0 as *const i8;
+
+            rocksdb_ffi::rocksdb_delete_file_in_range(self.inner,
+                                        start_key.as_ptr(),
+                                        start_key.len() as size_t,
+                                        end_key.as_ptr(),
+                                        end_key.len() as size_t,
+                                        &mut err);
+            if !err.is_null() {
+                return Err(error_message(err));
+            }
+            Ok(())
+        }
+    }
+
+    pub fn delete_file_in_range_cf(&self,
+                                   cf: DBCFHandle,
+                                   start_key: &[u8],
+                                   end_key: &[u8])
+                                   -> Result<(), String> {
+        unsafe {
+            let mut err: *const i8 = 0 as *const i8;
+
+            rocksdb_ffi::rocksdb_delete_file_in_range_cf(self.inner,
+                                        cf,
+                                        start_key.as_ptr(),
+                                        start_key.len() as size_t,
+                                        end_key.as_ptr(),
+                                        end_key.len() as size_t,
+                                        &mut err);
+            if !err.is_null() {
+                return Err(error_message(err));
+            }
+            Ok(())
+        }
+    }
+
     pub fn get_property_value(&self, name: &str) -> Option<String> {
         self.get_property_value_cf_opt(None, name)
     }

src/rocksdb_options.rs

@@ -91,7 +91,9 @@ impl BlockBasedOptions {
         }
     }
 
-    pub fn set_bloom_filter(&mut self, bits_per_key: c_int, block_based: bool) {
+    pub fn set_bloom_filter(&mut self,
+                            bits_per_key: c_int,
+                            block_based: bool) {
         unsafe {
             let bloom = if block_based {
                 rocksdb_ffi::rocksdb_filterpolicy_create_bloom(bits_per_key)