*: support getting sequence number

librocksdb_sys/crocksdb/c.cc

@@ -1101,6 +1101,11 @@ void crocksdb_release_snapshot(
   delete snapshot;
 }
 
+uint64_t crocksdb_get_snapshot_sequence_number(
+    const crocksdb_snapshot_t* snapshot) {
+  return snapshot->rep->GetSequenceNumber();
+}
+
 char* crocksdb_property_value(
     crocksdb_t* db,
     const char* propname) {
@@ -1269,9 +1274,11 @@ void crocksdb_sync_wal(
   SaveError(errptr, db->rep->SyncWAL());
 }
 
-void crocksdb_disable_file_deletions(
-    crocksdb_t* db,
-    char** errptr) {
+uint64_t crocksdb_get_latest_sequence_number(crocksdb_t* db) {
+  return db->rep->GetLatestSequenceNumber();
+}
+
+void crocksdb_disable_file_deletions(crocksdb_t* db, char** errptr) {
   SaveError(errptr, db->rep->DisableFileDeletions());
 }
 

librocksdb_sys/crocksdb/crocksdb/c.h

@@ -378,6 +378,8 @@ extern C_ROCKSDB_LIBRARY_API const crocksdb_snapshot_t* crocksdb_create_snapshot
 
 extern C_ROCKSDB_LIBRARY_API void crocksdb_release_snapshot(
     crocksdb_t* db, const crocksdb_snapshot_t* snapshot);
+extern C_ROCKSDB_LIBRARY_API uint64_t
+crocksdb_get_snapshot_sequence_number(const crocksdb_snapshot_t* snapshot);
 
 /* Returns NULL if property name is unknown.
    Else returns a pointer to a malloc()-ed null-terminated value. */
@@ -450,6 +452,9 @@ extern C_ROCKSDB_LIBRARY_API void crocksdb_flush_wal(
 extern C_ROCKSDB_LIBRARY_API void crocksdb_sync_wal(
     crocksdb_t* db, char** errptr);
 
+extern C_ROCKSDB_LIBRARY_API uint64_t
+crocksdb_get_latest_sequence_number(crocksdb_t* db);
+
 extern C_ROCKSDB_LIBRARY_API void crocksdb_disable_file_deletions(crocksdb_t* db,
                                                                char** errptr);
 

librocksdb_sys/src/lib.rs

@@ -709,6 +709,7 @@ extern "C" {
     ) -> *mut DBIterator;
     pub fn crocksdb_create_snapshot(db: *mut DBInstance) -> *const DBSnapshot;
     pub fn crocksdb_release_snapshot(db: *mut DBInstance, snapshot: *const DBSnapshot);
+    pub fn crocksdb_get_snapshot_sequence_number(snapshot: *const DBSnapshot) -> u64;
 
     pub fn crocksdb_delete(
         db: *mut DBInstance,
@@ -1003,6 +1004,8 @@ extern "C" {
     pub fn crocksdb_flush_wal(db: *mut DBInstance, sync: bool, err: *mut *mut c_char);
     pub fn crocksdb_sync_wal(db: *mut DBInstance, err: *mut *mut c_char);
 
+    pub fn crocksdb_get_latest_sequence_number(db: *mut DBInstance) -> u64;
+
     pub fn crocksdb_approximate_sizes(
         db: *mut DBInstance,
         num_ranges: c_int,

src/rocksdb.rs

@@ -326,6 +326,11 @@ impl<D: Deref<Target = DB>> Snapshot<D> {
         }
         self.db.get_cf_opt(cf, key, &readopts)
     }
+
+    /// Get the snapshot's sequence number.
+    pub fn get_sequence_number(&self) -> u64 {
+        unsafe { crocksdb_ffi::crocksdb_get_snapshot_sequence_number(self.snap.get_inner()) }
+    }
 }
 
 impl<D: Deref<Target = DB>> Drop for Snapshot<D> {
@@ -1011,6 +1016,11 @@ impl DB {
         }
     }
 
+    /// Get the sequence number of the most recent transaction.
+    pub fn get_latest_sequence_number(&self) -> u64 {
+        unsafe { crocksdb_ffi::crocksdb_get_latest_sequence_number(self.inner) }
+    }
+
     /// Return the approximate file system space used by keys in each ranges.
     ///
     /// Note that the returned sizes measure file system space usage, so
@@ -2869,4 +2879,22 @@ mod test {
             }
         }
     }
+
+    #[test]
+    fn test_sequence_number() {
+        let path = TempDir::new("_rust_rocksdb_sequence_number").expect("");
+
+        let mut opts = DBOptions::new();
+        opts.create_if_missing(true);
+        let db = DB::open(opts, path.path().to_str().unwrap()).unwrap();
+
+        let snap = db.snapshot();
+        let snap_seq = snap.get_sequence_number();
+        let seq1 = db.get_latest_sequence_number();
+        assert_eq!(snap_seq, seq1);
+
+        db.put(b"key", b"value").unwrap();
+        let seq2 = db.get_latest_sequence_number();
+        assert!(seq2 > seq1);
+    }
 }

src/titan.rs

@@ -3,7 +3,6 @@ use std::ops::Deref;
 
 use crocksdb_ffi::{self, DBCompressionType, DBTitanBlobIndex, DBTitanDBOptions};
 use librocksdb_sys::ctitandb_encode_blob_index;
-use std::ffi::c_void;
 use std::ops::DerefMut;
 use std::os::raw::c_double;
 use std::os::raw::c_int;
@@ -148,7 +147,7 @@ impl TitanBlobIndex {
             ctitandb_encode_blob_index(&self.inner, &mut value, &mut value_size);
             let slice = slice::from_raw_parts(value, value_size as usize);
             let vec = slice.to_vec();
-            libc::free(value as *mut c_void);
+            libc::free(value as *mut libc::c_void);
             vec
         }
     }