add single delete (#76)

librocksdb_sys/crocksdb/c.cc

@@ -683,6 +683,24 @@ void crocksdb_delete_cf(
         Slice(key, keylen)));
 }
 
+void crocksdb_single_delete(
+    crocksdb_t* db,
+    const crocksdb_writeoptions_t* options,
+    const char* key, size_t keylen,
+    char** errptr) {
+  SaveError(errptr, db->rep->SingleDelete(options->rep, Slice(key, keylen)));
+}
+
+void crocksdb_single_delete_cf(
+    crocksdb_t* db,
+    const crocksdb_writeoptions_t* options,
+    crocksdb_column_family_handle_t* column_family,
+    const char* key, size_t keylen,
+    char** errptr) {
+  SaveError(errptr, db->rep->SingleDelete(options->rep, column_family->rep,
+        Slice(key, keylen)));
+}
+
 void crocksdb_merge(
     crocksdb_t* db,
     const crocksdb_writeoptions_t* options,
@@ -1218,6 +1236,19 @@ void crocksdb_writebatch_delete_cf(
   b->rep.Delete(column_family->rep, Slice(key, klen));
 }
 
+void crocksdb_writebatch_single_delete(
+    crocksdb_writebatch_t* b,
+    const char* key, size_t klen) {
+  b->rep.SingleDelete(Slice(key, klen));
+}
+
+void crocksdb_writebatch_single_delete_cf(
+    crocksdb_writebatch_t* b,
+    crocksdb_column_family_handle_t* column_family,
+    const char* key, size_t klen) {
+  b->rep.SingleDelete(column_family->rep, Slice(key, klen));
+}
+
 void crocksdb_writebatch_deletev(
     crocksdb_writebatch_t* b,
     int num_keys, const char* const* keys_list,

librocksdb_sys/crocksdb/rocksdb/c.h

@@ -220,6 +220,15 @@ extern C_ROCKSDB_LIBRARY_API void crocksdb_delete_cf(
     crocksdb_column_family_handle_t* column_family, const char* key,
     size_t keylen, char** errptr);
 
+extern C_ROCKSDB_LIBRARY_API void crocksdb_single_delete(
+    crocksdb_t* db, const crocksdb_writeoptions_t* options, const char* key,
+    size_t keylen, char** errptr);
+
+extern C_ROCKSDB_LIBRARY_API void crocksdb_single_delete_cf(
+    crocksdb_t* db, const crocksdb_writeoptions_t* options,
+    crocksdb_column_family_handle_t* column_family, const char* key,
+    size_t keylen, char** errptr);
+
 extern C_ROCKSDB_LIBRARY_API void crocksdb_merge(
     crocksdb_t* db, const crocksdb_writeoptions_t* options, const char* key,
     size_t keylen, const char* val, size_t vallen, char** errptr);
@@ -418,6 +427,12 @@ extern C_ROCKSDB_LIBRARY_API void crocksdb_writebatch_delete(crocksdb_writebatch
 extern C_ROCKSDB_LIBRARY_API void crocksdb_writebatch_delete_cf(
     crocksdb_writebatch_t*, crocksdb_column_family_handle_t* column_family,
     const char* key, size_t klen);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_writebatch_single_delete(crocksdb_writebatch_t*,
+                                                          const char* key,
+                                                          size_t klen);
+extern C_ROCKSDB_LIBRARY_API void crocksdb_writebatch_single_delete_cf(
+    crocksdb_writebatch_t*, crocksdb_column_family_handle_t* column_family,
+    const char* key, size_t klen);
 extern C_ROCKSDB_LIBRARY_API void crocksdb_writebatch_deletev(
     crocksdb_writebatch_t* b, int num_keys, const char* const* keys_list,
     const size_t* keys_list_sizes);

librocksdb_sys/src/lib.rs

@@ -269,6 +269,17 @@ extern "C" {
                               k: *const u8,
                               kLen: size_t,
                               err: *mut *mut c_char);
+    pub fn crocksdb_single_delete(db: *mut DBInstance,
+                                  writeopts: *const DBWriteOptions,
+                                  k: *const u8,
+                                  kLen: size_t,
+                                  err: *mut *mut c_char);
+    pub fn crocksdb_single_delete_cf(db: *mut DBInstance,
+                                     writeopts: *const DBWriteOptions,
+                                     cf: *mut DBCFHandle,
+                                     k: *const u8,
+                                     kLen: size_t,
+                                     err: *mut *mut c_char);
     pub fn crocksdb_close(db: *mut DBInstance);
     pub fn crocksdb_destroy_db(options: *const DBOptions,
                                path: *const c_char,
@@ -368,6 +379,13 @@ extern "C" {
                                          cf: *mut DBCFHandle,
                                          key: *const u8,
                                          klen: size_t);
+    pub fn crocksdb_writebatch_single_delete(batch: *mut DBWriteBatch,
+                                             key: *const u8,
+                                             klen: size_t);
+    pub fn crocksdb_writebatch_single_delete_cf(batch: *mut DBWriteBatch,
+                                                cf: *mut DBCFHandle,
+                                                key: *const u8,
+                                                klen: size_t);
     pub fn crocksdb_writebatch_iterate(batch: *mut DBWriteBatch,
                                        state: *mut c_void,
                                        put_fn: extern "C" fn(state: *mut c_void,

src/rocksdb.rs

@@ -257,6 +257,8 @@ pub trait Writable {
     fn merge_cf(&self, cf: &CFHandle, key: &[u8], value: &[u8]) -> Result<(), String>;
     fn delete(&self, key: &[u8]) -> Result<(), String>;
     fn delete_cf(&self, cf: &CFHandle, key: &[u8]) -> Result<(), String>;
+    fn single_delete(&self, key: &[u8]) -> Result<(), String>;
+    fn single_delete_cf(&self, cf: &CFHandle, key: &[u8]) -> Result<(), String>;
 }
 
 /// A range of keys, `start_key` is included, but not `end_key`.
@@ -650,6 +652,31 @@ impl DB {
         }
     }
 
+    fn single_delete_opt(&self, key: &[u8], writeopts: &WriteOptions) -> Result<(), String> {
+        unsafe {
+            ffi_try!(crocksdb_single_delete(self.inner,
+                                            writeopts.inner,
+                                            key.as_ptr(),
+                                            key.len() as size_t));
+            Ok(())
+        }
+    }
+
+    fn single_delete_cf_opt(&self,
+                            cf: &CFHandle,
+                            key: &[u8],
+                            writeopts: &WriteOptions)
+                            -> Result<(), String> {
+        unsafe {
+            ffi_try!(crocksdb_single_delete_cf(self.inner,
+                                               writeopts.inner,
+                                               cf.inner,
+                                               key.as_ptr(),
+                                               key.len() as size_t));
+            Ok(())
+        }
+    }
+
     /// Flush all memtable data.
     ///
     /// Due to lack of abi, only default cf is supported.
@@ -892,6 +919,14 @@ impl Writable for DB {
     fn delete_cf(&self, cf: &CFHandle, key: &[u8]) -> Result<(), String> {
         self.delete_cf_opt(cf, key, &WriteOptions::new())
     }
+
+    fn single_delete(&self, key: &[u8]) -> Result<(), String> {
+        self.single_delete_opt(key, &WriteOptions::new())
+    }
+
+    fn single_delete_cf(&self, cf: &CFHandle, key: &[u8]) -> Result<(), String> {
+        self.single_delete_cf_opt(cf, key, &WriteOptions::new())
+    }
 }
 
 impl Default for WriteBatch {
@@ -1006,6 +1041,25 @@ impl Writable for WriteBatch {
             Ok(())
         }
     }
+
+    fn single_delete(&self, key: &[u8]) -> Result<(), String> {
+        unsafe {
+            crocksdb_ffi::crocksdb_writebatch_single_delete(self.inner,
+                                                            key.as_ptr(),
+                                                            key.len() as size_t);
+            Ok(())
+        }
+    }
+
+    fn single_delete_cf(&self, cf: &CFHandle, key: &[u8]) -> Result<(), String> {
+        unsafe {
+            crocksdb_ffi::crocksdb_writebatch_single_delete_cf(self.inner,
+                                                               cf.inner,
+                                                               key.as_ptr(),
+                                                               key.len() as size_t);
+            Ok(())
+        }
+    }
 }
 
 pub struct DBVector {
@@ -1288,6 +1342,41 @@ mod test {
             assert!(name.to_str().unwrap().find("LOG").is_none());
         }
     }
+
+    #[test]
+    fn single_delete_test() {
+        let path = TempDir::new("_rust_rocksdb_singledeletetest").expect("");
+        let db = DB::open_default(path.path().to_str().unwrap()).unwrap();
+
+        db.put(b"a", b"v1").unwrap();
+        let a = db.get(b"a");
+        assert_eq!(a.unwrap().unwrap().to_utf8().unwrap(), "v1");
+        db.single_delete(b"a").unwrap();
+        let a = db.get(b"a");
+        assert!(a.unwrap().is_none());
+
+        db.put(b"a", b"v2").unwrap();
+        let a = db.get(b"a");
+        assert_eq!(a.unwrap().unwrap().to_utf8().unwrap(), "v2");
+        db.single_delete(b"a").unwrap();
+        let a = db.get(b"a");
+        assert!(a.unwrap().is_none());
+
+        let cf_handle = db.cf_handle("default").unwrap();
+        db.put_cf(cf_handle, b"a", b"v3").unwrap();
+        let a = db.get_cf(cf_handle, b"a");
+        assert_eq!(a.unwrap().unwrap().to_utf8().unwrap(), "v3");
+        db.single_delete_cf(cf_handle, b"a").unwrap();
+        let a = db.get_cf(cf_handle, b"a");
+        assert!(a.unwrap().is_none());
+
+        db.put_cf(cf_handle, b"a", b"v4").unwrap();
+        let a = db.get_cf(cf_handle, b"a");
+        assert_eq!(a.unwrap().unwrap().to_utf8().unwrap(), "v4");
+        db.single_delete_cf(cf_handle, b"a").unwrap();
+        let a = db.get_cf(cf_handle, b"a");
+        assert!(a.unwrap().is_none());
+    }
 }
 
 #[test]