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/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/fail/checkpoint_outlive_db.stderr

@@ -1,11 +1,11 @@
 error[E0597]: `db` does not live long enough
- --> tests/fail/checkpoint_outlive_db.rs:7:25
+ --> tests/fail/snapshot_outlive_db.rs:7:9
   |
-5 |     let _checkpoint = {
-  |         ----------- borrow later stored here
+5 |     let _snapshot = {
+  |         --------- borrow later stored here
 6 |         let db = DB::open_default("foo").unwrap();
   |             -- binding `db` declared here
-7 |         Checkpoint::new(&db)
-  |                         ^^^ borrowed value does not live long enough
+7 |         db.snapshot()
+  |         ^^ borrowed value does not live long enough
 8 |     };
   |     - `db` dropped here while still borrowed

tests/fail/open_with_multiple_refs_as_single_threaded.stderr

@@ -2,20 +2,20 @@ error[E0596]: cannot borrow `*db_ref1` as mutable, as it is behind a `&` referen
  --> tests/fail/open_with_multiple_refs_as_single_threaded.rs:9:5
   |
 9 |     db_ref1.create_cf("cf1", &opts).unwrap();
-  |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `db_ref1` is a `&` reference, so the data it refers to cannot be borrowed as mutable
+  |     ^^^^^^^ `db_ref1` is a `&` reference, so the data it refers to cannot be borrowed as mutable
   |
 help: consider changing this to be a mutable reference
   |
 6 |     let db_ref1 = &mut db;
-  |                   ~~~~~~~
+  |                    +++
 
 error[E0596]: cannot borrow `*db_ref2` as mutable, as it is behind a `&` reference
   --> tests/fail/open_with_multiple_refs_as_single_threaded.rs:10:5
    |
 10 |     db_ref2.create_cf("cf2", &opts).unwrap();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `db_ref2` is a `&` reference, so the data it refers to cannot be borrowed as mutable
+   |     ^^^^^^^ `db_ref2` is a `&` reference, so the data it refers to cannot be borrowed as mutable
    |
 help: consider changing this to be a mutable reference
    |
 7  |     let db_ref2 = &mut db;
-   |                   ~~~~~~~
+   |                    +++

tests/fail/snapshot_outlive_db.stderr

@@ -6,6 +6,6 @@ error[E0597]: `db` does not live long enough
 6 |         let db = DB::open_default("foo").unwrap();
   |             -- binding `db` declared here
 7 |         db.snapshot()
-  |         ^^^^^^^^^^^^^ borrowed value does not live long enough
+  |         ^^ borrowed value does not live long enough
 8 |     };
   |     - `db` dropped here while still borrowed

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,15 +27,15 @@ 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 {:?}",
@@ -41,7 +45,7 @@ fn test_approximate() {
     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 +57,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

@@ -139,7 +139,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

@@ -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);