fix CI fails

Author: yangweijian

librocksdb-sys/tests/ffi.rs

@@ -24,8 +24,8 @@
 )]
 
 use const_cstr::const_cstr;
+use haizhi_librocksdb_sys::*;
 use libc::*;
-use librocksdb_sys::*;
 use std::borrow::Cow;
 use std::env;
 use std::ffi::{CStr, CString};

src/checkpoint.rs

@@ -18,12 +18,12 @@
 //! [1]: https://github.com/facebook/rocksdb/wiki/Checkpoints
 
 use crate::AsColumnFamilyRef;
-use crate::{ffi, Error, DB};
-use libc::{c_char, int32_t};
+use crate::{ffi, Error};
+use libc::c_char;
 
 use crate::db::DBInner;
 use crate::ffi_util::to_cpath;
-use crate::{ColumnFamily, DBCommon, ThreadMode};
+use crate::{DBCommon, ThreadMode};
 use std::ffi::{CStr, CString};
 use std::fs::File;
 use std::io::{Read, Write};
@@ -215,13 +215,11 @@ impl<'db> Checkpoint<'db> {
         export_dir: P,
     ) -> Result<ExportImportFilesMetaData, Error> {
         let path = export_dir.as_ref();
-        let cpath = if let Ok(c) = CString::new(path.to_string_lossy().as_bytes()) {
-            c
-        } else {
-            return Err(Error::new(
-                "Failed to convert path to CString when creating DB checkpoint".to_owned(),
-            ));
-        };
+        let cpath = CString::new(path.to_string_lossy().as_bytes()).map_err(|err| {
+            Error::new(format!(
+                "Failed to convert path to CString when creating DB checkpoint: {err}"
+            ))
+        })?;
 
         let inner: *mut ffi::rocksdb_export_import_files_metadata_t;
 

src/db.rs

@@ -2036,7 +2036,7 @@ impl<T: ThreadMode, D: DBInner> DBCommon<T, D> {
                 true,
                 true,
                 files_size_error_margin,
-            ))
+            ));
         }
         Ok(sizes)
     }
@@ -2167,13 +2167,11 @@ impl<T: ThreadMode, D: DBInner> DBCommon<T, D> {
         opts: &Options,
         metadata: &ExportImportFilesMetaData,
     ) -> Result<*mut ffi::rocksdb_column_family_handle_t, Error> {
-        let cf_name = if let Ok(c) = CString::new(name.as_bytes()) {
-            c
-        } else {
-            return Err(Error::new(
-                "Failed to convert path to CString when creating cf".to_owned(),
-            ));
-        };
+        let cf_name = CString::new(name.as_bytes()).map_err(|err| {
+            Error::new(format!(
+                "Failed to convert path to CString when creating cf: {err}"
+            ))
+        })?;
         Ok(unsafe {
             ffi_try!(ffi::rocksdb_create_column_family_with_import(
                 self.inner.inner(),

src/properties.rs

@@ -15,18 +15,18 @@ macro_rules! property {
     };
 }
 
-/// "rocksdb.num-files-at-level<N>" - returns string containing the number
-/// of files at level <N>, where <N> is an ASCII representation of a
+/// "rocksdb.num-files-at-level`<N>`" - returns string containing the number
+/// of files at level `<N>`, where `<N>` is an ASCII representation of a
 /// level number (e.g., "0").
 pub fn num_files_at_level(level: usize) -> CString {
     unsafe { level_property("num-files-at-level", level) }
 }
 
-/// "rocksdb.compression-ratio-at-level<N>" - returns string containing the
-/// compression ratio of data at level <N>, where <N> is an ASCII
+/// "rocksdb.compression-ratio-at-level`<N>`" - returns string containing the
+/// compression ratio of data at level `<N>`, where `<N>` is an ASCII
 /// representation of a level number (e.g., "0"). Here, compression
 /// ratio is defined as uncompressed data size / compressed file size.
-/// Returns "-1.0" if no open files at level <N>.
+/// Returns "-1.0" if no open files at level `<N>`.
 pub fn compression_ratio_at_level(level: usize) -> CString {
     unsafe { level_property("compression-ratio-at-level", level) }
 }
@@ -45,7 +45,7 @@ pub const SSTABLES: &CStr = property!("sstables");
 pub const CFSTATS: &CStr = property!("CFSTATS");
 
 /// "rocksdb.cfstats-no-file-histogram" - returns a multi-line string with
-/// general columm family stats per-level over db's lifetime ("L<n>"),
+/// general columm family stats per-level over db's lifetime ("L`<n>`"),
 /// aggregated over db's lifetime ("Sum"), and aggregated over the
 /// interval since the last retrieval ("Int").
 /// It could also be used to return the stats in the format of the map.
@@ -192,7 +192,7 @@ pub const ESTIMATE_PENDING_COMPACTION_BYTES: &CStr = property!("estimate-pending
 /// of the aggregated table properties of the target column family.
 pub const AGGREGATED_TABLE_PROPERTIES: &CStr = property!("aggregated-table-properties");
 
-/// "rocksdb.aggregated-table-properties-at-level<N>", same as the previous
+/// "rocksdb.aggregated-table-properties-at-level`<N>`", same as the previous
 /// one but only returns the aggregated table properties of the
 /// specified level "N" at the target column family.
 pub fn aggregated_table_properties_at_level(level: usize) -> CString {

src/transactions/transaction_db.rs

@@ -300,8 +300,8 @@ impl<T: ThreadMode> TransactionDB<T> {
             let mut cnt = 0;
             let ptr = ffi::rocksdb_transactiondb_get_prepared_transactions(db, &mut cnt);
             let mut vec = vec![std::ptr::null_mut(); cnt];
-            std::ptr::copy_nonoverlapping(ptr, vec.as_mut_ptr(), cnt);
             if !ptr.is_null() {
+                std::ptr::copy_nonoverlapping(ptr, vec.as_mut_ptr(), cnt);
                 ffi::rocksdb_free(ptr as *mut c_void);
             }
             vec

tests/test_approximate.rs

@@ -4,16 +4,20 @@ use haizhi_rocksdb as rocksdb;
 
 use rocksdb::Ranges;
 use rocksdb::{ColumnFamilyDescriptor, Options, DB};
+
+mod util;
+use util::DBPath;
+
 #[test]
 fn test_approximate() {
-    let path = "test1";
+    let path = DBPath::new("test_approximate_test1");
     let cf_opts = Options::default();
     let cf1 = ColumnFamilyDescriptor::new("cf1", cf_opts.clone());
     let cf2 = ColumnFamilyDescriptor::new("cf2", cf_opts);
     let mut db_opts = Options::default();
     db_opts.create_missing_column_families(true);
     db_opts.create_if_missing(true);
-    let db = DB::open_cf_descriptors(&db_opts, path, vec![cf1, cf2]).unwrap();
+    let db = DB::open_cf_descriptors(&db_opts, &path, vec![cf1, cf2]).unwrap();
     //
     let a = 1.to_string();
     let start_key: &[u8] = a.as_ref();
@@ -23,25 +27,21 @@ fn test_approximate() {
     let cf2 = db.cf_handle("cf2").unwrap();
     for key in 0..10000 {
         if key % 2 == 1 {
-            db.put_cf(cf1, key.to_string(), (key * 2).to_string())
+            db.put_cf(&cf1, key.to_string(), (key * 2).to_string())
                 .unwrap();
         } else {
-            db.put_cf(cf2, key.to_string(), (key * 2).to_string())
+            db.put_cf(&cf2, key.to_string(), (key * 2).to_string())
                 .unwrap();
         }
     }
-    db.flush_cf(cf1).unwrap();
-    db.flush_cf(cf2).unwrap();
+    db.flush_cf(&cf1).unwrap();
+    db.flush_cf(&cf2).unwrap();
     std::thread::sleep(Duration::from_secs(2));
-    println!(
-        "start_key {:?}, end_key {:?}",
-        start_key.clone(),
-        end_key.clone()
-    );
+    println!("start_key {:?}, end_key {:?}", start_key, end_key,);
     let files_error_margin: f64 = 1.0;
     let f = db
         .get_approximate_sizes_with_option(
-            cf1,
+            &cf1,
             &[Ranges::new(start_key, end_key)],
             files_error_margin,
         )
@@ -53,18 +53,18 @@ fn test_approximate() {
 
     for key in 0..10000 {
         if key % 2 == 1 {
-            db.delete_cf(cf1, key.to_string()).unwrap();
+            db.delete_cf(&cf1, key.to_string()).unwrap();
         } else {
-            db.delete_cf(cf2, key.to_string()).unwrap();
+            db.delete_cf(&cf2, key.to_string()).unwrap();
         }
     }
-    db.flush_cf(cf1).unwrap();
+    db.flush_cf(&cf1).unwrap();
     std::thread::sleep(Duration::from_secs(5));
     let none: Option<Vec<u8>> = None;
     db.compact_range(none.clone(), none);
     let f = db
         .get_approximate_sizes_with_option(
-            cf1,
+            &cf1,
             &[Ranges::new(start_key, end_key)],
             files_error_margin,
         )

tests/test_checkpoint.rs

@@ -18,10 +18,7 @@ use pretty_assertions::assert_eq;
 
 use haizhi_rocksdb as rocksdb;
 
-use rocksdb::{
-    checkpoint::{Checkpoint, ExportImportFilesMetaData},
-    Options, DB,
-};
+use rocksdb::{checkpoint::Checkpoint, Options, DB};
 use util::DBPath;
 
 #[test]
@@ -139,7 +136,7 @@ fn test_export_column_family() {
 
     let export_path = DBPath::new(&format!("{}db1_backup", PATH_PREFIX));
     // let export_path = Path::new("db1_backup");
-    let result = checkpoint.export_column_family(cf1, &export_path);
+    let result = checkpoint.export_column_family(&cf1, &export_path);
     assert!(result.is_ok());
     let metadata = result.unwrap();
     // println!("metadata {:?}", metadata.save("save"));

tests/test_column_family.rs

@@ -512,7 +512,7 @@ fn test_create_cf_with_import() {
 
     let mut opts = Options::default();
     opts.create_if_missing(true);
-    let mut origin_db = DB::open(&opts, &origin_db_path).unwrap();
+    let mut origin_db = DB::open(&opts, origin_db_path).unwrap();
     // create two column families
     assert!(origin_db.create_cf("cf1", &opts).is_ok());
     assert!(origin_db.create_cf("cf2", &opts).is_ok());
@@ -537,7 +537,7 @@ fn test_create_cf_with_import() {
 
     let export_path = format!("{}/db1_backup", PATH_PREFIX);
     let export_path = Path::new(&export_path);
-    let result = checkpoint.export_column_family(cf1, &export_path);
+    let result = checkpoint.export_column_family(&cf1, export_path);
     assert!(result.is_ok());
     drop(checkpoint);
 
@@ -549,7 +549,7 @@ fn test_create_cf_with_import() {
     // new db from export path
     let recover_db_path = format!("{}/db1_recover", PATH_PREFIX);
     let recover_db_path = Path::new(&recover_db_path);
-    let mut recover_db = DB::open(&opts, &recover_db_path).unwrap();
+    let mut recover_db = DB::open(&opts, recover_db_path).unwrap();
     assert!(recover_db.cf_handle("cf1").is_none());
     assert!(recover_db.cf_handle("cf2").is_none());
     let result = recover_db.create_cf_with_import("cf1", &opts, &recover_metadata);

tests/test_comparator.rs

@@ -9,10 +9,10 @@ pub fn rocks_old_compare(one: &[u8], two: &[u8]) -> Ordering {
     one.cmp(two)
 }
 
+type CmpFn = dyn Fn(&[u8], &[u8]) -> Ordering;
+
 /// create database add some values, and iterate over these
-pub fn write_to_db_with_comparator(
-    compare_fn: Box<dyn Fn(&[u8], &[u8]) -> Ordering>,
-) -> Vec<String> {
+pub fn write_to_db_with_comparator(compare_fn: Box<CmpFn>) -> Vec<String> {
     let mut result_vec = Vec::new();
 
     let path = "_path_for_rocksdb_storage";