*: format code (#121)

.clang-format

+# Complete list of style options can be found at: 
+# http://clang.llvm.org/docs/ClangFormatStyleOptions.html
+---
+BasedOnStyle: Google
+...

.travis.yml

@@ -12,13 +12,8 @@ cache:
 
 os:
   - linux
-#  - osx
-
-before_script:
-- make -f travis-build/Makefile prepare-rustfmt
 
 script:
-- cargo fmt -- --write-mode diff || (echo please make format and run tests before creating a pr!; exit 1)
 - cargo build --features static-link
 - cargo test --all --features static-link
 
@@ -26,4 +21,3 @@ env:
   global:
   - RUST_TEST_THREADS=1
   - LD_LIBRARY_PATH: "/usr/local/lib"
-  - RUSTFMT_VERSION=v0.6.0

circle.yml

@@ -8,14 +8,13 @@ machine:
     CPPFLAGS: "-I$HOME/.local/include"
     CXXFLAGS: "-I$HOME/.local/include"
     PKG_CONFIG_PATH: "$PKG_CONFIG_PATH:$HOME/.local/lib/pkgconfig"
-    RUSTC_DATE: "2017-03-28"
+    RUSTC_DATE: "2017-08-09"
     LOCAL_PREFIX: "$HOME/.local"
     # used by cargo
     LIBRARY_PATH: "$LIBRARY_PATH:$HOME/.local/lib"
     RUST_TEST_THREADS: 1
     RUST_BACKTRACE: 1
     RUSTFLAGS: "-Dwarnings"
-    RUSTFMT_VERSION: "v0.6.0"
   pre:
     - |
       sudo add-apt-repository ppa:ubuntu-toolchain-r/test -y;

librocksdb_sys/build.rs

 
 extern crate gcc;
 
+use gcc::Build;
 use std::{env, fs, str};
 use std::path::PathBuf;
 use std::process::Command;
 
-use gcc::Config;
-
 macro_rules! t {
     ($e:expr) => (match $e {
         Ok(n) => n,
@@ -26,8 +25,8 @@ fn main() {
     println!("cargo:rustc-link-lib=static=crocksdb");
 }
 
-fn build_rocksdb() -> Config {
-    let mut cfg = Config::new();
+fn build_rocksdb() -> Build {
+    let mut cfg = Build::new();
 
     if !cfg!(feature = "static-link") {
         if cfg!(target_os = "windows") {
@@ -89,10 +88,12 @@ fn build_rocksdb() -> Config {
         }
 
         if let Err(e) = fs::rename(src.as_path(), dst.as_path()) {
-            panic!("failed to move {} to {}: {:?}",
+            panic!(
+                "failed to move {} to {}: {:?}",
                 src.display(),
                 dst.display(),
-                   e);
+                e
+            );
         }
     }
 
@@ -124,23 +125,29 @@ fn build_rocksdb() -> Config {
         return cfg;
     }
 
-    let output =
-        Command::new(p.as_path()).args(&["find_library", std_lib_name]).output().unwrap();
+    let output = Command::new(p.as_path())
+        .args(&["find_library", std_lib_name])
+        .output()
+        .unwrap();
     if output.status.success() && !output.stdout.is_empty() {
         if let Ok(path_str) = str::from_utf8(&output.stdout) {
             let path = PathBuf::from(path_str);
             if path.is_absolute() {
                 println!("cargo:rustc-link-lib=static=stdc++");
-                println!("cargo:rustc-link-search=native={}",
-                            path.parent().unwrap().display());
+                println!(
+                    "cargo:rustc-link-search=native={}",
+                    path.parent().unwrap().display()
+                );
                 cfg.cpp_link_stdlib(None);
                 return cfg;
             }
         }
     }
-    println!("failed to detect {}: {:?}, fallback to dynamic",
+    println!(
+        "failed to detect {}: {:?}, fallback to dynamic",
         std_lib_name,
-             output);
+        output
+    );
     cfg
 }
 

librocksdb_sys/crocksdb/crocksdb/c.h

@@ -628,7 +628,8 @@ crocksdb_compactionjobinfo_table_properties(
 extern C_ROCKSDB_LIBRARY_API uint64_t
 crocksdb_compactionjobinfo_elapsed_micros(const crocksdb_compactionjobinfo_t*);
 extern C_ROCKSDB_LIBRARY_API uint64_t
-crocksdb_compactionjobinfo_num_corrupt_keys(const crocksdb_compactionjobinfo_t*);
+crocksdb_compactionjobinfo_num_corrupt_keys(
+    const crocksdb_compactionjobinfo_t*);
 
 /* External file ingestion info */
 

librocksdb_sys/src/lib.rs

@@ -17,7 +17,7 @@ extern crate libc;
 #[cfg(test)]
 extern crate tempdir;
 
-use libc::{c_char, c_uchar, c_int, c_void, size_t, uint8_t, uint32_t, uint64_t, c_double};
+use libc::{c_char, c_double, c_int, c_uchar, c_void, size_t, uint32_t, uint64_t, uint8_t};
 use std::ffi::CStr;
 
 pub enum Options {}
@@ -265,37 +265,57 @@ extern "C" {
     pub fn crocksdb_block_based_options_destroy(opts: *mut DBBlockBasedTableOptions);
     pub fn crocksdb_block_based_options_set_block_size(
         block_options: *mut DBBlockBasedTableOptions,
-        block_size: size_t);
+        block_size: size_t,
+    );
     pub fn crocksdb_block_based_options_set_block_size_deviation(
         block_options: *mut DBBlockBasedTableOptions,
-        block_size_deviation: c_int);
+        block_size_deviation: c_int,
+    );
     pub fn crocksdb_block_based_options_set_block_restart_interval(
         block_options: *mut DBBlockBasedTableOptions,
-        block_restart_interval: c_int);
+        block_restart_interval: c_int,
+    );
     pub fn crocksdb_block_based_options_set_cache_index_and_filter_blocks(
-        block_options: *mut DBBlockBasedTableOptions, v: c_uchar);
+        block_options: *mut DBBlockBasedTableOptions,
+        v: c_uchar,
+    );
     pub fn crocksdb_block_based_options_set_filter_policy(
         block_options: *mut DBBlockBasedTableOptions,
-        filter_policy: *mut DBFilterPolicy);
+        filter_policy: *mut DBFilterPolicy,
+    );
     pub fn crocksdb_block_based_options_set_no_block_cache(
-        block_options: *mut DBBlockBasedTableOptions, no_block_cache: bool);
+        block_options: *mut DBBlockBasedTableOptions,
+        no_block_cache: bool,
+    );
     pub fn crocksdb_block_based_options_set_block_cache(
-        block_options: *mut DBBlockBasedTableOptions, block_cache: *mut DBCache);
+        block_options: *mut DBBlockBasedTableOptions,
+        block_cache: *mut DBCache,
+    );
     pub fn crocksdb_block_based_options_set_block_cache_compressed(
         block_options: *mut DBBlockBasedTableOptions,
-        block_cache_compressed: *mut DBCache);
+        block_cache_compressed: *mut DBCache,
+    );
     pub fn crocksdb_block_based_options_set_whole_key_filtering(
-        ck_options: *mut DBBlockBasedTableOptions, doit: bool);
+        ck_options: *mut DBBlockBasedTableOptions,
+        doit: bool,
+    );
     pub fn crocksdb_options_set_block_based_table_factory(
         options: *mut Options,
-        block_options: *mut DBBlockBasedTableOptions);
+        block_options: *mut DBBlockBasedTableOptions,
+    );
     pub fn crocksdb_block_based_options_set_pin_l0_filter_and_index_blocks_in_cache(
-        block_options: *mut DBBlockBasedTableOptions, v: c_uchar);
+        block_options: *mut DBBlockBasedTableOptions,
+        v: c_uchar,
+    );
     pub fn crocksdb_options_increase_parallelism(options: *mut Options, threads: c_int);
-    pub fn crocksdb_options_optimize_level_style_compaction(options: *mut Options,
-                                                            memtable_memory_budget: c_int);
-    pub fn crocksdb_options_set_compaction_filter(options: *mut Options,
-                                                  filter: *mut DBCompactionFilter);
+    pub fn crocksdb_options_optimize_level_style_compaction(
+        options: *mut Options,
+        memtable_memory_budget: c_int,
+    );
+    pub fn crocksdb_options_set_compaction_filter(
+        options: *mut Options,
+        filter: *mut DBCompactionFilter,
+    );
     pub fn crocksdb_options_set_create_if_missing(options: *mut Options, v: bool);
     pub fn crocksdb_options_set_max_open_files(options: *mut Options, files: c_int);
     pub fn crocksdb_options_set_max_total_wal_size(options: *mut Options, size: u64);
@@ -303,16 +323,21 @@ extern "C" {
     pub fn crocksdb_options_set_bytes_per_sync(options: *mut Options, bytes: u64);
     pub fn crocksdb_options_set_enable_pipelined_write(options: *mut Options, v: bool);
     pub fn crocksdb_options_set_allow_concurrent_memtable_write(options: *mut Options, v: bool);
-    pub fn crocksdb_options_optimize_for_point_lookup(options: *mut Options,
-                                                      block_cache_size_mb: u64);
+    pub fn crocksdb_options_optimize_for_point_lookup(
+        options: *mut Options,
+        block_cache_size_mb: u64,
+    );
     pub fn crocksdb_options_set_table_cache_numshardbits(options: *mut Options, bits: c_int);
-    pub fn crocksdb_options_set_writable_file_max_buffer_size(options: *mut Options,
-                                                              nbytes: c_int);
+    pub fn crocksdb_options_set_writable_file_max_buffer_size(options: *mut Options, nbytes: c_int);
     pub fn crocksdb_options_set_max_write_buffer_number(options: *mut Options, bufno: c_int);
-    pub fn crocksdb_options_set_min_write_buffer_number_to_merge(options: *mut Options,
-                                                                 bufno: c_int);
-    pub fn crocksdb_options_set_level0_file_num_compaction_trigger(options: *mut Options,
-                                                                   no: c_int);
+    pub fn crocksdb_options_set_min_write_buffer_number_to_merge(
+        options: *mut Options,
+        bufno: c_int,
+    );
+    pub fn crocksdb_options_set_level0_file_num_compaction_trigger(
+        options: *mut Options,
+        no: c_int,
+    );
     pub fn crocksdb_options_set_level0_slowdown_writes_trigger(options: *mut Options, no: c_int);
     pub fn crocksdb_options_set_level0_stop_writes_trigger(options: *mut Options, no: c_int);
     pub fn crocksdb_options_set_write_buffer_size(options: *mut Options, bytes: u64);
@@ -326,20 +351,28 @@ extern "C" {
     pub fn crocksdb_options_set_info_log_level(options: *mut Options, level: DBInfoLogLevel);
     pub fn crocksdb_options_set_keep_log_file_num(options: *mut Options, num: size_t);
     pub fn crocksdb_options_set_max_manifest_file_size(options: *mut Options, bytes: u64);
-    pub fn crocksdb_options_set_hash_skip_list_rep(options: *mut Options,
+    pub fn crocksdb_options_set_hash_skip_list_rep(
+        options: *mut Options,
         bytes: u64,
         a1: i32,
-                                                   a2: i32);
+        a2: i32,
+    );
     pub fn crocksdb_options_set_compaction_style(options: *mut Options, cs: DBCompactionStyle);
-    pub fn crocksdb_options_set_compression(options: *mut Options,
-                                            compression_style_no: DBCompressionType);
+    pub fn crocksdb_options_set_compression(
+        options: *mut Options,
+        compression_style_no: DBCompressionType,
+    );
     pub fn crocksdb_options_get_compression(options: *mut Options) -> DBCompressionType;
-    pub fn crocksdb_options_set_compression_per_level(options: *mut Options,
+    pub fn crocksdb_options_set_compression_per_level(
+        options: *mut Options,
         level_values: *const DBCompressionType,
-                                                      num_levels: size_t);
+        num_levels: size_t,
+    );
     pub fn crocksdb_options_get_compression_level_number(options: *mut Options) -> size_t;
-    pub fn crocksdb_options_get_compression_per_level(options: *mut Options,
-                                                      level_values: *mut DBCompressionType);
+    pub fn crocksdb_options_get_compression_per_level(
+        options: *mut Options,
+        level_values: *mut DBCompressionType,
+    );
     pub fn crocksdb_set_bottommost_compression(options: *mut Options, c: DBCompressionType);
     pub fn crocksdb_options_set_max_background_jobs(options: *mut Options, max_bg_jobs: c_int);
     pub fn crocksdb_options_set_disable_auto_compactions(options: *mut Options, v: c_int);
@@ -350,23 +383,27 @@ extern "C" {
     pub fn crocksdb_options_set_wal_bytes_per_sync(options: *mut Options, v: u64);
     pub fn crocksdb_options_enable_statistics(options: *mut Options);
     pub fn crocksdb_options_statistics_get_string(options: *mut Options) -> *const c_char;
-    pub fn crocksdb_options_statistics_get_ticker_count(options: *mut Options,
-                                                        ticker_type: DBStatisticsTickerType)
-                                                        -> u64;
-    pub fn crocksdb_options_statistics_get_and_reset_ticker_count(options: *mut Options,
-                                                        ticker_type: DBStatisticsTickerType)
-                                                        -> u64;
-    pub fn crocksdb_options_statistics_get_histogram_string(options: *mut Options,
-                                                            hist_type: DBStatisticsHistogramType)
-                                                            -> *const c_char;
-    pub fn crocksdb_options_statistics_get_histogram(options: *mut Options,
+    pub fn crocksdb_options_statistics_get_ticker_count(
+        options: *mut Options,
+        ticker_type: DBStatisticsTickerType,
+    ) -> u64;
+    pub fn crocksdb_options_statistics_get_and_reset_ticker_count(
+        options: *mut Options,
+        ticker_type: DBStatisticsTickerType,
+    ) -> u64;
+    pub fn crocksdb_options_statistics_get_histogram_string(
+        options: *mut Options,
+        hist_type: DBStatisticsHistogramType,
+    ) -> *const c_char;
+    pub fn crocksdb_options_statistics_get_histogram(
+        options: *mut Options,
         hist_type: DBStatisticsHistogramType,
         median: *mut c_double,
         percentile95: *mut c_double,
         percentile99: *mut c_double,
         average: *mut c_double,
-                                                     standard_deviation: *mut c_double)
-                                                     -> bool;
+        standard_deviation: *mut c_double,
+    ) -> bool;
     pub fn crocksdb_options_set_stats_dump_period_sec(options: *mut Options, v: usize);
     pub fn crocksdb_options_set_num_levels(options: *mut Options, v: c_int);
     pub fn crocksdb_options_set_db_log_dir(options: *mut Options, path: *const c_char);
@@ -374,191 +411,236 @@ extern "C" {
     pub fn crocksdb_options_set_wal_ttl_seconds(options: *mut Options, ttl: u64);
     pub fn crocksdb_options_set_wal_size_limit_mb(options: *mut Options, limit: u64);
     pub fn crocksdb_options_set_use_direct_reads(options: *mut Options, v: bool);
-    pub fn crocksdb_options_set_use_direct_io_for_flush_and_compaction(options: *mut Options,
-                                                                       v: bool);
-    pub fn crocksdb_options_set_prefix_extractor(options: *mut Options,
-                                                 prefix_extractor: *mut DBSliceTransform);
+    pub fn crocksdb_options_set_use_direct_io_for_flush_and_compaction(
+        options: *mut Options,
+        v: bool,
+    );
+    pub fn crocksdb_options_set_prefix_extractor(
+        options: *mut Options,
+        prefix_extractor: *mut DBSliceTransform,
+    );
     pub fn crocksdb_options_set_optimize_filters_for_hits(options: *mut Options, v: bool);
-    pub fn crocksdb_options_set_level_compaction_dynamic_level_bytes(options: *mut Options,
-                                                                     v: bool);
-    pub fn crocksdb_options_set_memtable_insert_with_hint_prefix_extractor(options: *mut Options,
-                                                 prefix_extractor: *mut DBSliceTransform);
-    pub fn crocksdb_options_set_memtable_prefix_bloom_size_ratio(options: *mut Options,
-                                                                 ratio: c_double);
+    pub fn crocksdb_options_set_level_compaction_dynamic_level_bytes(
+        options: *mut Options,
+        v: bool,
+    );
+    pub fn crocksdb_options_set_memtable_insert_with_hint_prefix_extractor(
+        options: *mut Options,
+        prefix_extractor: *mut DBSliceTransform,
+    );
+    pub fn crocksdb_options_set_memtable_prefix_bloom_size_ratio(
+        options: *mut Options,
+        ratio: c_double,
+    );
     pub fn crocksdb_options_set_delayed_write_rate(options: *mut Options, rate: u64);
     pub fn crocksdb_options_set_ratelimiter(options: *mut Options, limiter: *mut DBRateLimiter);
     pub fn crocksdb_options_set_info_log(options: *mut Options, logger: *mut DBLogger);
     pub fn crocksdb_options_get_block_cache_usage(options: *const Options) -> usize;
-    pub fn crocksdb_ratelimiter_create(rate_bytes_per_sec: i64,
+    pub fn crocksdb_ratelimiter_create(
+        rate_bytes_per_sec: i64,
         refill_period_us: i64,
-                                       fairness: i32)
-                                       -> *mut DBRateLimiter;
+        fairness: i32,
+    ) -> *mut DBRateLimiter;
     pub fn crocksdb_ratelimiter_destroy(limiter: *mut DBRateLimiter);
-    pub fn crocksdb_options_set_soft_pending_compaction_bytes_limit(options: *mut Options,
-                                                                    v: u64);
-    pub fn crocksdb_options_set_hard_pending_compaction_bytes_limit(options: *mut Options,
-                                                                    v: u64);
+    pub fn crocksdb_options_set_soft_pending_compaction_bytes_limit(options: *mut Options, v: u64);
+    pub fn crocksdb_options_set_hard_pending_compaction_bytes_limit(options: *mut Options, v: u64);
     pub fn crocksdb_options_set_compaction_priority(options: *mut Options, v: CompactionPriority);
-    pub fn crocksdb_options_set_db_paths(options: *mut Options,
+    pub fn crocksdb_options_set_db_paths(
+        options: *mut Options,
         db_paths: *const *const c_char,
         path_lens: *const usize,
         target_size: *const u64,
-                                         num_paths: c_int);
+        num_paths: c_int,
+    );
     pub fn crocksdb_filterpolicy_create_bloom_full(bits_per_key: c_int) -> *mut DBFilterPolicy;
     pub fn crocksdb_filterpolicy_create_bloom(bits_per_key: c_int) -> *mut DBFilterPolicy;
-    pub fn crocksdb_open(options: *mut Options,
+    pub fn crocksdb_open(
+        options: *mut Options,
         path: *const c_char,
-                         err: *mut *mut c_char)
-                         -> *mut DBInstance;
+        err: *mut *mut c_char,
+    ) -> *mut DBInstance;
     pub fn crocksdb_writeoptions_create() -> *mut DBWriteOptions;
     pub fn crocksdb_writeoptions_destroy(writeopts: *mut DBWriteOptions);
     pub fn crocksdb_writeoptions_set_sync(writeopts: *mut DBWriteOptions, v: bool);
     pub fn crocksdb_writeoptions_disable_wal(writeopts: *mut DBWriteOptions, v: c_int);
-    pub fn crocksdb_writeoptions_set_ignore_missing_column_families(writeopts: *mut DBWriteOptions,
-                                                                    v: bool);
+    pub fn crocksdb_writeoptions_set_ignore_missing_column_families(
+        writeopts: *mut DBWriteOptions,
+        v: bool,
+    );
     pub fn crocksdb_writeoptions_set_no_slowdown(writeopts: *mut DBWriteOptions, v: bool);
     pub fn crocksdb_writeoptions_set_low_pri(writeopts: *mut DBWriteOptions, v: bool);
-    pub fn crocksdb_put(db: *mut DBInstance,
+    pub fn crocksdb_put(
+        db: *mut DBInstance,
         writeopts: *mut DBWriteOptions,
         k: *const u8,
         kLen: size_t,
         v: *const u8,
         vLen: size_t,
-                        err: *mut *mut c_char);
-    pub fn crocksdb_put_cf(db: *mut DBInstance,
+        err: *mut *mut c_char,
+    );
+    pub fn crocksdb_put_cf(
+        db: *mut DBInstance,
         writeopts: *mut DBWriteOptions,
         cf: *mut DBCFHandle,
         k: *const u8,
         kLen: size_t,
         v: *const u8,
         vLen: size_t,
-                           err: *mut *mut c_char);
+        err: *mut *mut c_char,
+    );
     pub fn crocksdb_readoptions_create() -> *mut DBReadOptions;
     pub fn crocksdb_readoptions_destroy(readopts: *mut DBReadOptions);
     pub fn crocksdb_readoptions_set_verify_checksums(readopts: *mut DBReadOptions, v: bool);
     pub fn crocksdb_readoptions_set_fill_cache(readopts: *mut DBReadOptions, v: bool);
-    pub fn crocksdb_readoptions_set_snapshot(readopts: *mut DBReadOptions,
-                                             snapshot: *const DBSnapshot);
-    pub fn crocksdb_readoptions_set_iterate_upper_bound(readopts: *mut DBReadOptions,
+    pub fn crocksdb_readoptions_set_snapshot(
+        readopts: *mut DBReadOptions,
+        snapshot: *const DBSnapshot,
+    );
+    pub fn crocksdb_readoptions_set_iterate_upper_bound(
+        readopts: *mut DBReadOptions,
         k: *const u8,
-                                                        kLen: size_t);
+        kLen: size_t,
+    );
     pub fn crocksdb_readoptions_set_read_tier(readopts: *mut DBReadOptions, tier: c_int);
     pub fn crocksdb_readoptions_set_tailing(readopts: *mut DBReadOptions, v: bool);
     pub fn crocksdb_readoptions_set_managed(readopts: *mut DBReadOptions, v: bool);
     pub fn crocksdb_readoptions_set_readahead_size(readopts: *mut DBReadOptions, size: size_t);
-    pub fn crocksdb_readoptions_set_max_skippable_internal_keys(readopts: *mut DBReadOptions,
-                                                                n: uint64_t);
+    pub fn crocksdb_readoptions_set_max_skippable_internal_keys(
+        readopts: *mut DBReadOptions,
+        n: uint64_t,
+    );
     pub fn crocksdb_readoptions_set_total_order_seek(readopts: *mut DBReadOptions, v: bool);
     pub fn crocksdb_readoptions_set_prefix_same_as_start(readopts: *mut DBReadOptions, v: bool);
     pub fn crocksdb_readoptions_set_pin_data(readopts: *mut DBReadOptions, v: bool);
-    pub fn crocksdb_readoptions_set_background_purge_on_iterator_cleanup
-    (readopts: *mut DBReadOptions, v: bool);
+    pub fn crocksdb_readoptions_set_background_purge_on_iterator_cleanup(
+        readopts: *mut DBReadOptions,
+        v: bool,
+    );
     pub fn crocksdb_readoptions_set_ignore_range_deletions(readopts: *mut DBReadOptions, v: bool);
 
-    pub fn crocksdb_get(db: *const DBInstance,
+    pub fn crocksdb_get(
+        db: *const DBInstance,
         readopts: *const DBReadOptions,
         k: *const u8,
         kLen: size_t,
         valLen: *const size_t,
-                        err: *mut *mut c_char)
-                        -> *mut u8;
-    pub fn crocksdb_get_cf(db: *const DBInstance,
+        err: *mut *mut c_char,
+    ) -> *mut u8;
+    pub fn crocksdb_get_cf(
+        db: *const DBInstance,
         readopts: *const DBReadOptions,
         cf_handle: *mut DBCFHandle,
         k: *const u8,
         kLen: size_t,
         valLen: *const size_t,
-                           err: *mut *mut c_char)
-                           -> *mut u8;
-    pub fn crocksdb_create_iterator(db: *mut DBInstance,
-                                    readopts: *const DBReadOptions)
-                                    -> *mut DBIterator;
-    pub fn crocksdb_create_iterator_cf(db: *mut DBInstance,
+        err: *mut *mut c_char,
+    ) -> *mut u8;
+    pub fn crocksdb_create_iterator(
+        db: *mut DBInstance,
         readopts: *const DBReadOptions,
-                                       cf_handle: *mut DBCFHandle)
-                                       -> *mut DBIterator;
+    ) -> *mut DBIterator;
+    pub fn crocksdb_create_iterator_cf(
+        db: *mut DBInstance,
+        readopts: *const DBReadOptions,
+        cf_handle: *mut DBCFHandle,
+    ) -> *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_delete(db: *mut DBInstance,
+    pub fn crocksdb_delete(
+        db: *mut DBInstance,
         writeopts: *const DBWriteOptions,
         k: *const u8,
         kLen: size_t,
-                           err: *mut *mut c_char);
-    pub fn crocksdb_delete_cf(db: *mut DBInstance,
+        err: *mut *mut c_char,
+    );
+    pub fn crocksdb_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_single_delete(db: *mut DBInstance,
+        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,
+        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_delete_range_cf(db: *mut DBInstance,
+        err: *mut *mut c_char,
+    );
+    pub fn crocksdb_delete_range_cf(
+        db: *mut DBInstance,
         writeopts: *const DBWriteOptions,
         cf: *mut DBCFHandle,
         begin_key: *const u8,
         begin_keylen: size_t,
         end_key: *const u8,
         end_keylen: size_t,
-                                    err: *mut *mut c_char);
+        err: *mut *mut c_char,
+    );
     pub fn crocksdb_close(db: *mut DBInstance);
     pub fn crocksdb_pause_bg_work(db: *mut DBInstance);
     pub fn crocksdb_continue_bg_work(db: *mut DBInstance);
-    pub fn crocksdb_destroy_db(options: *const Options,
-                               path: *const c_char,
-                               err: *mut *mut c_char);
-    pub fn crocksdb_repair_db(options: *const Options,
-                              path: *const c_char,
-                              err: *mut *mut c_char);
+    pub fn crocksdb_destroy_db(options: *const Options, path: *const c_char, err: *mut *mut c_char);
+    pub fn crocksdb_repair_db(options: *const Options, path: *const c_char, err: *mut *mut c_char);
     // Merge
-    pub fn crocksdb_merge(db: *mut DBInstance,
+    pub fn crocksdb_merge(
+        db: *mut DBInstance,
         writeopts: *const DBWriteOptions,
         k: *const u8,
         kLen: size_t,
         v: *const u8,
         vLen: size_t,
-                          err: *mut *mut c_char);
-    pub fn crocksdb_merge_cf(db: *mut DBInstance,
+        err: *mut *mut c_char,
+    );
+    pub fn crocksdb_merge_cf(
+        db: *mut DBInstance,
         writeopts: *const DBWriteOptions,
         cf: *mut DBCFHandle,
         k: *const u8,
         kLen: size_t,
         v: *const u8,
         vLen: size_t,
-                             err: *mut *mut c_char);
+        err: *mut *mut c_char,
+    );
     pub fn crocksdb_mergeoperator_create(
         state: *mut c_void,
-        destroy: extern fn(*mut c_void) -> (),
-        full_merge: extern fn (arg: *mut c_void,
-                               key: *const c_char, key_len: size_t,
+        destroy: extern "C" fn(*mut c_void) -> (),
+        full_merge: extern "C" fn(
+            arg: *mut c_void,
+            key: *const c_char,
+            key_len: size_t,
             existing_value: *const c_char,
             existing_value_len: size_t,
             operands_list: *const *const c_char,
             operands_list_len: *const size_t,
-                               num_operands: c_int, success: *mut u8,
-                               new_value_length: *mut size_t
+            num_operands: c_int,
+            success: *mut u8,
+            new_value_length: *mut size_t,
         ) -> *const c_char,
-        partial_merge: extern fn(arg: *mut c_void,
-                                 key: *const c_char, key_len: size_t,
+        partial_merge: extern "C" fn(
+            arg: *mut c_void,
+            key: *const c_char,
+            key_len: size_t,
             operands_list: *const *const c_char,
             operands_list_len: *const size_t,
-                                 num_operands: c_int, success: *mut u8,
-                                 new_value_length: *mut size_t
+            num_operands: c_int,
+            success: *mut u8,
+            new_value_length: *mut size_t,
         ) -> *const c_char,
-        delete_value: Option<extern "C" fn(*mut c_void,
-                                           value: *const c_char,
-                                           value_len: *mut size_t
-                                           ) -> ()>,
-        name_fn: extern fn(*mut c_void) -> *const c_char,
+        delete_value: Option<
+            extern "C" fn(*mut c_void, value: *const c_char, value_len: *mut size_t) -> (),
+        >,
+        name_fn: extern "C" fn(*mut c_void) -> *const c_char,
     ) -> *mut DBMergeOperator;
     pub fn crocksdb_mergeoperator_destroy(mo: *mut DBMergeOperator);
     pub fn crocksdb_options_set_merge_operator(options: *mut Options, mo: *mut DBMergeOperator);
@@ -575,114 +657,145 @@ extern "C" {
     pub fn crocksdb_iter_value(iter: *const DBIterator, vlen: *mut size_t) -> *mut u8;
     pub fn crocksdb_iter_get_error(iter: *const DBIterator, err: *mut *mut c_char);
     // Write batch
-    pub fn crocksdb_write(db: *mut DBInstance,
+    pub fn crocksdb_write(
+        db: *mut DBInstance,
         writeopts: *const DBWriteOptions,
         batch: *mut DBWriteBatch,
-                          err: *mut *mut c_char);
+        err: *mut *mut c_char,
+    );
     pub fn crocksdb_writebatch_create() -> *mut DBWriteBatch;
     pub fn crocksdb_writebatch_create_with_capacity(cap: size_t) -> *mut DBWriteBatch;
     pub fn crocksdb_writebatch_create_from(rep: *const u8, size: size_t) -> *mut DBWriteBatch;
     pub fn crocksdb_writebatch_destroy(batch: *mut DBWriteBatch);
     pub fn crocksdb_writebatch_clear(batch: *mut DBWriteBatch);
     pub fn crocksdb_writebatch_count(batch: *mut DBWriteBatch) -> c_int;
-    pub fn crocksdb_writebatch_put(batch: *mut DBWriteBatch,
+    pub fn crocksdb_writebatch_put(
+        batch: *mut DBWriteBatch,
         key: *const u8,
         klen: size_t,
         val: *const u8,
-                                   vlen: size_t);
-    pub fn crocksdb_writebatch_put_cf(batch: *mut DBWriteBatch,
+        vlen: size_t,
+    );
+    pub fn crocksdb_writebatch_put_cf(
+        batch: *mut DBWriteBatch,
         cf: *mut DBCFHandle,
         key: *const u8,
         klen: size_t,
         val: *const u8,
-                                      vlen: size_t);
-    pub fn crocksdb_writebatch_merge(batch: *mut DBWriteBatch,
+        vlen: size_t,
+    );
+    pub fn crocksdb_writebatch_merge(
+        batch: *mut DBWriteBatch,
         key: *const u8,
         klen: size_t,
         val: *const u8,
-                                     vlen: size_t);
-    pub fn crocksdb_writebatch_merge_cf(batch: *mut DBWriteBatch,
+        vlen: size_t,
+    );
+    pub fn crocksdb_writebatch_merge_cf(
+        batch: *mut DBWriteBatch,
         cf: *mut DBCFHandle,
         key: *const u8,
         klen: size_t,
         val: *const u8,
-                                        vlen: size_t);
+        vlen: size_t,
+    );
     pub fn crocksdb_writebatch_delete(batch: *mut DBWriteBatch, key: *const u8, klen: size_t);
-    pub fn crocksdb_writebatch_delete_cf(batch: *mut DBWriteBatch,
+    pub fn crocksdb_writebatch_delete_cf(
+        batch: *mut DBWriteBatch,
         cf: *mut DBCFHandle,
         key: *const u8,
-                                         klen: size_t);
-    pub fn crocksdb_writebatch_single_delete(batch: *mut DBWriteBatch,
+        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,
+        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_delete_range(batch: *mut DBWriteBatch,
+        klen: size_t,
+    );
+    pub fn crocksdb_writebatch_delete_range(
+        batch: *mut DBWriteBatch,
         begin_key: *const u8,
         begin_keylen: size_t,
         end_key: *const u8,
-                                            end_keylen: size_t);
-    pub fn crocksdb_writebatch_delete_range_cf(batch: *mut DBWriteBatch,
+        end_keylen: size_t,
+    );
+    pub fn crocksdb_writebatch_delete_range_cf(
+        batch: *mut DBWriteBatch,
         cf: *mut DBCFHandle,
         begin_key: *const u8,
         begin_keylen: size_t,
         end_key: *const u8,
-                                               end_keylen: size_t);
-    pub fn crocksdb_writebatch_iterate(batch: *mut DBWriteBatch,
+        end_keylen: size_t,
+    );
+    pub fn crocksdb_writebatch_iterate(
+        batch: *mut DBWriteBatch,
+        state: *mut c_void,
+        put_fn: extern "C" fn(
             state: *mut c_void,
-                                       put_fn: extern "C" fn(state: *mut c_void,
             k: *const u8,
             klen: size_t,
             v: *const u8,
-                                                             vlen: size_t),
-                                       deleted_fn: extern "C" fn(state: *mut c_void,
-                                                                 k: *const u8,
-                                                                 klen: size_t));
+            vlen: size_t,
+        ),
+        deleted_fn: extern "C" fn(state: *mut c_void, k: *const u8, klen: size_t),
+    );
     pub fn crocksdb_writebatch_data(batch: *mut DBWriteBatch, size: *mut size_t) -> *const u8;
     pub fn crocksdb_writebatch_set_save_point(batch: *mut DBWriteBatch);
-    pub fn crocksdb_writebatch_rollback_to_save_point(batch: *mut DBWriteBatch,
-                                                      err: *mut *mut c_char);
+    pub fn crocksdb_writebatch_rollback_to_save_point(
+        batch: *mut DBWriteBatch,
+        err: *mut *mut c_char,
+    );
 
     // Comparator
     pub fn crocksdb_options_set_comparator(options: *mut Options, cb: *mut DBComparator);
-    pub fn crocksdb_comparator_create(state: *mut c_void,
+    pub fn crocksdb_comparator_create(
+        state: *mut c_void,
         destroy: extern "C" fn(*mut c_void) -> (),
-                                      compare: extern "C" fn(arg: *mut c_void,
+        compare: extern "C" fn(
+            arg: *mut c_void,
             a: *const c_char,
             alen: size_t,
             b: *const c_char,
-                                                             blen: size_t)
-                                                             -> c_int,
-                                      name_fn: extern "C" fn(*mut c_void) -> *const c_char)
-                                      -> *mut DBComparator;
+            blen: size_t,
+        ) -> c_int,
+        name_fn: extern "C" fn(*mut c_void) -> *const c_char,
+    ) -> *mut DBComparator;
     pub fn crocksdb_comparator_destroy(cmp: *mut DBComparator);
 
     // Column Family
-    pub fn crocksdb_open_column_families(options: *const Options,
+    pub fn crocksdb_open_column_families(
+        options: *const Options,
         path: *const c_char,
         num_column_families: c_int,
         column_family_names: *const *const c_char,
         column_family_options: *const *const Options,
         column_family_handles: *const *mut DBCFHandle,
-                                         err: *mut *mut c_char)
-                                         -> *mut DBInstance;
-    pub fn crocksdb_create_column_family(db: *mut DBInstance,
+        err: *mut *mut c_char,
+    ) -> *mut DBInstance;
+    pub fn crocksdb_create_column_family(
+        db: *mut DBInstance,
         column_family_options: *const Options,
         column_family_name: *const c_char,
-                                         err: *mut *mut c_char)
-                                         -> *mut DBCFHandle;
-    pub fn crocksdb_drop_column_family(db: *mut DBInstance,
+        err: *mut *mut c_char,
+    ) -> *mut DBCFHandle;
+    pub fn crocksdb_drop_column_family(
+        db: *mut DBInstance,
         column_family_handle: *mut DBCFHandle,
-                                       err: *mut *mut c_char);
+        err: *mut *mut c_char,
+    );
     pub fn crocksdb_column_family_handle_id(column_family_handle: *mut DBCFHandle) -> u32;
     pub fn crocksdb_column_family_handle_destroy(column_family_handle: *mut DBCFHandle);
-    pub fn crocksdb_list_column_families(db: *const Options,
+    pub fn crocksdb_list_column_families(
+        db: *const Options,
         path: *const c_char,
         lencf: *mut size_t,
-                                         err: *mut *mut c_char)
-                                         -> *mut *mut c_char;
+        err: *mut *mut c_char,
+    ) -> *mut *mut c_char;
     pub fn crocksdb_list_column_families_destroy(list: *mut *mut c_char, len: size_t);
 
     // Flush options
@@ -690,89 +803,116 @@ extern "C" {
     pub fn crocksdb_flushoptions_destroy(opt: *mut DBFlushOptions);
     pub fn crocksdb_flushoptions_set_wait(opt: *mut DBFlushOptions, whether_wait: bool);
 
-    pub fn crocksdb_flush(db: *mut DBInstance,
+    pub fn crocksdb_flush(
+        db: *mut DBInstance,
         options: *const DBFlushOptions,
-                          err: *mut *mut c_char);
-    pub fn crocksdb_flush_cf(db: *mut DBInstance,
+        err: *mut *mut c_char,
+    );
+    pub fn crocksdb_flush_cf(
+        db: *mut DBInstance,
         cf: *mut DBCFHandle,
         options: *const DBFlushOptions,
-                             err: *mut *mut c_char);
+        err: *mut *mut c_char,
+    );
     pub fn crocksdb_sync_wal(db: *mut DBInstance, err: *mut *mut c_char);
 
-    pub fn crocksdb_approximate_sizes(db: *mut DBInstance,
+    pub fn crocksdb_approximate_sizes(
+        db: *mut DBInstance,
         num_ranges: c_int,
         range_start_key: *const *const u8,
         range_start_key_len: *const size_t,
         range_limit_key: *const *const u8,
         range_limit_key_len: *const size_t,
-                                      sizes: *mut uint64_t);
-    pub fn crocksdb_approximate_sizes_cf(db: *mut DBInstance,
+        sizes: *mut uint64_t,
+    );
+    pub fn crocksdb_approximate_sizes_cf(
+        db: *mut DBInstance,
         cf: *mut DBCFHandle,
         num_ranges: c_int,
         range_start_key: *const *const u8,
         range_start_key_len: *const size_t,
         range_limit_key: *const *const u8,
         range_limit_key_len: *const size_t,
-                                         sizes: *mut uint64_t);
-    pub fn crocksdb_approximate_memtable_stats(db: *const DBInstance,
+        sizes: *mut uint64_t,
+    );
+    pub fn crocksdb_approximate_memtable_stats(
+        db: *const DBInstance,
         range_start_key: *const u8,
         range_start_key_len: size_t,
         range_limit_key: *const u8,
         range_limit_key_len: size_t,
         count: *mut uint64_t,
-                                               size: *mut uint64_t);
-    pub fn crocksdb_approximate_memtable_stats_cf(db: *const DBInstance,
+        size: *mut uint64_t,
+    );
+    pub fn crocksdb_approximate_memtable_stats_cf(
+        db: *const DBInstance,
         cf: *const DBCFHandle,
         range_start_key: *const u8,
         range_start_key_len: size_t,
         range_limit_key: *const u8,
         range_limit_key_len: size_t,
         count: *mut uint64_t,
-                                                  size: *mut uint64_t);
+        size: *mut uint64_t,
+    );
     pub fn crocksdb_compactoptions_create() -> *mut DBCompactOptions;
     pub fn crocksdb_compactoptions_destroy(opt: *mut DBCompactOptions);
-    pub fn crocksdb_compactoptions_set_exclusive_manual_compaction(opt: *mut DBCompactOptions,
-                                                                   v: bool);
-    pub fn crocksdb_compact_range(db: *mut DBInstance,
+    pub fn crocksdb_compactoptions_set_exclusive_manual_compaction(
+        opt: *mut DBCompactOptions,
+        v: bool,
+    );
+    pub fn crocksdb_compact_range(
+        db: *mut DBInstance,
         start_key: *const u8,
         start_key_len: size_t,
         limit_key: *const u8,
-                                  limit_key_len: size_t);
-    pub fn crocksdb_compact_range_cf(db: *mut DBInstance,
+        limit_key_len: size_t,
+    );
+    pub fn crocksdb_compact_range_cf(
+        db: *mut DBInstance,
         cf: *mut DBCFHandle,
         start_key: *const u8,
         start_key_len: size_t,
         limit_key: *const u8,
-                                     limit_key_len: size_t);
-    pub fn crocksdb_compact_range_cf_opt(db: *mut DBInstance,
+        limit_key_len: size_t,
+    );
+    pub fn crocksdb_compact_range_cf_opt(
+        db: *mut DBInstance,
         cf: *mut DBCFHandle,
         compact_options: *mut DBCompactOptions,
         start_key: *const u8,
         start_key_len: size_t,
         limit_key: *const u8,
-                                         limit_key_len: size_t);
-    pub fn crocksdb_delete_file_in_range(db: *mut DBInstance,
+        limit_key_len: size_t,
+    );
+    pub fn crocksdb_delete_file_in_range(
+        db: *mut 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 *mut c_char);
-    pub fn crocksdb_delete_file_in_range_cf(db: *mut DBInstance,
+        err: *mut *mut c_char,
+    );
+    pub fn crocksdb_delete_file_in_range_cf(
+        db: *mut DBInstance,
         cf: *mut 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 *mut c_char);
+        err: *mut *mut c_char,
+    );
     pub fn crocksdb_property_value(db: *mut DBInstance, propname: *const c_char) -> *mut c_char;
-    pub fn crocksdb_property_value_cf(db: *mut DBInstance,
+    pub fn crocksdb_property_value_cf(
+        db: *mut DBInstance,
         cf: *mut DBCFHandle,
-                                      propname: *const c_char)
-                                      -> *mut c_char;
+        propname: *const c_char,
+    ) -> *mut c_char;
     // Compaction filter
-    pub fn crocksdb_compactionfilter_create(state: *mut c_void,
+    pub fn crocksdb_compactionfilter_create(
+        state: *mut c_void,
         destructor: extern "C" fn(*mut c_void),
-                                            filter: extern "C" fn(*mut c_void,
+        filter: extern "C" fn(
+            *mut c_void,
             c_int,
             *const u8,
             size_t,
@@ -780,12 +920,14 @@ extern "C" {
             size_t,
             *mut *mut u8,
             *mut size_t,
-                                                                  *mut bool)
-                                                                  -> bool,
-                                            name: extern "C" fn(*mut c_void) -> *const c_char)
-                                            -> *mut DBCompactionFilter;
-    pub fn crocksdb_compactionfilter_set_ignore_snapshots(filter: *mut DBCompactionFilter,
-                                                          ignore_snapshot: bool);
+            *mut bool,
+        ) -> bool,
+        name: extern "C" fn(*mut c_void) -> *const c_char,
+    ) -> *mut DBCompactionFilter;
+    pub fn crocksdb_compactionfilter_set_ignore_snapshots(
+        filter: *mut DBCompactionFilter,
+        ignore_snapshot: bool,
+    );
     pub fn crocksdb_compactionfilter_destroy(filter: *mut DBCompactionFilter);
 
     // EnvOptions
@@ -794,63 +936,87 @@ extern "C" {
 
     // IngestExternalFileOptions
     pub fn crocksdb_ingestexternalfileoptions_create() -> *mut IngestExternalFileOptions;
-    pub fn crocksdb_ingestexternalfileoptions_set_move_files(opt: *mut IngestExternalFileOptions,
-                                                             move_files: bool);
+    pub fn crocksdb_ingestexternalfileoptions_set_move_files(
+        opt: *mut IngestExternalFileOptions,
+        move_files: bool,
+    );
     pub fn crocksdb_ingestexternalfileoptions_set_snapshot_consistency(
-        opt: *mut IngestExternalFileOptions, snapshot_consistency: bool);
+        opt: *mut IngestExternalFileOptions,
+        snapshot_consistency: bool,
+    );
     pub fn crocksdb_ingestexternalfileoptions_set_allow_global_seqno(
-        opt: *mut IngestExternalFileOptions, allow_global_seqno: bool);
+        opt: *mut IngestExternalFileOptions,
+        allow_global_seqno: bool,
+    );
     pub fn crocksdb_ingestexternalfileoptions_set_allow_blocking_flush(
-        opt: *mut IngestExternalFileOptions, allow_blocking_flush: bool);
+        opt: *mut IngestExternalFileOptions,
+        allow_blocking_flush: bool,
+    );
     pub fn crocksdb_ingestexternalfileoptions_destroy(opt: *mut IngestExternalFileOptions);
 
     // SstFileWriter
-    pub fn crocksdb_sstfilewriter_create(env: *mut EnvOptions,
-                                         io_options: *const Options)
-                                         -> *mut SstFileWriter;
-    pub fn crocksdb_sstfilewriter_create_cf(env: *mut EnvOptions,
+    pub fn crocksdb_sstfilewriter_create(
+        env: *mut EnvOptions,
         io_options: *const Options,
-                                            cf: *mut DBCFHandle)
-                                            -> *mut SstFileWriter;
-    pub fn crocksdb_sstfilewriter_open(writer: *mut SstFileWriter,
+    ) -> *mut SstFileWriter;
+    pub fn crocksdb_sstfilewriter_create_cf(
+        env: *mut EnvOptions,
+        io_options: *const Options,
+        cf: *mut DBCFHandle,
+    ) -> *mut SstFileWriter;
+    pub fn crocksdb_sstfilewriter_open(
+        writer: *mut SstFileWriter,
         name: *const c_char,
-                                       err: *mut *mut c_char);
-    pub fn crocksdb_sstfilewriter_add(writer: *mut SstFileWriter,
+        err: *mut *mut c_char,
+    );
+    pub fn crocksdb_sstfilewriter_add(
+        writer: *mut SstFileWriter,
         key: *const u8,
         key_len: size_t,
         val: *const u8,
         val_len: size_t,
-                                      err: *mut *mut c_char);
-    pub fn crocksdb_sstfilewriter_put(writer: *mut SstFileWriter,
+        err: *mut *mut c_char,
+    );
+    pub fn crocksdb_sstfilewriter_put(
+        writer: *mut SstFileWriter,
         key: *const u8,
         key_len: size_t,
         val: *const u8,
         val_len: size_t,
-                                      err: *mut *mut c_char);
-    pub fn crocksdb_sstfilewriter_merge(writer: *mut SstFileWriter,
+        err: *mut *mut c_char,
+    );
+    pub fn crocksdb_sstfilewriter_merge(
+        writer: *mut SstFileWriter,
         key: *const u8,
         key_len: size_t,
         val: *const u8,
         val_len: size_t,
-                                        err: *mut *mut c_char);
-    pub fn crocksdb_sstfilewriter_delete(writer: *mut SstFileWriter,
+        err: *mut *mut c_char,
+    );
+    pub fn crocksdb_sstfilewriter_delete(
+        writer: *mut SstFileWriter,
         key: *const u8,
         key_len: size_t,
-                                         err: *mut *mut c_char);
+        err: *mut *mut c_char,
+    );
     pub fn crocksdb_sstfilewriter_finish(writer: *mut SstFileWriter, err: *mut *mut c_char);
     pub fn crocksdb_sstfilewriter_destroy(writer: *mut SstFileWriter);
 
-    pub fn crocksdb_ingest_external_file(db: *mut DBInstance,
+    pub fn crocksdb_ingest_external_file(
+        db: *mut DBInstance,
         file_list: *const *const c_char,
         list_len: size_t,
         opt: *const IngestExternalFileOptions,
-                                         err: *mut *mut c_char);
-    pub fn crocksdb_ingest_external_file_cf(db: *mut DBInstance,
+        err: *mut *mut c_char,
+    );
+    pub fn crocksdb_ingest_external_file_cf(
+        db: *mut DBInstance,
         handle: *const DBCFHandle,
         file_list: *const *const c_char,
         list_len: size_t,
         opt: *const IngestExternalFileOptions,
-                                            err: *mut *mut c_char);
+        err: *mut *mut c_char,
+    );
 
     // Restore Option
     pub fn crocksdb_restore_options_create() -> *mut DBRestoreOptions;
@@ -859,249 +1025,283 @@ extern "C" {
 
     // Backup engine
     // TODO: add more ffis about backup engine.
-    pub fn crocksdb_backup_engine_open(options: *const Options,
+    pub fn crocksdb_backup_engine_open(
+        options: *const Options,
         path: *const c_char,
-                                       err: *mut *mut c_char)
-                                       -> *mut DBBackupEngine;
-    pub fn crocksdb_backup_engine_create_new_backup(be: *mut DBBackupEngine,
+        err: *mut *mut c_char,
+    ) -> *mut DBBackupEngine;
+    pub fn crocksdb_backup_engine_create_new_backup(
+        be: *mut DBBackupEngine,
         db: *mut DBInstance,
-                                                    err: *mut *mut c_char);
+        err: *mut *mut c_char,
+    );
     pub fn crocksdb_backup_engine_close(be: *mut DBBackupEngine);
-    pub fn crocksdb_backup_engine_restore_db_from_latest_backup(be: *mut DBBackupEngine,
+    pub fn crocksdb_backup_engine_restore_db_from_latest_backup(
+        be: *mut DBBackupEngine,
         db_path: *const c_char,
         wal_path: *const c_char,
         ropts: *const DBRestoreOptions,
-                                                                err: *mut *mut c_char);
+        err: *mut *mut c_char,
+    );
     // SliceTransform
-    pub fn crocksdb_slicetransform_create(state: *mut c_void,
+    pub fn crocksdb_slicetransform_create(
+        state: *mut c_void,
         destructor: extern "C" fn(*mut c_void),
-                                          transform: extern "C" fn(*mut c_void,
-                                                                   *const u8,
-                                                                   size_t,
-                                                                   *mut size_t)
+        transform: extern "C" fn(*mut c_void, *const u8, size_t, *mut size_t)
             -> *const u8,
-                                          in_domain: extern "C" fn(*mut c_void,
-                                                                   *const u8,
-                                                                   size_t)
-                                                                   -> u8,
-                                          in_range: extern "C" fn(*mut c_void, *const u8, size_t)
-                                                                  -> u8,
-                                          name: extern "C" fn(*mut c_void) -> *const c_char)
-                                          -> *mut DBSliceTransform;
+        in_domain: extern "C" fn(*mut c_void, *const u8, size_t) -> u8,
+        in_range: extern "C" fn(*mut c_void, *const u8, size_t) -> u8,
+        name: extern "C" fn(*mut c_void) -> *const c_char,
+    ) -> *mut DBSliceTransform;
     pub fn crocksdb_slicetransform_destroy(transform: *mut DBSliceTransform);
-    pub fn crocksdb_create_log_from_options(path: *const c_char,
+    pub fn crocksdb_create_log_from_options(
+        path: *const c_char,
         options: *mut Options,
-                                            err: *mut *mut c_char)
-                                            -> *mut DBLogger;
+        err: *mut *mut c_char,
+    ) -> *mut DBLogger;
     pub fn crocksdb_log_destroy(logger: *mut DBLogger);
 
-    pub fn crocksdb_get_pinned(db: *mut DBInstance,
+    pub fn crocksdb_get_pinned(
+        db: *mut DBInstance,
         readopts: *const DBReadOptions,
         k: *const u8,
         kLen: size_t,
-                               err: *mut *mut c_char)
-                               -> *mut DBPinnableSlice;
-    pub fn crocksdb_get_pinned_cf(db: *mut DBInstance,
+        err: *mut *mut c_char,
+    ) -> *mut DBPinnableSlice;
+    pub fn crocksdb_get_pinned_cf(
+        db: *mut DBInstance,
         readopts: *const DBReadOptions,
         cf_handle: *mut DBCFHandle,
         k: *const u8,
         kLen: size_t,
-                                  err: *mut *mut c_char)
-                                  -> *mut DBPinnableSlice;
-    pub fn crocksdb_pinnableslice_value(s: *const DBPinnableSlice,
-                                        valLen: *mut size_t)
-                                        -> *const u8;
+        err: *mut *mut c_char,
+    ) -> *mut DBPinnableSlice;
+    pub fn crocksdb_pinnableslice_value(
+        s: *const DBPinnableSlice,
+        valLen: *mut size_t,
+    ) -> *const u8;
     pub fn crocksdb_pinnableslice_destroy(v: *mut DBPinnableSlice);
     pub fn crocksdb_get_supported_compression_number() -> size_t;
     pub fn crocksdb_get_supported_compression(v: *mut DBCompressionType, l: size_t);
 
-    pub fn crocksdb_user_collected_properties_add(props: *mut DBUserCollectedProperties,
+    pub fn crocksdb_user_collected_properties_add(
+        props: *mut DBUserCollectedProperties,
         key: *const uint8_t,
         key_len: size_t,
         value: *const uint8_t,
-                                                  value_len: size_t);
+        value_len: size_t,
+    );
 
-    pub fn crocksdb_user_collected_properties_iter_create
-        (props: *const DBUserCollectedProperties)
-         -> *mut DBUserCollectedPropertiesIterator;
+    pub fn crocksdb_user_collected_properties_iter_create(
+        props: *const DBUserCollectedProperties,
+    ) -> *mut DBUserCollectedPropertiesIterator;
 
-    pub fn crocksdb_user_collected_properties_iter_destroy
-        (it: *mut DBUserCollectedPropertiesIterator);
+    pub fn crocksdb_user_collected_properties_iter_destroy(
+        it: *mut DBUserCollectedPropertiesIterator,
+    );
 
-    pub fn crocksdb_user_collected_properties_iter_valid
-        (it: *const DBUserCollectedPropertiesIterator) -> bool;
+    pub fn crocksdb_user_collected_properties_iter_valid(
+        it: *const DBUserCollectedPropertiesIterator,
+    ) -> bool;
 
-    pub fn crocksdb_user_collected_properties_iter_next
-        (it: *mut DBUserCollectedPropertiesIterator);
+    pub fn crocksdb_user_collected_properties_iter_next(it: *mut DBUserCollectedPropertiesIterator);
 
-    pub fn crocksdb_user_collected_properties_iter_key(it: *const DBUserCollectedPropertiesIterator,
-                                                       klen: *mut size_t)
-                                                       -> *const uint8_t;
+    pub fn crocksdb_user_collected_properties_iter_key(
+        it: *const DBUserCollectedPropertiesIterator,
+        klen: *mut size_t,
+    ) -> *const uint8_t;
 
-    pub fn crocksdb_user_collected_properties_iter_value
-        (it: *const DBUserCollectedPropertiesIterator, vlen: *mut size_t) -> *const uint8_t;
+    pub fn crocksdb_user_collected_properties_iter_value(
+        it: *const DBUserCollectedPropertiesIterator,
+        vlen: *mut size_t,
+    ) -> *const uint8_t;
 
-    pub fn crocksdb_table_properties_get_u64(props: *const DBTableProperties,
-                                             prop: DBTableProperty)
-                                             -> uint64_t;
+    pub fn crocksdb_table_properties_get_u64(
+        props: *const DBTableProperties,
+        prop: DBTableProperty,
+    ) -> uint64_t;
 
-    pub fn crocksdb_table_properties_get_str(props: *const DBTableProperties,
+    pub fn crocksdb_table_properties_get_str(
+        props: *const DBTableProperties,
         prop: DBTableProperty,
-                                             slen: *mut size_t)
-                                             -> *const uint8_t;
+        slen: *mut size_t,
+    ) -> *const uint8_t;
 
-    pub fn crocksdb_table_properties_get_user_properties(props: *const DBTableProperties)
-                                                         -> *const DBUserCollectedProperties;
+    pub fn crocksdb_table_properties_get_user_properties(
+        props: *const DBTableProperties,
+    ) -> *const DBUserCollectedProperties;
 
-    pub fn crocksdb_user_collected_properties_get(props: *const DBUserCollectedProperties,
+    pub fn crocksdb_user_collected_properties_get(
+        props: *const DBUserCollectedProperties,
         key: *const uint8_t,
         klen: size_t,
-                                                  vlen: *mut size_t)
-                                                  -> *const uint8_t;
+        vlen: *mut size_t,
+    ) -> *const uint8_t;
 
-    pub fn crocksdb_user_collected_properties_len(props: *const DBUserCollectedProperties)
-                                                  -> size_t;
+    pub fn crocksdb_user_collected_properties_len(
+        props: *const DBUserCollectedProperties,
+    ) -> size_t;
 
-    pub fn crocksdb_table_properties_collection_len(props: *const DBTablePropertiesCollection)
-                                                    -> size_t;
+    pub fn crocksdb_table_properties_collection_len(
+        props: *const DBTablePropertiesCollection,
+    ) -> size_t;
 
     pub fn crocksdb_table_properties_collection_destroy(props: *mut DBTablePropertiesCollection);
 
-    pub fn crocksdb_table_properties_collection_iter_create
-        (props: *const DBTablePropertiesCollection)
-         -> *mut DBTablePropertiesCollectionIterator;
+    pub fn crocksdb_table_properties_collection_iter_create(
+        props: *const DBTablePropertiesCollection,
+    ) -> *mut DBTablePropertiesCollectionIterator;
 
-    pub fn crocksdb_table_properties_collection_iter_destroy
-        (it: *mut DBTablePropertiesCollectionIterator);
+    pub fn crocksdb_table_properties_collection_iter_destroy(
+        it: *mut DBTablePropertiesCollectionIterator,
+    );
 
-    pub fn crocksdb_table_properties_collection_iter_valid
-        (it: *const DBTablePropertiesCollectionIterator) -> bool;
+    pub fn crocksdb_table_properties_collection_iter_valid(
+        it: *const DBTablePropertiesCollectionIterator,
+    ) -> bool;
 
-    pub fn crocksdb_table_properties_collection_iter_next
-        (it: *mut DBTablePropertiesCollectionIterator);
+    pub fn crocksdb_table_properties_collection_iter_next(
+        it: *mut DBTablePropertiesCollectionIterator,
+    );
 
     pub fn crocksdb_table_properties_collection_iter_key(
-        it: *const DBTablePropertiesCollectionIterator, klen: *mut size_t) -> *const uint8_t;
+        it: *const DBTablePropertiesCollectionIterator,
+        klen: *mut size_t,
+    ) -> *const uint8_t;
 
-    pub fn crocksdb_table_properties_collection_iter_value
-        (it: *const DBTablePropertiesCollectionIterator) -> *const DBTableProperties;
+    pub fn crocksdb_table_properties_collection_iter_value(
+        it: *const DBTablePropertiesCollectionIterator,
+    ) -> *const DBTableProperties;
 
-    pub fn crocksdb_table_properties_collector_create(state: *mut c_void,
-                                                      name: extern "C" fn(*mut c_void)
-                                                                          -> *const c_char,
+    pub fn crocksdb_table_properties_collector_create(
+        state: *mut c_void,
+        name: extern "C" fn(*mut c_void) -> *const c_char,
         destruct: extern "C" fn(*mut c_void),
-                                                      add_userkey: extern "C" fn(*mut c_void,
+        add_userkey: extern "C" fn(
+            *mut c_void,
             *const uint8_t,
             size_t,
             *const uint8_t,
             size_t,
             c_int,
             uint64_t,
-                                                                                 uint64_t),
-                                                      finish: extern "C" fn(
-                                                          *mut c_void,
-                                                          *mut DBUserCollectedProperties))
-                                                      -> *mut DBTablePropertiesCollector;
+            uint64_t,
+        ),
+        finish: extern "C" fn(*mut c_void, *mut DBUserCollectedProperties),
+    ) -> *mut DBTablePropertiesCollector;
 
     pub fn crocksdb_table_properties_collector_destroy(c: *mut DBTablePropertiesCollector);
 
-    pub fn crocksdb_table_properties_collector_factory_create
-        (state: *mut c_void,
+    pub fn crocksdb_table_properties_collector_factory_create(
+        state: *mut c_void,
         name: extern "C" fn(*mut c_void) -> *const c_char,
         destruct: extern "C" fn(*mut c_void),
         create_table_properties_collector: extern "C" fn(*mut c_void, uint32_t)
-                                                          -> *mut DBTablePropertiesCollector)
-         -> *mut DBTablePropertiesCollectorFactory;
+            -> *mut DBTablePropertiesCollector,
+    ) -> *mut DBTablePropertiesCollectorFactory;
 
     pub fn crocksdb_table_properties_collector_factory_destroy(
-        f: *mut DBTablePropertiesCollectorFactory);
+        f: *mut DBTablePropertiesCollectorFactory,
+    );
 
     pub fn crocksdb_options_add_table_properties_collector_factory(
-        options: *mut Options, f: *mut DBTablePropertiesCollectorFactory);
+        options: *mut Options,
+        f: *mut DBTablePropertiesCollectorFactory,
+    );
 
-    pub fn crocksdb_get_properties_of_all_tables(db: *mut DBInstance,
-                                                 errptr: *mut *mut c_char)
-                                                 -> *mut DBTablePropertiesCollection;
+    pub fn crocksdb_get_properties_of_all_tables(
+        db: *mut DBInstance,
+        errptr: *mut *mut c_char,
+    ) -> *mut DBTablePropertiesCollection;
 
-    pub fn crocksdb_get_properties_of_all_tables_cf(db: *mut DBInstance,
+    pub fn crocksdb_get_properties_of_all_tables_cf(
+        db: *mut DBInstance,
         cf: *mut DBCFHandle,
-                                                    errptr: *mut *mut c_char)
-                                                    -> *mut DBTablePropertiesCollection;
+        errptr: *mut *mut c_char,
+    ) -> *mut DBTablePropertiesCollection;
 
-    pub fn crocksdb_get_properties_of_tables_in_range(db: *mut DBInstance,
+    pub fn crocksdb_get_properties_of_tables_in_range(
+        db: *mut DBInstance,
         cf: *mut DBCFHandle,
         num_ranges: c_int,
         start_keys: *const *const uint8_t,
         start_keys_lens: *const size_t,
         limit_keys: *const *const uint8_t,
         limit_keys_lens: *const size_t,
-                                                      errptr: *mut *mut c_char)
-                                                      -> *mut DBTablePropertiesCollection;
-
-    pub fn crocksdb_flushjobinfo_cf_name(info: *const DBFlushJobInfo,
-                                         size: *mut size_t)
-                                         -> *const c_char;
-    pub fn crocksdb_flushjobinfo_file_path(info: *const DBFlushJobInfo,
-                                           size: *mut size_t)
-                                           -> *const c_char;
-    pub fn crocksdb_flushjobinfo_table_properties(info: *const DBFlushJobInfo)
-                                                  -> *const DBTableProperties;
-
-    pub fn crocksdb_compactionjobinfo_cf_name(info: *const DBCompactionJobInfo,
-                                              size: *mut size_t)
-                                              -> *const c_char;
+        errptr: *mut *mut c_char,
+    ) -> *mut DBTablePropertiesCollection;
+
+    pub fn crocksdb_flushjobinfo_cf_name(
+        info: *const DBFlushJobInfo,
+        size: *mut size_t,
+    ) -> *const c_char;
+    pub fn crocksdb_flushjobinfo_file_path(
+        info: *const DBFlushJobInfo,
+        size: *mut size_t,
+    ) -> *const c_char;
+    pub fn crocksdb_flushjobinfo_table_properties(
+        info: *const DBFlushJobInfo,
+    ) -> *const DBTableProperties;
+
+    pub fn crocksdb_compactionjobinfo_cf_name(
+        info: *const DBCompactionJobInfo,
+        size: *mut size_t,
+    ) -> *const c_char;
     pub fn crocksdb_compactionjobinfo_input_files_count(info: *const DBCompactionJobInfo)
         -> size_t;
-    pub fn crocksdb_compactionjobinfo_input_file_at(info: *const DBCompactionJobInfo,
+    pub fn crocksdb_compactionjobinfo_input_file_at(
+        info: *const DBCompactionJobInfo,
         pos: size_t,
-                                                    len: *mut size_t)
-                                                    -> *const c_char;
-    pub fn crocksdb_compactionjobinfo_output_files_count(info: *const DBCompactionJobInfo)
-                                                         -> size_t;
-    pub fn crocksdb_compactionjobinfo_output_file_at(info: *const DBCompactionJobInfo,
+        len: *mut size_t,
+    ) -> *const c_char;
+    pub fn crocksdb_compactionjobinfo_output_files_count(
+        info: *const DBCompactionJobInfo,
+    ) -> size_t;
+    pub fn crocksdb_compactionjobinfo_output_file_at(
+        info: *const DBCompactionJobInfo,
         pos: size_t,
-                                                     len: *mut size_t)
-                                                     -> *const c_char;
-    pub fn crocksdb_compactionjobinfo_table_properties(info: *const DBCompactionJobInfo)
-                                                       -> *const DBTablePropertiesCollection;
-    pub fn crocksdb_compactionjobinfo_elapsed_micros(info: *const DBCompactionJobInfo)
-                                                     -> uint64_t;
-    pub fn crocksdb_compactionjobinfo_num_corrupt_keys(info: *const DBCompactionJobInfo)
-                                                       -> uint64_t;
-
-    pub fn crocksdb_externalfileingestioninfo_cf_name(info: *const DBIngestionInfo,
-                                                      size: *mut size_t)
-                                                      -> *const c_char;
-    pub fn crocksdb_externalfileingestioninfo_internal_file_path(info: *const DBIngestionInfo,
-                                                                 size: *mut size_t)
-                                                                 -> *const c_char;
-    pub fn crocksdb_externalfileingestioninfo_table_properties(info: *const DBIngestionInfo)
-                                                               -> *const DBTableProperties;
-
-    pub fn crocksdb_eventlistener_create(state: *mut c_void,
+        len: *mut size_t,
+    ) -> *const c_char;
+    pub fn crocksdb_compactionjobinfo_table_properties(
+        info: *const DBCompactionJobInfo,
+    ) -> *const DBTablePropertiesCollection;
+    pub fn crocksdb_compactionjobinfo_elapsed_micros(info: *const DBCompactionJobInfo) -> uint64_t;
+    pub fn crocksdb_compactionjobinfo_num_corrupt_keys(
+        info: *const DBCompactionJobInfo,
+    ) -> uint64_t;
+
+    pub fn crocksdb_externalfileingestioninfo_cf_name(
+        info: *const DBIngestionInfo,
+        size: *mut size_t,
+    ) -> *const c_char;
+    pub fn crocksdb_externalfileingestioninfo_internal_file_path(
+        info: *const DBIngestionInfo,
+        size: *mut size_t,
+    ) -> *const c_char;
+    pub fn crocksdb_externalfileingestioninfo_table_properties(
+        info: *const DBIngestionInfo,
+    ) -> *const DBTableProperties;
+
+    pub fn crocksdb_eventlistener_create(
+        state: *mut c_void,
         destructor: extern "C" fn(*mut c_void),
-                                         flush: extern "C" fn(*mut c_void,
-                                                              *mut DBInstance,
-                                                              *const DBFlushJobInfo),
-                                         compact: extern "C" fn(*mut c_void,
-                                                                *mut DBInstance,
-                                                                *const DBCompactionJobInfo),
-                                         ingest: extern "C" fn(*mut c_void,
-                                                               *mut DBInstance,
-                                                               *const DBIngestionInfo))
-                                         -> *mut DBEventListener;
+        flush: extern "C" fn(*mut c_void, *mut DBInstance, *const DBFlushJobInfo),
+        compact: extern "C" fn(*mut c_void, *mut DBInstance, *const DBCompactionJobInfo),
+        ingest: extern "C" fn(*mut c_void, *mut DBInstance, *const DBIngestionInfo),
+    ) -> *mut DBEventListener;
     pub fn crocksdb_eventlistener_destroy(et: *mut DBEventListener);
     pub fn crocksdb_options_add_eventlistener(opt: *mut Options, et: *mut DBEventListener);
     // Get All Key Versions
     pub fn crocksdb_keyversions_destroy(kvs: *mut DBKeyVersions);
 
-    pub fn crocksdb_get_all_key_versions(db: *mut DBInstance,
+    pub fn crocksdb_get_all_key_versions(
+        db: *mut DBInstance,
         begin_key: *const u8,
         begin_keylen: size_t,
         end_key: *const u8,
         end_keylen: size_t,
-                                         errptr: *mut *mut c_char)
-                                         -> *mut DBKeyVersions;
+        errptr: *mut *mut c_char,
+    ) -> *mut DBKeyVersions;
 
     pub fn crocksdb_keyversions_count(kvs: *mut DBKeyVersions) -> size_t;
 
@@ -1116,10 +1316,10 @@ extern "C" {
 
 #[cfg(test)]
 mod test {
+    use super::*;
     use libc::{self, c_void};
-    use std::{ptr, slice, fs};
+    use std::{fs, ptr, slice};
     use std::ffi::{CStr, CString};
-    use super::*;
     use tempdir::TempDir;
 
     #[test]
@@ -1165,29 +1365,37 @@ mod test {
             assert!(err.is_null(), error_message(err));
 
             let mut sizes = vec![0; 1];
-            crocksdb_approximate_sizes(db,
+            crocksdb_approximate_sizes(
+                db,
                 1,
                 vec![b"\x00\x00".as_ptr()].as_ptr(),
                 vec![1].as_ptr(),
                 vec![b"\xff\x00".as_ptr()].as_ptr(),
                 vec![1].as_ptr(),
-                                       sizes.as_mut_ptr());
+                sizes.as_mut_ptr(),
+            );
             assert_eq!(sizes.len(), 1);
             assert!(sizes[0] > 0);
 
-            crocksdb_delete_file_in_range(db,
+            crocksdb_delete_file_in_range(
+                db,
                 b"\x00\x00".as_ptr(),
                 2,
                 b"\xff\x00".as_ptr(),
                 2,
-                                          &mut err);
+                &mut err,
+            );
             assert!(err.is_null(), error_message(err));
 
             let propname = CString::new("rocksdb.total-sst-files-size").unwrap();
             let value = crocksdb_property_value(db, propname.as_ptr());
             assert!(!value.is_null());
 
-            let sst_size = CStr::from_ptr(value).to_str().unwrap().parse::<u64>().unwrap();
+            let sst_size = CStr::from_ptr(value)
+                .to_str()
+                .unwrap()
+                .parse::<u64>()
+                .unwrap();
             assert!(sst_size > 0);
             libc::free(value as *mut c_void);
 
@@ -1202,10 +1410,12 @@ mod test {
         }
     }
 
-    unsafe fn check_get(db: *mut DBInstance,
+    unsafe fn check_get(
+        db: *mut DBInstance,
         opt: *const DBReadOptions,
         key: &[u8],
-                        val: Option<&[u8]>) {
+        val: Option<&[u8]>,
+    ) {
         let mut val_len = 0;
         let mut err = ptr::null_mut();
         let res_ptr = crocksdb_get(db, opt, key.as_ptr(), key.len(), &mut val_len, &mut err);

src/compaction_filter.rs

 use crocksdb_ffi::{self, DBCompactionFilter};
-use libc::{c_void, c_char, c_int, size_t};
+use libc::{c_char, c_int, c_void, size_t};
 use std::ffi::CString;
 use std::slice;
 
@@ -34,7 +34,8 @@ extern "C" fn destructor(filter: *mut c_void) {
     }
 }
 
-extern "C" fn filter(filter: *mut c_void,
+extern "C" fn filter(
+    filter: *mut c_void,
     level: c_int,
     key: *const u8,
     key_len: size_t,
@@ -42,8 +43,8 @@ extern "C" fn filter(filter: *mut c_void,
     value_len: size_t,
     _: *mut *mut u8,
     _: *mut size_t,
-                     value_changed: *mut bool)
-                     -> bool {
+    value_changed: *mut bool,
+) -> bool {
     unsafe {
         let filter = &mut *(filter as *mut CompactionFilterProxy);
         let key = slice::from_raw_parts(key, key_len);
@@ -65,18 +66,21 @@ impl Drop for CompactionFilterHandle {
     }
 }
 
-pub unsafe fn new_compaction_filter(c_name: CString,
+pub unsafe fn new_compaction_filter(
+    c_name: CString,
     ignore_snapshots: bool,
-                                    f: Box<CompactionFilter>)
-                                    -> Result<CompactionFilterHandle, String> {
+    f: Box<CompactionFilter>,
+) -> Result<CompactionFilterHandle, String> {
     let proxy = Box::into_raw(Box::new(CompactionFilterProxy {
         name: c_name,
         filter: f,
     }));
-    let filter = crocksdb_ffi::crocksdb_compactionfilter_create(proxy as *mut c_void,
+    let filter = crocksdb_ffi::crocksdb_compactionfilter_create(
+        proxy as *mut c_void,
         destructor,
         filter,
-                                                                name);
+        name,
+    );
     crocksdb_ffi::crocksdb_compactionfilter_set_ignore_snapshots(filter, ignore_snapshots);
     Ok(CompactionFilterHandle { inner: filter })
 }

src/comparator.rs

@@ -36,12 +36,13 @@ pub extern "C" fn name_callback(raw_cb: *mut c_void) -> *const c_char {
     }
 }
 
-pub extern "C" fn compare_callback(raw_cb: *mut c_void,
+pub extern "C" fn compare_callback(
+    raw_cb: *mut c_void,
     a_raw: *const c_char,
     a_len: size_t,
     b_raw: *const c_char,
-                                   b_len: size_t)
-                                   -> c_int {
+    b_len: size_t,
+) -> c_int {
     unsafe {
         let cb: &mut ComparatorCallback = &mut *(raw_cb as *mut ComparatorCallback);
         let a: &[u8] = slice::from_raw_parts(a_raw as *const u8, a_len as usize);

src/event_listener.rs

@@ -13,10 +13,10 @@
 
 
 use {TableProperties, TablePropertiesCollectionView};
-use crocksdb_ffi::{self, DBInstance, DBFlushJobInfo, DBCompactionJobInfo, DBIngestionInfo,
-                   DBEventListener};
+use crocksdb_ffi::{self, DBCompactionJobInfo, DBEventListener, DBFlushJobInfo, DBIngestionInfo,
+                   DBInstance};
 use libc::c_void;
-use std::{slice, mem, str};
+use std::{mem, slice, str};
 use std::path::Path;
 
 
@@ -98,8 +98,11 @@ impl IngestionInfo {
     }
 
     pub fn internal_file_path(&self) -> &Path {
-        let p =
-            unsafe { fetch_str!(crocksdb_externalfileingestioninfo_internal_file_path(&self.0)) };
+        let p = unsafe {
+            fetch_str!(crocksdb_externalfileingestioninfo_internal_file_path(
+                &self.0
+            ))
+        };
         Path::new(p)
     }
 
@@ -134,23 +137,29 @@ extern "C" fn destructor(ctx: *mut c_void) {
 
 // Maybe we should reuse db instance?
 // TODO: refactor DB implement so that we can convert DBInstance to DB.
-extern "C" fn on_flush_completed(ctx: *mut c_void,
+extern "C" fn on_flush_completed(
+    ctx: *mut c_void,
     _: *mut DBInstance,
-                                 info: *const DBFlushJobInfo) {
+    info: *const DBFlushJobInfo,
+) {
     let (ctx, info) = unsafe { (&*(ctx as *mut Box<EventListener>), mem::transmute(&*info)) };
     ctx.on_flush_completed(info);
 }
 
-extern "C" fn on_compaction_completed(ctx: *mut c_void,
+extern "C" fn on_compaction_completed(
+    ctx: *mut c_void,
     _: *mut DBInstance,
-                                      info: *const DBCompactionJobInfo) {
+    info: *const DBCompactionJobInfo,
+) {
     let (ctx, info) = unsafe { (&*(ctx as *mut Box<EventListener>), mem::transmute(&*info)) };
     ctx.on_compaction_completed(info);
 }
 
-extern "C" fn on_external_file_ingested(ctx: *mut c_void,
+extern "C" fn on_external_file_ingested(
+    ctx: *mut c_void,
     _: *mut DBInstance,
-                                        info: *const DBIngestionInfo) {
+    info: *const DBIngestionInfo,
+) {
     let (ctx, info) = unsafe { (&*(ctx as *mut Box<EventListener>), mem::transmute(&*info)) };
     ctx.on_external_file_ingested(info);
 }
@@ -158,10 +167,12 @@ extern "C" fn on_external_file_ingested(ctx: *mut c_void,
 pub fn new_event_listener<L: EventListener>(l: L) -> *mut DBEventListener {
     let p: Box<EventListener> = Box::new(l);
     unsafe {
-        crocksdb_ffi::crocksdb_eventlistener_create(Box::into_raw(Box::new(p)) as *mut c_void,
+        crocksdb_ffi::crocksdb_eventlistener_create(
+            Box::into_raw(Box::new(p)) as *mut c_void,
             destructor,
             on_flush_completed,
             on_compaction_completed,
-                                                    on_external_file_ingested)
+            on_external_file_ingested,
+        )
     }
 }

src/lib.rs

@@ -32,16 +32,16 @@ mod table_properties_collector_factory;
 mod event_listener;
 
 pub use compaction_filter::CompactionFilter;
-pub use event_listener::{EventListener, CompactionJobInfo, IngestionInfo, FlushJobInfo};
-pub use librocksdb_sys::{DBCompactionStyle, DBCompressionType, DBRecoveryMode, DBInfoLogLevel,
-                         DBStatisticsTickerType, DBStatisticsHistogramType, new_bloom_filter,
-                         CompactionPriority, DBEntryType, self as crocksdb_ffi};
+pub use event_listener::{CompactionJobInfo, EventListener, FlushJobInfo, IngestionInfo};
+pub use librocksdb_sys::{self as crocksdb_ffi, new_bloom_filter, CompactionPriority,
+                         DBCompactionStyle, DBCompressionType, DBEntryType, DBInfoLogLevel,
+                         DBRecoveryMode, DBStatisticsHistogramType, DBStatisticsTickerType};
 pub use merge_operator::MergeOperands;
-pub use rocksdb::{DB, DBIterator, DBVector, Kv, SeekKey, Writable, WriteBatch, CFHandle, Range,
-                  BackupEngine, SstFileWriter};
-pub use rocksdb_options::{BlockBasedOptions, DBOptions, ColumnFamilyOptions, ReadOptions,
-                          WriteOptions, RestoreOptions, IngestExternalFileOptions, EnvOptions,
-                          HistogramData, CompactOptions};
+pub use rocksdb::{BackupEngine, CFHandle, DBIterator, DBVector, Kv, Range, SeekKey, SstFileWriter,
+                  Writable, WriteBatch, DB};
+pub use rocksdb_options::{BlockBasedOptions, ColumnFamilyOptions, CompactOptions, DBOptions,
+                          EnvOptions, HistogramData, IngestExternalFileOptions, ReadOptions,
+                          RestoreOptions, WriteOptions};
 pub use slice_transform::SliceTransform;
 pub use table_properties::{TableProperties, TablePropertiesCollection,
                            TablePropertiesCollectionView, UserCollectedProperties};

src/main.rs

@@ -14,7 +14,7 @@
 //
 
 extern crate rocksdb;
-use rocksdb::{DB, MergeOperands, DBOptions, Writable, ColumnFamilyOptions};
+use rocksdb::{ColumnFamilyOptions, DBOptions, MergeOperands, Writable, DB};
 
 // fn snapshot_test() {
 //    let path = "_rust_rocksdb_iteratortest";
@@ -52,12 +52,10 @@ fn main() {
     let db = DB::open_default(path).unwrap();
     assert!(db.put(b"my key", b"my value").is_ok());
     match db.get(b"my key") {
-        Ok(Some(value)) => {
-            match value.to_utf8() {
+        Ok(Some(value)) => match value.to_utf8() {
             Some(v) => println!("retrieved utf8 value: {}", v),
             None => println!("did not read valid utf-8 out of the db"),
-            }
-        }
+        },
         Ok(None) => panic!("value not present!"),
         Err(e) => println!("error retrieving value: {}", e),
     }
@@ -70,11 +68,9 @@ fn main() {
 fn concat_merge(_: &[u8], existing_val: Option<&[u8]>, operands: &mut MergeOperands) -> Vec<u8> {
     let mut result: Vec<u8> = Vec::with_capacity(operands.size_hint().0);
     match existing_val {
-        Some(v) => {
-            for e in v {
+        Some(v) => for e in v {
             result.push(*e)
-            }
-        }
+        },
         None => (),
     }
     for op in operands {
@@ -100,12 +96,10 @@ fn custom_merge() {
         db.merge(b"k1", b"efg").unwrap();
         db.merge(b"k1", b"h").unwrap();
         match db.get(b"k1") {
-            Ok(Some(value)) => {
-                match value.to_utf8() {
+            Ok(Some(value)) => match value.to_utf8() {
                 Some(v) => println!("retrieved utf8 value: {}", v),
                 None => println!("did not read valid utf-8 out of the db"),
-                }
-            }
+            },
             Ok(None) => panic!("value not present!"),
             Err(e) => println!("error retrieving value: {}", e),
         }
@@ -116,22 +110,25 @@ fn custom_merge() {
 
 #[cfg(test)]
 mod tests {
-    use rocksdb::{BlockBasedOptions, DB, DBCompressionType, ColumnFamilyOptions, DBOptions};
+    use rocksdb::{BlockBasedOptions, ColumnFamilyOptions, DBCompressionType, DBOptions, DB};
     use rocksdb::DBCompactionStyle;
     use rocksdb::DBRecoveryMode;
 
     #[allow(dead_code)]
-    fn tuned_for_somebody_elses_disk(path: &str,
+    fn tuned_for_somebody_elses_disk(
+        path: &str,
         mut opts: DBOptions,
-                                     blockopts: &mut BlockBasedOptions)
-                                     -> DB {
-        let per_level_compression: [DBCompressionType; 7] = [DBCompressionType::No,
+        blockopts: &mut BlockBasedOptions,
+    ) -> DB {
+        let per_level_compression: [DBCompressionType; 7] = [
             DBCompressionType::No,
             DBCompressionType::No,
+            DBCompressionType::No,
+            DBCompressionType::Lz4,
             DBCompressionType::Lz4,
             DBCompressionType::Lz4,
             DBCompressionType::Lz4,
-                                                             DBCompressionType::Lz4];
+        ];
         let mut cf_opts = ColumnFamilyOptions::new();
         opts.create_if_missing(true);
         opts.set_max_open_files(10000);

src/merge_operator.rs

@@ -41,7 +41,8 @@ pub extern "C" fn name_callback(raw_cb: *mut c_void) -> *const c_char {
     }
 }
 
-pub extern "C" fn full_merge_callback(raw_cb: *mut c_void,
+pub extern "C" fn full_merge_callback(
+    raw_cb: *mut c_void,
     raw_key: *const c_char,
     key_len: size_t,
     existing_value: *const c_char,
@@ -50,14 +51,14 @@ pub extern "C" fn full_merge_callback(raw_cb: *mut c_void,
     operands_list_len: *const size_t,
     num_operands: c_int,
     success: *mut u8,
-                                      new_value_length: *mut size_t)
-                                      -> *const c_char {
+    new_value_length: *mut size_t,
+) -> *const c_char {
     unsafe {
         let cb: &mut MergeOperatorCallback = &mut *(raw_cb as *mut MergeOperatorCallback);
         let operands = &mut MergeOperands::new(operands_list, operands_list_len, num_operands);
         let key: &[u8] = slice::from_raw_parts(raw_key as *const u8, key_len as usize);
-        let oldval: &[u8] = slice::from_raw_parts(existing_value as *const u8,
-                                                  existing_value_len as usize);
+        let oldval: &[u8] =
+            slice::from_raw_parts(existing_value as *const u8, existing_value_len as usize);
         let mut result = (cb.merge_fn)(key, Some(oldval), operands);
         result.shrink_to_fit();
         // TODO(tan) investigate zero-copy techniques to improve performance
@@ -70,15 +71,16 @@ pub extern "C" fn full_merge_callback(raw_cb: *mut c_void,
     }
 }
 
-pub extern "C" fn partial_merge_callback(raw_cb: *mut c_void,
+pub extern "C" fn partial_merge_callback(
+    raw_cb: *mut c_void,
     raw_key: *const c_char,
     key_len: size_t,
     operands_list: *const *const c_char,
     operands_list_len: *const size_t,
     num_operands: c_int,
     success: *mut u8,
-                                         new_value_length: *mut size_t)
-                                         -> *const c_char {
+    new_value_length: *mut size_t,
+) -> *const c_char {
     unsafe {
         let cb: &mut MergeOperatorCallback = &mut *(raw_cb as *mut MergeOperatorCallback);
         let operands = &mut MergeOperands::new(operands_list, operands_list_len, num_operands);
@@ -104,10 +106,11 @@ pub struct MergeOperands {
 }
 
 impl MergeOperands {
-    fn new(operands_list: *const *const c_char,
+    fn new(
+        operands_list: *const *const c_char,
         operands_list_len: *const size_t,
-           num_operands: c_int)
-           -> MergeOperands {
+        num_operands: c_int,
+    ) -> MergeOperands {
         assert!(num_operands >= 0);
         MergeOperands {
             operands_list: operands_list,
@@ -133,8 +136,10 @@ impl<'a> Iterator for &'a mut MergeOperands {
                 let len = *len_ptr as usize;
                 let ptr = base + (spacing * self.cursor);
                 self.cursor += 1;
-                Some(mem::transmute(slice::from_raw_parts(*(ptr as *const *const u8) as *const u8,
-                                                          len)))
+                Some(mem::transmute(slice::from_raw_parts(
+                    *(ptr as *const *const u8) as *const u8,
+                    len,
+                )))
             }
         }
     }
@@ -147,17 +152,18 @@ impl<'a> Iterator for &'a mut MergeOperands {
 
 #[cfg(test)]
 mod test {
-    use rocksdb::{DB, DBVector, Writable};
-    use rocksdb_options::{DBOptions, ColumnFamilyOptions};
     use super::*;
+    use rocksdb::{DBVector, Writable, DB};
+    use rocksdb_options::{ColumnFamilyOptions, DBOptions};
     use tempdir::TempDir;
 
     #[allow(unused_variables)]
     #[allow(dead_code)]
-    fn test_provided_merge(new_key: &[u8],
+    fn test_provided_merge(
+        new_key: &[u8],
         existing_val: Option<&[u8]>,
-                           operands: &mut MergeOperands)
-                           -> Vec<u8> {
+        operands: &mut MergeOperands,
+    ) -> Vec<u8> {
         let nops = operands.size_hint().0;
         let mut result: Vec<u8> = Vec::with_capacity(nops);
         if let Some(v) = existing_val {
@@ -181,11 +187,12 @@ mod test {
         opts.create_if_missing(true);
         let mut cf_opts = ColumnFamilyOptions::new();
         cf_opts.add_merge_operator("test operator", test_provided_merge);
-        let db = DB::open_cf(opts,
+        let db = DB::open_cf(
+            opts,
             path.path().to_str().unwrap(),
             vec!["default"],
-                             vec![cf_opts])
-            .unwrap();
+            vec![cf_opts],
+        ).unwrap();
         let p = db.put(b"k1", b"a");
         assert!(p.is_ok());
         let _ = db.merge(b"k1", b"b");
@@ -195,12 +202,10 @@ mod test {
         let m = db.merge(b"k1", b"h");
         assert!(m.is_ok());
         match db.get(b"k1") {
-            Ok(Some(value)) => {
-                match value.to_utf8() {
+            Ok(Some(value)) => match value.to_utf8() {
                 Some(v) => println!("retrieved utf8 value: {}", v),
                 None => println!("did not read valid utf-8 out of the db"),
-                }
-            }
+            },
             Err(e) => println!("error reading value {:?}", e),
             _ => panic!("value not present"),
         }

src/rocksdb.rs

@@ -13,13 +13,13 @@
 // limitations under the License.
 //
 
-use crocksdb_ffi::{self, DBWriteBatch, DBCFHandle, DBInstance, DBBackupEngine,
-                   DBStatisticsTickerType, DBStatisticsHistogramType, DBPinnableSlice,
-                   DBCompressionType};
+use crocksdb_ffi::{self, DBBackupEngine, DBCFHandle, DBCompressionType, DBInstance,
+                   DBPinnableSlice, DBStatisticsHistogramType, DBStatisticsTickerType,
+                   DBWriteBatch};
 use libc::{self, c_int, c_void, size_t};
-use rocksdb_options::{DBOptions, ColumnFamilyOptions, ReadOptions, UnsafeSnap, WriteOptions,
-                      FlushOptions, EnvOptions, RestoreOptions, IngestExternalFileOptions,
-                      HistogramData, CompactOptions};
+use rocksdb_options::{ColumnFamilyOptions, CompactOptions, DBOptions, EnvOptions, FlushOptions,
+                      HistogramData, IngestExternalFileOptions, ReadOptions, RestoreOptions,
+                      UnsafeSnap, WriteOptions};
 use std::{fs, ptr, slice};
 use std::collections::BTreeMap;
 use std::collections::btree_map::Entry;
@@ -51,7 +51,8 @@ impl Drop for CFHandle {
 }
 
 fn build_cstring_list(str_list: &[&str]) -> Vec<CString> {
-    str_list.into_iter()
+    str_list
+        .into_iter()
         .map(|s| CString::new(s.as_bytes()).unwrap())
         .collect()
 }
@@ -135,11 +136,11 @@ impl<'a> DBIterator<'a> {
             match key {
                 SeekKey::Start => crocksdb_ffi::crocksdb_iter_seek_to_first(self.inner),
                 SeekKey::End => crocksdb_ffi::crocksdb_iter_seek_to_last(self.inner),
-                SeekKey::Key(key) => {
-                    crocksdb_ffi::crocksdb_iter_seek_for_prev(self.inner,
+                SeekKey::Key(key) => crocksdb_ffi::crocksdb_iter_seek_for_prev(
+                    self.inner,
                     key.as_ptr(),
-                                                              key.len() as size_t)
-                }
+                    key.len() as size_t,
+                ),
             }
         }
         self.valid()
@@ -193,9 +194,11 @@ impl<'a> DBIterator<'a> {
 
     pub fn new_cf(db: &'a DB, cf_handle: &CFHandle, readopts: ReadOptions) -> DBIterator<'a> {
         unsafe {
-            let iterator = crocksdb_ffi::crocksdb_create_iterator_cf(db.inner,
+            let iterator = crocksdb_ffi::crocksdb_create_iterator_cf(
+                db.inner,
                 readopts.get_inner(),
-                                                                     cf_handle.inner);
+                cf_handle.inner,
+            );
             DBIterator {
                 db: db,
                 readopts: readopts,
@@ -283,11 +286,12 @@ pub trait Writable {
     fn single_delete(&self, key: &[u8]) -> Result<(), String>;
     fn single_delete_cf(&self, cf: &CFHandle, key: &[u8]) -> Result<(), String>;
     fn delete_range(&self, begin_key: &[u8], end_key: &[u8]) -> Result<(), String>;
-    fn delete_range_cf(&self,
+    fn delete_range_cf(
+        &self,
         cf: &CFHandle,
         begin_key: &[u8],
-                       end_key: &[u8])
-                       -> Result<(), String>;
+        end_key: &[u8],
+    ) -> Result<(), String>;
 }
 
 /// A range of keys, `start_key` is included, but not `end_key`.
@@ -326,22 +330,27 @@ impl DB {
         DB::open_cf(opts, path, vec![], vec![])
     }
 
-    pub fn open_cf(opts: DBOptions,
+    pub fn open_cf(
+        opts: DBOptions,
         path: &str,
         cfs: Vec<&str>,
-                   cf_opts: Vec<ColumnFamilyOptions>)
-                   -> Result<DB, String> {
+        cf_opts: Vec<ColumnFamilyOptions>,
+    ) -> Result<DB, String> {
         let cpath = match CString::new(path.as_bytes()) {
             Ok(c) => c,
             Err(_) => {
-                return Err("Failed to convert path to CString when opening rocksdb".to_owned())
+                return Err(
+                    "Failed to convert path to CString when opening rocksdb".to_owned(),
+                )
             }
         };
         if let Err(e) = fs::create_dir_all(&Path::new(path)) {
-            return Err(format!("Failed to create rocksdb directory: \
+            return Err(format!(
+                "Failed to create rocksdb directory: \
                  src/rocksdb.rs:                              \
                  {:?}",
-                               e));
+                e
+            ));
         }
         if cfs.len() != cf_opts.len() {
             return Err(format!("cfs.len() and cf_opts.len() not match."));
@@ -365,17 +374,20 @@ impl DB {
             // These handles will be populated by DB.
             let cfhandles: Vec<_> = cfs_v.iter().map(|_| ptr::null_mut()).collect();
 
-            let cfopts: Vec<_> = cf_opts_v.iter()
+            let cfopts: Vec<_> = cf_opts_v
+                .iter()
                 .map(|x| x.inner as *const crocksdb_ffi::Options)
                 .collect();
 
             let db = unsafe {
-                ffi_try!(crocksdb_open_column_families(opts.inner,
+                ffi_try!(crocksdb_open_column_families(
+                    opts.inner,
                     cpath.as_ptr(),
                     cfs_v.len() as c_int,
                     cfnames.as_ptr(),
                     cfopts.as_ptr(),
-                                                       cfhandles.as_ptr()))
+                    cfhandles.as_ptr()
+                ))
             };
 
             for handle in &cfhandles {
@@ -425,17 +437,22 @@ impl DB {
         let cpath = match CString::new(path.as_bytes()) {
             Ok(c) => c,
             Err(_) => {
-                return Err("Failed to convert path to CString when list \
+                return Err(
+                    "Failed to convert path to CString when list \
                      column families"
-                    .to_owned())
+                        .to_owned(),
+                )
             }
         };
 
         let mut cfs: Vec<String> = vec![];
         unsafe {
             let mut lencf: size_t = 0;
-            let list =
-                ffi_try!(crocksdb_list_column_families(opts.inner, cpath.as_ptr(), &mut lencf));
+            let list = ffi_try!(crocksdb_list_column_families(
+                opts.inner,
+                cpath.as_ptr(),
+                &mut lencf
+            ));
             let list_cfs = slice::from_raw_parts(list, lencf);
             for &cf_name in list_cfs {
                 let cf = match CStr::from_ptr(cf_name).to_owned().into_string() {
@@ -485,10 +502,12 @@ impl DB {
 
     pub fn get_opt(&self, key: &[u8], readopts: &ReadOptions) -> Result<Option<DBVector>, String> {
         unsafe {
-            let val = ffi_try!(crocksdb_get_pinned(self.inner,
+            let val = ffi_try!(crocksdb_get_pinned(
+                self.inner,
                 readopts.get_inner(),
                 key.as_ptr(),
-                                                   key.len() as size_t));
+                key.len() as size_t
+            ));
             if val.is_null() {
                 Ok(None)
             } else {
@@ -501,17 +520,20 @@ impl DB {
         self.get_opt(key, &ReadOptions::new())
     }
 
-    pub fn get_cf_opt(&self,
+    pub fn get_cf_opt(
+        &self,
         cf: &CFHandle,
         key: &[u8],
-                      readopts: &ReadOptions)
-                      -> Result<Option<DBVector>, String> {
+        readopts: &ReadOptions,
+    ) -> Result<Option<DBVector>, String> {
         unsafe {
-            let val = ffi_try!(crocksdb_get_pinned_cf(self.inner,
+            let val = ffi_try!(crocksdb_get_pinned_cf(
+                self.inner,
                 readopts.get_inner(),
                 cf.inner,
                 key.as_ptr(),
-                                                      key.len() as size_t));
+                key.len() as size_t
+            ));
             if val.is_null() {
                 Ok(None)
             } else {
@@ -524,20 +546,26 @@ impl DB {
         self.get_cf_opt(cf, key, &ReadOptions::new())
     }
 
-    pub fn create_cf(&mut self,
+    pub fn create_cf(
+        &mut self,
         name: &str,
-                     cf_opts: ColumnFamilyOptions)
-                     -> Result<&CFHandle, String> {
+        cf_opts: ColumnFamilyOptions,
+    ) -> Result<&CFHandle, String> {
         let cname = match CString::new(name.as_bytes()) {
             Ok(c) => c,
             Err(_) => {
-                return Err("Failed to convert path to CString when opening rocksdb".to_owned())
+                return Err(
+                    "Failed to convert path to CString when opening rocksdb".to_owned(),
+                )
             }
         };
         let cname_ptr = cname.as_ptr();
         unsafe {
-            let cf_handler =
-                ffi_try!(crocksdb_create_column_family(self.inner, cf_opts.inner, cname_ptr));
+            let cf_handler = ffi_try!(crocksdb_create_column_family(
+                self.inner,
+                cf_opts.inner,
+                cname_ptr
+            ));
             let handle = CFHandle { inner: cf_handler };
             self._cf_opts.push(cf_opts);
             Ok(match self.cfs.entry(name.to_owned()) {
@@ -602,135 +630,160 @@ impl DB {
         crocksdb_ffi::crocksdb_release_snapshot(self.inner, snap.get_inner())
     }
 
-    pub fn put_opt(&self,
+    pub fn put_opt(
+        &self,
         key: &[u8],
         value: &[u8],
-                   writeopts: &WriteOptions)
-                   -> Result<(), String> {
+        writeopts: &WriteOptions,
+    ) -> Result<(), String> {
         unsafe {
-            ffi_try!(crocksdb_put(self.inner,
+            ffi_try!(crocksdb_put(
+                self.inner,
                 writeopts.inner,
                 key.as_ptr(),
                 key.len() as size_t,
                 value.as_ptr(),
-                                  value.len() as size_t));
+                value.len() as size_t
+            ));
             Ok(())
         }
     }
 
-    pub fn put_cf_opt(&self,
+    pub fn put_cf_opt(
+        &self,
         cf: &CFHandle,
         key: &[u8],
         value: &[u8],
-                      writeopts: &WriteOptions)
-                      -> Result<(), String> {
+        writeopts: &WriteOptions,
+    ) -> Result<(), String> {
         unsafe {
-            ffi_try!(crocksdb_put_cf(self.inner,
+            ffi_try!(crocksdb_put_cf(
+                self.inner,
                 writeopts.inner,
                 cf.inner,
                 key.as_ptr(),
                 key.len() as size_t,
                 value.as_ptr(),
-                                     value.len() as size_t));
+                value.len() as size_t
+            ));
             Ok(())
         }
     }
-    pub fn merge_opt(&self,
+    pub fn merge_opt(
+        &self,
         key: &[u8],
         value: &[u8],
-                     writeopts: &WriteOptions)
-                     -> Result<(), String> {
+        writeopts: &WriteOptions,
+    ) -> Result<(), String> {
         unsafe {
-            ffi_try!(crocksdb_merge(self.inner,
+            ffi_try!(crocksdb_merge(
+                self.inner,
                 writeopts.inner,
                 key.as_ptr(),
                 key.len() as size_t,
                 value.as_ptr(),
-                                    value.len() as size_t));
+                value.len() as size_t
+            ));
             Ok(())
         }
     }
-    fn merge_cf_opt(&self,
+    fn merge_cf_opt(
+        &self,
         cf: &CFHandle,
         key: &[u8],
         value: &[u8],
-                    writeopts: &WriteOptions)
-                    -> Result<(), String> {
+        writeopts: &WriteOptions,
+    ) -> Result<(), String> {
         unsafe {
-            ffi_try!(crocksdb_merge_cf(self.inner,
+            ffi_try!(crocksdb_merge_cf(
+                self.inner,
                 writeopts.inner,
                 cf.inner,
                 key.as_ptr(),
                 key.len() as size_t,
                 value.as_ptr(),
-                                       value.len() as size_t));
+                value.len() as size_t
+            ));
             Ok(())
         }
     }
     fn delete_opt(&self, key: &[u8], writeopts: &WriteOptions) -> Result<(), String> {
         unsafe {
-            ffi_try!(crocksdb_delete(self.inner,
+            ffi_try!(crocksdb_delete(
+                self.inner,
                 writeopts.inner,
                 key.as_ptr(),
-                                     key.len() as size_t));
+                key.len() as size_t
+            ));
             Ok(())
         }
     }
 
-    fn delete_cf_opt(&self,
+    fn delete_cf_opt(
+        &self,
         cf: &CFHandle,
         key: &[u8],
-                     writeopts: &WriteOptions)
-                     -> Result<(), String> {
+        writeopts: &WriteOptions,
+    ) -> Result<(), String> {
         unsafe {
-            ffi_try!(crocksdb_delete_cf(self.inner,
+            ffi_try!(crocksdb_delete_cf(
+                self.inner,
                 writeopts.inner,
                 cf.inner,
                 key.as_ptr(),
-                                        key.len() as size_t));
+                key.len() as size_t
+            ));
             Ok(())
         }
     }
 
     fn single_delete_opt(&self, key: &[u8], writeopts: &WriteOptions) -> Result<(), String> {
         unsafe {
-            ffi_try!(crocksdb_single_delete(self.inner,
+            ffi_try!(crocksdb_single_delete(
+                self.inner,
                 writeopts.inner,
                 key.as_ptr(),
-                                            key.len() as size_t));
+                key.len() as size_t
+            ));
             Ok(())
         }
     }
 
-    fn single_delete_cf_opt(&self,
+    fn single_delete_cf_opt(
+        &self,
         cf: &CFHandle,
         key: &[u8],
-                            writeopts: &WriteOptions)
-                            -> Result<(), String> {
+        writeopts: &WriteOptions,
+    ) -> Result<(), String> {
         unsafe {
-            ffi_try!(crocksdb_single_delete_cf(self.inner,
+            ffi_try!(crocksdb_single_delete_cf(
+                self.inner,
                 writeopts.inner,
                 cf.inner,
                 key.as_ptr(),
-                                               key.len() as size_t));
+                key.len() as size_t
+            ));
             Ok(())
         }
     }
 
-    fn delete_range_cf_opt(&self,
+    fn delete_range_cf_opt(
+        &self,
         cf: &CFHandle,
         begin_key: &[u8],
         end_key: &[u8],
-                           writeopts: &WriteOptions)
-                           -> Result<(), String> {
+        writeopts: &WriteOptions,
+    ) -> Result<(), String> {
         unsafe {
-            ffi_try!(crocksdb_delete_range_cf(self.inner,
+            ffi_try!(crocksdb_delete_range_cf(
+                self.inner,
                 writeopts.inner,
                 cf.inner,
                 begin_key.as_ptr(),
                 begin_key.len() as size_t,
                 end_key.as_ptr(),
-                                              end_key.len() as size_t));
+                end_key.len() as size_t
+            ));
             Ok(())
         }
     }
@@ -789,32 +842,37 @@ impl DB {
         let end_keys: Vec<*const u8> = ranges.iter().map(|x| x.end_key.as_ptr()).collect();
         let end_key_lens: Vec<_> = ranges.iter().map(|x| x.end_key.len()).collect();
         let mut sizes: Vec<u64> = vec![0; ranges.len()];
-        let (n, start_key_ptr, start_key_len_ptr, end_key_ptr, end_key_len_ptr, size_ptr) =
-            (ranges.len() as i32,
+        let (n, start_key_ptr, start_key_len_ptr, end_key_ptr, end_key_len_ptr, size_ptr) = (
+            ranges.len() as i32,
             start_keys.as_ptr(),
             start_key_lens.as_ptr(),
             end_keys.as_ptr(),
             end_key_lens.as_ptr(),
-             sizes.as_mut_ptr());
+            sizes.as_mut_ptr(),
+        );
         match cf {
             None => unsafe {
-                crocksdb_ffi::crocksdb_approximate_sizes(self.inner,
+                crocksdb_ffi::crocksdb_approximate_sizes(
+                    self.inner,
                     n,
                     start_key_ptr,
                     start_key_len_ptr,
                     end_key_ptr,
                     end_key_len_ptr,
-                                                         size_ptr)
+                    size_ptr,
+                )
             },
             Some(cf) => unsafe {
-                crocksdb_ffi::crocksdb_approximate_sizes_cf(self.inner,
+                crocksdb_ffi::crocksdb_approximate_sizes_cf(
+                    self.inner,
                     cf.inner,
                     n,
                     start_key_ptr,
                     start_key_len_ptr,
                     end_key_ptr,
                     end_key_len_ptr,
-                                                            size_ptr)
+                    size_ptr,
+                )
             },
         }
         sizes
@@ -824,13 +882,15 @@ impl DB {
     pub fn get_approximate_memtable_stats(&self, range: &Range) -> (u64, u64) {
         let (mut count, mut size) = (0, 0);
         unsafe {
-            crocksdb_ffi::crocksdb_approximate_memtable_stats(self.inner,
+            crocksdb_ffi::crocksdb_approximate_memtable_stats(
+                self.inner,
                 range.start_key.as_ptr(),
                 range.start_key.len(),
                 range.end_key.as_ptr(),
                 range.end_key.len(),
                 &mut count,
-                                                              &mut size);
+                &mut size,
+            );
         }
         (count, size)
     }
@@ -839,14 +899,16 @@ impl DB {
     pub fn get_approximate_memtable_stats_cf(&self, cf: &CFHandle, range: &Range) -> (u64, u64) {
         let (mut count, mut size) = (0, 0);
         unsafe {
-            crocksdb_ffi::crocksdb_approximate_memtable_stats_cf(self.inner,
+            crocksdb_ffi::crocksdb_approximate_memtable_stats_cf(
+                self.inner,
                 cf.inner,
                 range.start_key.as_ptr(),
                 range.start_key.len(),
                 range.end_key.as_ptr(),
                 range.end_key.len(),
                 &mut count,
-                                                                 &mut size);
+                &mut size,
+            );
         }
         (count, size)
     }
@@ -859,10 +921,12 @@ impl DB {
         }
     }
 
-    pub fn compact_range_cf(&self,
+    pub fn compact_range_cf(
+        &self,
         cf: &CFHandle,
         start_key: Option<&[u8]>,
-                            end_key: Option<&[u8]>) {
+        end_key: Option<&[u8]>,
+    ) {
         unsafe {
             let (start, s_len) = start_key.map_or((ptr::null(), 0), |k| (k.as_ptr(), k.len()));
             let (end, e_len) = end_key.map_or((ptr::null(), 0), |k| (k.as_ptr(), k.len()));
@@ -870,47 +934,56 @@ impl DB {
         }
     }
 
-    pub fn compact_range_cf_opt(&self,
+    pub fn compact_range_cf_opt(
+        &self,
         cf: &CFHandle,
         compact_options: &CompactOptions,
         start_key: Option<&[u8]>,
-                                end_key: Option<&[u8]>) {
+        end_key: Option<&[u8]>,
+    ) {
         unsafe {
             let (start, s_len) = start_key.map_or((ptr::null(), 0), |k| (k.as_ptr(), k.len()));
             let (end, e_len) = end_key.map_or((ptr::null(), 0), |k| (k.as_ptr(), k.len()));
-            crocksdb_ffi::crocksdb_compact_range_cf_opt(self.inner,
+            crocksdb_ffi::crocksdb_compact_range_cf_opt(
+                self.inner,
                 cf.inner,
                 compact_options.inner,
                 start,
                 s_len,
                 end,
-                                                        e_len);
+                e_len,
+            );
         }
     }
 
     pub fn delete_file_in_range(&self, start_key: &[u8], end_key: &[u8]) -> Result<(), String> {
         unsafe {
-            ffi_try!(crocksdb_delete_file_in_range(self.inner,
+            ffi_try!(crocksdb_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));
+                end_key.len() as size_t
+            ));
             Ok(())
         }
     }
 
-    pub fn delete_file_in_range_cf(&self,
+    pub fn delete_file_in_range_cf(
+        &self,
         cf: &CFHandle,
         start_key: &[u8],
-                                   end_key: &[u8])
-                                   -> Result<(), String> {
+        end_key: &[u8],
+    ) -> Result<(), String> {
         unsafe {
-            ffi_try!(crocksdb_delete_file_in_range_cf(self.inner,
+            ffi_try!(crocksdb_delete_file_in_range_cf(
+                self.inner,
                 cf.inner,
                 start_key.as_ptr(),
                 start_key.len() as size_t,
                 end_key.as_ptr(),
-                                                      end_key.len() as size_t));
+                end_key.len() as size_t
+            ));
             Ok(())
         }
     }
@@ -939,11 +1012,11 @@ impl DB {
 
             let value = match cf {
                 None => crocksdb_ffi::crocksdb_property_value(self.inner, prop_name.as_ptr()),
-                Some(cf) => {
-                    crocksdb_ffi::crocksdb_property_value_cf(self.inner,
+                Some(cf) => crocksdb_ffi::crocksdb_property_value_cf(
+                    self.inner,
                     cf.inner,
-                                                             prop_name.as_ptr())
-                }
+                    prop_name.as_ptr(),
+                ),
             };
 
             if value.is_null() {
@@ -977,22 +1050,24 @@ impl DB {
         self.opts.get_statistics_ticker_count(ticker_type)
     }
 
-    pub fn get_and_reset_statistics_ticker_count(&self,
-                                                 ticker_type: DBStatisticsTickerType)
-                                                 -> u64 {
-        self.opts
-            .get_and_reset_statistics_ticker_count(ticker_type)
+    pub fn get_and_reset_statistics_ticker_count(
+        &self,
+        ticker_type: DBStatisticsTickerType,
+    ) -> u64 {
+        self.opts.get_and_reset_statistics_ticker_count(ticker_type)
     }
 
-    pub fn get_statistics_histogram_string(&self,
-                                           hist_type: DBStatisticsHistogramType)
-                                           -> Option<String> {
+    pub fn get_statistics_histogram_string(
+        &self,
+        hist_type: DBStatisticsHistogramType,
+    ) -> Option<String> {
         self.opts.get_statistics_histogram_string(hist_type)
     }
 
-    pub fn get_statistics_histogram(&self,
-                                    hist_type: DBStatisticsHistogramType)
-                                    -> Option<HistogramData> {
+    pub fn get_statistics_histogram(
+        &self,
+        hist_type: DBStatisticsHistogramType,
+    ) -> Option<HistogramData> {
         self.opts.get_statistics_histogram(hist_type)
     }
 
@@ -1011,34 +1086,40 @@ impl DB {
         }
     }
 
-    pub fn ingest_external_file(&self,
+    pub fn ingest_external_file(
+        &self,
         opt: &IngestExternalFileOptions,
-                                files: &[&str])
-                                -> Result<(), String> {
+        files: &[&str],
+    ) -> Result<(), String> {
         let c_files = build_cstring_list(files);
         let c_files_ptrs: Vec<*const _> = c_files.iter().map(|s| s.as_ptr()).collect();
         unsafe {
-            ffi_try!(crocksdb_ingest_external_file(self.inner,
+            ffi_try!(crocksdb_ingest_external_file(
+                self.inner,
                 c_files_ptrs.as_ptr(),
                 c_files.len(),
-                                                   opt.inner));
+                opt.inner
+            ));
         }
         Ok(())
     }
 
-    pub fn ingest_external_file_cf(&self,
+    pub fn ingest_external_file_cf(
+        &self,
         cf: &CFHandle,
         opt: &IngestExternalFileOptions,
-                                   files: &[&str])
-                                   -> Result<(), String> {
+        files: &[&str],
+    ) -> Result<(), String> {
         let c_files = build_cstring_list(files);
         let c_files_ptrs: Vec<*const _> = c_files.iter().map(|s| s.as_ptr()).collect();
         unsafe {
-            ffi_try!(crocksdb_ingest_external_file_cf(self.inner,
+            ffi_try!(crocksdb_ingest_external_file_cf(
+                self.inner,
                 cf.inner,
                 c_files_ptrs.as_ptr(),
                 c_files_ptrs.len(),
-                                                      opt.inner));
+                opt.inner
+            ));
         }
         Ok(())
     }
@@ -1046,37 +1127,47 @@ impl DB {
     pub fn backup_at(&self, path: &str) -> Result<BackupEngine, String> {
         let backup_engine = BackupEngine::open(DBOptions::new(), path).unwrap();
         unsafe {
-            ffi_try!(crocksdb_backup_engine_create_new_backup(backup_engine.inner, self.inner))
+            ffi_try!(crocksdb_backup_engine_create_new_backup(
+                backup_engine.inner,
+                self.inner
+            ))
         }
         Ok(backup_engine)
     }
 
-    pub fn restore_from(backup_engine: &BackupEngine,
+    pub fn restore_from(
+        backup_engine: &BackupEngine,
         restore_db_path: &str,
         restore_wal_path: &str,
-                        ropts: &RestoreOptions)
-                        -> Result<DB, String> {
+        ropts: &RestoreOptions,
+    ) -> Result<DB, String> {
         let c_db_path = match CString::new(restore_db_path.as_bytes()) {
             Ok(c) => c,
             Err(_) => {
-                return Err("Failed to convert restore_db_path to CString when restoring rocksdb"
-                    .to_owned())
+                return Err(
+                    "Failed to convert restore_db_path to CString when restoring rocksdb"
+                        .to_owned(),
+                )
             }
         };
 
         let c_wal_path = match CString::new(restore_wal_path.as_bytes()) {
             Ok(c) => c,
             Err(_) => {
-                return Err("Failed to convert restore_wal_path to CString when restoring rocksdb"
-                    .to_owned())
+                return Err(
+                    "Failed to convert restore_wal_path to CString when restoring rocksdb"
+                        .to_owned(),
+                )
             }
         };
 
         unsafe {
-            ffi_try!(crocksdb_backup_engine_restore_db_from_latest_backup(backup_engine.inner,
+            ffi_try!(crocksdb_backup_engine_restore_db_from_latest_backup(
+                backup_engine.inner,
                 c_db_path.as_ptr(),
                 c_wal_path.as_ptr(),
-                                                                          ropts.inner))
+                ropts.inner
+            ))
         };
 
         DB::open_default(restore_db_path)
@@ -1097,45 +1188,55 @@ impl DB {
         }
     }
 
-    pub fn get_properties_of_all_tables_cf(&self,
-                                           cf: &CFHandle)
-                                           -> Result<TablePropertiesCollection, String> {
+    pub fn get_properties_of_all_tables_cf(
+        &self,
+        cf: &CFHandle,
+    ) -> Result<TablePropertiesCollection, String> {
         unsafe {
-            let props = ffi_try!(crocksdb_get_properties_of_all_tables_cf(self.inner, cf.inner));
+            let props = ffi_try!(crocksdb_get_properties_of_all_tables_cf(
+                self.inner,
+                cf.inner
+            ));
             Ok(TablePropertiesCollection::from_raw(props))
         }
     }
 
-    pub fn get_properties_of_tables_in_range(&self,
+    pub fn get_properties_of_tables_in_range(
+        &self,
         cf: &CFHandle,
-                                             ranges: &[Range])
-                                             -> Result<TablePropertiesCollection, String> {
+        ranges: &[Range],
+    ) -> Result<TablePropertiesCollection, String> {
         let start_keys: Vec<*const u8> = ranges.iter().map(|x| x.start_key.as_ptr()).collect();
         let start_keys_lens: Vec<_> = ranges.iter().map(|x| x.start_key.len()).collect();
         let limit_keys: Vec<*const u8> = ranges.iter().map(|x| x.end_key.as_ptr()).collect();
         let limit_keys_lens: Vec<_> = ranges.iter().map(|x| x.end_key.len()).collect();
         unsafe {
-            let props = ffi_try!(crocksdb_get_properties_of_tables_in_range(self.inner,
+            let props = ffi_try!(crocksdb_get_properties_of_tables_in_range(
+                self.inner,
                 cf.inner,
                 ranges.len() as i32,
                 start_keys.as_ptr(),
                 start_keys_lens.as_ptr(),
                 limit_keys.as_ptr(),
-                                                                limit_keys_lens.as_ptr()));
+                limit_keys_lens.as_ptr()
+            ));
             Ok(TablePropertiesCollection::from_raw(props))
         }
     }
 
-    pub fn get_all_key_versions(&self,
+    pub fn get_all_key_versions(
+        &self,
         start_key: &[u8],
-                                end_key: &[u8])
-                                -> Result<Vec<KeyVersion>, String> {
+        end_key: &[u8],
+    ) -> Result<Vec<KeyVersion>, String> {
         unsafe {
-            let kvs = ffi_try!(crocksdb_get_all_key_versions(self.inner,
+            let kvs = ffi_try!(crocksdb_get_all_key_versions(
+                self.inner,
                 start_key.as_ptr(),
                 start_key.len() as size_t,
                 end_key.as_ptr(),
-                                                             end_key.len() as size_t));
+                end_key.len() as size_t
+            ));
             let size = crocksdb_ffi::crocksdb_keyversions_count(kvs) as usize;
             let mut key_versions = Vec::with_capacity(size);
             for i in 0..size {
@@ -1194,18 +1295,21 @@ impl Writable for DB {
         self.delete_range_cf(handle, begin_key, end_key)
     }
 
-    fn delete_range_cf(&self,
+    fn delete_range_cf(
+        &self,
         cf: &CFHandle,
         begin_key: &[u8],
-                       end_key: &[u8])
-                       -> Result<(), String> {
+        end_key: &[u8],
+    ) -> Result<(), String> {
         self.delete_range_cf_opt(cf, begin_key, end_key, &WriteOptions::new())
     }
 }
 
 impl Default for WriteBatch {
     fn default() -> WriteBatch {
-        WriteBatch { inner: unsafe { crocksdb_ffi::crocksdb_writebatch_create() } }
+        WriteBatch {
+            inner: unsafe { crocksdb_ffi::crocksdb_writebatch_create() },
+        }
     }
 }
 
@@ -1215,7 +1319,9 @@ impl WriteBatch {
     }
 
     pub fn with_capacity(cap: usize) -> WriteBatch {
-        WriteBatch { inner: unsafe { crocksdb_ffi::crocksdb_writebatch_create_with_capacity(cap) } }
+        WriteBatch {
+            inner: unsafe { crocksdb_ffi::crocksdb_writebatch_create_with_capacity(cap) },
+        }
     }
 
     pub fn count(&self) -> usize {
@@ -1272,46 +1378,54 @@ impl Drop for DB {
 impl Writable for WriteBatch {
     fn put(&self, key: &[u8], value: &[u8]) -> Result<(), String> {
         unsafe {
-            crocksdb_ffi::crocksdb_writebatch_put(self.inner,
+            crocksdb_ffi::crocksdb_writebatch_put(
+                self.inner,
                 key.as_ptr(),
                 key.len() as size_t,
                 value.as_ptr(),
-                                                  value.len() as size_t);
+                value.len() as size_t,
+            );
             Ok(())
         }
     }
 
     fn put_cf(&self, cf: &CFHandle, key: &[u8], value: &[u8]) -> Result<(), String> {
         unsafe {
-            crocksdb_ffi::crocksdb_writebatch_put_cf(self.inner,
+            crocksdb_ffi::crocksdb_writebatch_put_cf(
+                self.inner,
                 cf.inner,
                 key.as_ptr(),
                 key.len() as size_t,
                 value.as_ptr(),
-                                                     value.len() as size_t);
+                value.len() as size_t,
+            );
             Ok(())
         }
     }
 
     fn merge(&self, key: &[u8], value: &[u8]) -> Result<(), String> {
         unsafe {
-            crocksdb_ffi::crocksdb_writebatch_merge(self.inner,
+            crocksdb_ffi::crocksdb_writebatch_merge(
+                self.inner,
                 key.as_ptr(),
                 key.len() as size_t,
                 value.as_ptr(),
-                                                    value.len() as size_t);
+                value.len() as size_t,
+            );
             Ok(())
         }
     }
 
     fn merge_cf(&self, cf: &CFHandle, key: &[u8], value: &[u8]) -> Result<(), String> {
         unsafe {
-            crocksdb_ffi::crocksdb_writebatch_merge_cf(self.inner,
+            crocksdb_ffi::crocksdb_writebatch_merge_cf(
+                self.inner,
                 cf.inner,
                 key.as_ptr(),
                 key.len() as size_t,
                 value.as_ptr(),
-                                                       value.len() as size_t);
+                value.len() as size_t,
+            );
             Ok(())
         }
     }
@@ -1325,56 +1439,67 @@ impl Writable for WriteBatch {
 
     fn delete_cf(&self, cf: &CFHandle, key: &[u8]) -> Result<(), String> {
         unsafe {
-            crocksdb_ffi::crocksdb_writebatch_delete_cf(self.inner,
+            crocksdb_ffi::crocksdb_writebatch_delete_cf(
+                self.inner,
                 cf.inner,
                 key.as_ptr(),
-                                                        key.len() as size_t);
+                key.len() as size_t,
+            );
             Ok(())
         }
     }
 
     fn single_delete(&self, key: &[u8]) -> Result<(), String> {
         unsafe {
-            crocksdb_ffi::crocksdb_writebatch_single_delete(self.inner,
+            crocksdb_ffi::crocksdb_writebatch_single_delete(
+                self.inner,
                 key.as_ptr(),
-                                                            key.len() as size_t);
+                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,
+            crocksdb_ffi::crocksdb_writebatch_single_delete_cf(
+                self.inner,
                 cf.inner,
                 key.as_ptr(),
-                                                               key.len() as size_t);
+                key.len() as size_t,
+            );
             Ok(())
         }
     }
 
     fn delete_range(&self, begin_key: &[u8], end_key: &[u8]) -> Result<(), String> {
         unsafe {
-            crocksdb_ffi::crocksdb_writebatch_delete_range(self.inner,
+            crocksdb_ffi::crocksdb_writebatch_delete_range(
+                self.inner,
                 begin_key.as_ptr(),
                 begin_key.len(),
                 end_key.as_ptr(),
-                                                           end_key.len());
+                end_key.len(),
+            );
             Ok(())
         }
     }
 
-    fn delete_range_cf(&self,
+    fn delete_range_cf(
+        &self,
         cf: &CFHandle,
         begin_key: &[u8],
-                       end_key: &[u8])
-                       -> Result<(), String> {
+        end_key: &[u8],
+    ) -> Result<(), String> {
         unsafe {
-            crocksdb_ffi::crocksdb_writebatch_delete_range_cf(self.inner,
+            crocksdb_ffi::crocksdb_writebatch_delete_range_cf(
+                self.inner,
                 cf.inner,
                 begin_key.as_ptr(),
                 begin_key.len(),
                 end_key.as_ptr(),
-                                                              end_key.len());
+                end_key.len(),
+            );
             Ok(())
         }
     }
@@ -1435,19 +1560,26 @@ impl BackupEngine {
         let cpath = match CString::new(path.as_bytes()) {
             Ok(c) => c,
             Err(_) => {
-                return Err("Failed to convert path to CString when opening rocksdb backup engine"
-                    .to_owned())
+                return Err(
+                    "Failed to convert path to CString when opening rocksdb backup engine"
+                        .to_owned(),
+                )
             }
         };
 
         if let Err(e) = fs::create_dir_all(path) {
-            return Err(format!("Failed to create rocksdb backup directory: {:?}", e));
+            return Err(format!(
+                "Failed to create rocksdb backup directory: {:?}",
+                e
+            ));
         }
 
         let backup_engine =
             unsafe { ffi_try!(crocksdb_backup_engine_open(opts.inner, cpath.as_ptr())) };
 
-        Ok(BackupEngine { inner: backup_engine })
+        Ok(BackupEngine {
+            inner: backup_engine,
+        })
     }
 }
 
@@ -1483,9 +1615,11 @@ impl SstFileWriter {
     pub fn new_cf(env_opt: EnvOptions, opt: ColumnFamilyOptions, cf: &CFHandle) -> SstFileWriter {
         unsafe {
             SstFileWriter {
-                inner: crocksdb_ffi::crocksdb_sstfilewriter_create_cf(env_opt.inner,
+                inner: crocksdb_ffi::crocksdb_sstfilewriter_create_cf(
+                    env_opt.inner,
                     opt.inner,
-                                                                      cf.inner),
+                    cf.inner,
+                ),
                 _env_opt: env_opt,
                 _opt: opt,
             }
@@ -1498,47 +1632,61 @@ impl SstFileWriter {
             Err(e) => return Err(format!("invalid path {}: {:?}", name, e)),
             Ok(p) => p,
         };
-        unsafe { Ok(ffi_try!(crocksdb_sstfilewriter_open(self.inner, path.as_ptr()))) }
+        unsafe {
+            Ok(ffi_try!(
+                crocksdb_sstfilewriter_open(self.inner, path.as_ptr())
+            ))
+        }
     }
 
     /// Add key, value to currently opened file
     /// REQUIRES: key is after any previously added key according to comparator.
     pub fn add(&mut self, key: &[u8], val: &[u8]) -> Result<(), String> {
         unsafe {
-            ffi_try!(crocksdb_sstfilewriter_add(self.inner,
+            ffi_try!(crocksdb_sstfilewriter_add(
+                self.inner,
                 key.as_ptr(),
                 key.len(),
                 val.as_ptr(),
-                                                val.len()));
+                val.len()
+            ));
             Ok(())
         }
     }
 
     pub fn put(&mut self, key: &[u8], val: &[u8]) -> Result<(), String> {
         unsafe {
-            ffi_try!(crocksdb_sstfilewriter_put(self.inner,
+            ffi_try!(crocksdb_sstfilewriter_put(
+                self.inner,
                 key.as_ptr(),
                 key.len(),
                 val.as_ptr(),
-                                                val.len()));
+                val.len()
+            ));
             Ok(())
         }
     }
 
     pub fn merge(&mut self, key: &[u8], val: &[u8]) -> Result<(), String> {
         unsafe {
-            ffi_try!(crocksdb_sstfilewriter_merge(self.inner,
+            ffi_try!(crocksdb_sstfilewriter_merge(
+                self.inner,
                 key.as_ptr(),
                 key.len(),
                 val.as_ptr(),
-                                                  val.len()));
+                val.len()
+            ));
             Ok(())
         }
     }
 
     pub fn delete(&mut self, key: &[u8]) -> Result<(), String> {
         unsafe {
-            ffi_try!(crocksdb_sstfilewriter_delete(self.inner, key.as_ptr(), key.len()));
+            ffi_try!(crocksdb_sstfilewriter_delete(
+                self.inner,
+                key.as_ptr(),
+                key.len()
+            ));
             Ok(())
         }
     }
@@ -1571,13 +1719,13 @@ pub fn supported_compression() -> Vec<DBCompressionType> {
 
 #[cfg(test)]
 mod test {
+    use super::*;
     use std::fs;
     use std::path::Path;
     use std::str;
     use std::string::String;
     use std::sync::*;
     use std::thread;
-    use super::*;
     use tempdir::TempDir;
 
     #[test]
@@ -1602,9 +1750,11 @@ mod test {
         // The DB will still be open when we try to destroy and the lock should fail
         match DB::destroy(&opts, path_str) {
             Err(ref s) => {
-                assert!(s.contains("IO error: ") && s.contains("lock"),
+                assert!(
+                    s.contains("IO error: ") && s.contains("lock"),
                     "expect lock fail, but got {}",
-                        s);
+                    s
+                );
             }
             Ok(_) => panic!("should fail"),
         }
@@ -1690,9 +1840,11 @@ mod test {
         let mut iter = db.iter();
         iter.seek(SeekKey::Start);
         for (k, v) in &mut iter {
-            println!("Hello {}: {}",
+            println!(
+                "Hello {}: {}",
                 str::from_utf8(&*k).unwrap(),
-                     str::from_utf8(&*v).unwrap());
+                str::from_utf8(&*v).unwrap()
+            );
         }
     }
 
@@ -1701,18 +1853,21 @@ mod test {
         let path = TempDir::new("_rust_rocksdb_iteratortest").expect("");
         let db = DB::open_default(path.path().to_str().unwrap()).unwrap();
         for i in 1..8000 {
-            db.put(format!("{:04}", i).as_bytes(),
-                     format!("{:04}", i).as_bytes())
-                .expect("");
+            db.put(
+                format!("{:04}", i).as_bytes(),
+                format!("{:04}", i).as_bytes(),
+            ).expect("");
         }
         db.flush(true).expect("");
         assert!(db.get(b"0001").expect("").is_some());
         db.flush(true).expect("");
-        let sizes = db.get_approximate_sizes(&[Range::new(b"0000", b"2000"),
+        let sizes = db.get_approximate_sizes(&[
+            Range::new(b"0000", b"2000"),
             Range::new(b"2000", b"4000"),
             Range::new(b"4000", b"6000"),
             Range::new(b"6000", b"8000"),
-                                               Range::new(b"8000", b"9999")]);
+            Range::new(b"8000", b"9999"),
+        ]);
         assert_eq!(sizes.len(), 5);
         for s in &sizes[0..4] {
             assert!(*s > 0);
@@ -1756,8 +1911,8 @@ mod test {
             }
         }
         let opts_list_cfs = DBOptions::new();
-        let mut cfs_vec = DB::list_column_families(&opts_list_cfs, path.path().to_str().unwrap())
-            .unwrap();
+        let mut cfs_vec =
+            DB::list_column_families(&opts_list_cfs, path.path().to_str().unwrap()).unwrap();
         cfs_vec.sort();
         cfs.sort();
         assert_eq!(cfs_vec, cfs);
@@ -1775,8 +1930,7 @@ mod test {
 
         // Make a backup.
         let backup_dir = TempDir::new("_rust_rocksdb_backuptest_backup").unwrap();
-        let backup_engine = db.backup_at(backup_dir.path().to_str().unwrap())
-            .unwrap();
+        let backup_engine = db.backup_at(backup_dir.path().to_str().unwrap()).unwrap();
 
         // Restore it.
         let ropt1 = RestoreOptions::new();
@@ -1785,11 +1939,12 @@ mod test {
         let ropts = [ropt1, ropt2];
         for ropt in &ropts {
             let restore_dir = TempDir::new("_rust_rocksdb_backuptest_restore").unwrap();
-            let restored_db = DB::restore_from(&backup_engine,
+            let restored_db = DB::restore_from(
+                &backup_engine,
                 restore_dir.path().to_str().unwrap(),
                 restore_dir.path().to_str().unwrap(),
-                                               &ropt)
-                .unwrap();
+                &ropt,
+            ).unwrap();
 
             let r = restored_db.get(key);
             assert!(r.unwrap().unwrap().to_utf8().unwrap() == str::from_utf8(value).unwrap());
@@ -1864,7 +2019,8 @@ mod test {
         let db = Arc::new(db);
         let db1 = db.clone();
         let builder = thread::Builder::new().name(String::from("put-thread"));
-        let h = builder.spawn(move || {
+        let h = builder
+            .spawn(move || {
                 db1.put(b"k1", b"v1").unwrap();
                 db1.put(b"k2", b"v2").unwrap();
                 db1.flush(true).unwrap();
@@ -1873,12 +2029,15 @@ mod test {
             .unwrap();
         // Wait until all currently running background processes finish.
         db.pause_bg_work();
-        assert_eq!(db.get_property_int("rocksdb.num-running-compactions")
-                       .unwrap(),
-                   0);
-        assert_eq!(db.get_property_int("rocksdb.num-running-flushes")
+        assert_eq!(
+            db.get_property_int("rocksdb.num-running-compactions")
                 .unwrap(),
-                   0);
+            0
+        );
+        assert_eq!(
+            db.get_property_int("rocksdb.num-running-flushes").unwrap(),
+            0
+        );
         db.continue_bg_work();
         h.join().unwrap();
     }
@@ -1942,7 +2101,8 @@ mod test {
         }
         db.flush_cf(cf_handle, true).unwrap();
 
-        let total_sst_files_size = db.get_property_int_cf(cf_handle, "rocksdb.total-sst-files-size")
+        let total_sst_files_size =
+            db.get_property_int_cf(cf_handle, "rocksdb.total-sst-files-size")
                 .unwrap();
         assert!(total_sst_files_size > 0);
     }
@@ -1971,10 +2131,12 @@ mod test {
         let path = TempDir::new("_rust_rocksdb_get_all_key_version_test").expect("");
         let db = DB::open(opts, path.path().to_str().unwrap()).unwrap();
 
-        let samples = vec![(b"key1".to_vec(), b"value1".to_vec()),
+        let samples = vec![
+            (b"key1".to_vec(), b"value1".to_vec()),
             (b"key2".to_vec(), b"value2".to_vec()),
             (b"key3".to_vec(), b"value3".to_vec()),
-                           (b"key4".to_vec(), b"value4".to_vec())];
+            (b"key4".to_vec(), b"value4".to_vec()),
+        ];
 
         // Put 4 keys.
         for &(ref k, ref v) in &samples {
@@ -1995,10 +2157,12 @@ mod test {
         let path = TempDir::new("_rust_rocksdb_get_approximate_memtable_stats").expect("");
         let db = DB::open(opts, path.path().to_str().unwrap()).unwrap();
 
-        let samples = [(b"key1", b"value1"),
+        let samples = [
+            (b"key1", b"value1"),
             (b"key2", b"value2"),
             (b"key3", b"value3"),
-                       (b"key4", b"value4")];
+            (b"key4", b"value4"),
+        ];
 
         for &(k, v) in &samples {
             db.put(k, v).unwrap();

src/rocksdb_options.rs

@@ -13,23 +13,23 @@
 // limitations under the License.
 //
 
-use compaction_filter::{CompactionFilter, new_compaction_filter, CompactionFilterHandle};
-use comparator::{self, ComparatorCallback, compare_callback};
-
-use crocksdb_ffi::{self, Options, DBWriteOptions, DBBlockBasedTableOptions, DBReadOptions,
-                   DBRestoreOptions, DBCompressionType, DBRecoveryMode, DBSnapshot, DBInstance,
-                   DBFlushOptions, DBStatisticsTickerType, DBStatisticsHistogramType,
-                   DBRateLimiter, DBInfoLogLevel, DBCompactOptions};
-use event_listener::{EventListener, new_event_listener};
-use libc::{self, c_int, size_t, c_void};
-use merge_operator::{self, MergeOperatorCallback, full_merge_callback, partial_merge_callback};
+use compaction_filter::{new_compaction_filter, CompactionFilter, CompactionFilterHandle};
+use comparator::{self, compare_callback, ComparatorCallback};
+
+use crocksdb_ffi::{self, DBBlockBasedTableOptions, DBCompactOptions, DBCompressionType,
+                   DBFlushOptions, DBInfoLogLevel, DBInstance, DBRateLimiter, DBReadOptions,
+                   DBRecoveryMode, DBRestoreOptions, DBSnapshot, DBStatisticsHistogramType,
+                   DBStatisticsTickerType, DBWriteOptions, Options};
+use event_listener::{new_event_listener, EventListener};
+use libc::{self, c_int, c_void, size_t};
+use merge_operator::{self, full_merge_callback, partial_merge_callback, MergeOperatorCallback};
 use merge_operator::MergeFn;
-use slice_transform::{SliceTransform, new_slice_transform};
+use slice_transform::{new_slice_transform, SliceTransform};
 use std::ffi::{CStr, CString};
 use std::mem;
 use std::path::Path;
-use table_properties_collector_factory::{TablePropertiesCollectorFactory,
-                                         new_table_properties_collector_factory};
+use table_properties_collector_factory::{new_table_properties_collector_factory,
+                                         TablePropertiesCollectorFactory};
 
 #[derive(Default, Debug)]
 pub struct HistogramData {
@@ -56,8 +56,10 @@ impl Default for BlockBasedOptions {
     fn default() -> BlockBasedOptions {
         unsafe {
             let block_opts = crocksdb_ffi::crocksdb_block_based_options_create();
-            assert!(!block_opts.is_null(),
-                    "Could not create rocksdb block based options");
+            assert!(
+                !block_opts.is_null(),
+                "Could not create rocksdb block based options"
+            );
             BlockBasedOptions { inner: block_opts }
         }
     }
@@ -96,8 +98,10 @@ impl BlockBasedOptions {
 
     pub fn set_cache_index_and_filter_blocks(&mut self, v: bool) {
         unsafe {
-            crocksdb_ffi::crocksdb_block_based_options_set_cache_index_and_filter_blocks(self.inner,
-                                                                                       v as u8);
+            crocksdb_ffi::crocksdb_block_based_options_set_cache_index_and_filter_blocks(
+                self.inner,
+                v as u8,
+            );
         }
     }
 
@@ -123,9 +127,11 @@ pub struct RateLimiter {
 impl RateLimiter {
     pub fn new(rate_bytes_per_sec: i64, refill_period_us: i64, fairness: i32) -> RateLimiter {
         let limiter = unsafe {
-            crocksdb_ffi::crocksdb_ratelimiter_create(rate_bytes_per_sec,
+            crocksdb_ffi::crocksdb_ratelimiter_create(
+                rate_bytes_per_sec,
                 refill_period_us,
-                                                      fairness)
+                fairness,
+            )
         };
         RateLimiter { inner: limiter }
     }
@@ -151,7 +157,9 @@ pub struct UnsafeSnap {
 
 impl UnsafeSnap {
     pub unsafe fn new(db: *mut DBInstance) -> UnsafeSnap {
-        UnsafeSnap { inner: crocksdb_ffi::crocksdb_create_snapshot(db) }
+        UnsafeSnap {
+            inner: crocksdb_ffi::crocksdb_create_snapshot(db),
+        }
     }
 
     pub unsafe fn get_inner(&self) -> *const DBSnapshot {
@@ -212,9 +220,11 @@ impl ReadOptions {
     pub fn set_iterate_upper_bound(&mut self, key: &[u8]) {
         self.upper_bound = Vec::from(key);
         unsafe {
-            crocksdb_ffi::crocksdb_readoptions_set_iterate_upper_bound(self.inner,
+            crocksdb_ffi::crocksdb_readoptions_set_iterate_upper_bound(
+                self.inner,
                 self.upper_bound.as_ptr(),
-                                                                       self.upper_bound.len());
+                self.upper_bound.len(),
+            );
         }
     }
 
@@ -268,8 +278,10 @@ impl ReadOptions {
 
     pub fn set_background_purge_on_iterator_cleanup(&mut self, v: bool) {
         unsafe {
-            crocksdb_ffi::crocksdb_readoptions_set_background_purge_on_iterator_cleanup(self.inner,
-                                                                                        v);
+            crocksdb_ffi::crocksdb_readoptions_set_background_purge_on_iterator_cleanup(
+                self.inner,
+                v,
+            );
         }
     }
 
@@ -299,8 +311,10 @@ impl Drop for WriteOptions {
 impl Default for WriteOptions {
     fn default() -> WriteOptions {
         let write_opts = unsafe { crocksdb_ffi::crocksdb_writeoptions_create() };
-        assert!(!write_opts.is_null(),
-                "Could not create rocksdb write options");
+        assert!(
+            !write_opts.is_null(),
+            "Could not create rocksdb write options"
+        );
         WriteOptions { inner: write_opts }
     }
 }
@@ -351,7 +365,11 @@ pub struct CompactOptions {
 
 impl CompactOptions {
     pub fn new() -> CompactOptions {
-        unsafe { CompactOptions { inner: crocksdb_ffi::crocksdb_compactoptions_create() } }
+        unsafe {
+            CompactOptions {
+                inner: crocksdb_ffi::crocksdb_compactoptions_create(),
+            }
+        }
     }
 
     pub fn set_exclusive_manual_compaction(&mut self, v: bool) {
@@ -471,8 +489,10 @@ impl DBOptions {
 
     pub fn set_use_direct_io_for_flush_and_compaction(&mut self, v: bool) {
         unsafe {
-            crocksdb_ffi::crocksdb_options_set_use_direct_io_for_flush_and_compaction(self.inner,
-                                                                                      v);
+            crocksdb_ffi::crocksdb_options_set_use_direct_io_for_flush_and_compaction(
+                self.inner,
+                v,
+            );
         }
     }
 
@@ -524,27 +544,33 @@ impl DBOptions {
         }
     }
 
-    pub fn get_and_reset_statistics_ticker_count(&self,
-                                                 ticker_type: DBStatisticsTickerType)
-                                                 -> u64 {
+    pub fn get_and_reset_statistics_ticker_count(
+        &self,
+        ticker_type: DBStatisticsTickerType,
+    ) -> u64 {
         unsafe {
-            crocksdb_ffi::crocksdb_options_statistics_get_and_reset_ticker_count(self.inner,
-                                                                                 ticker_type)
+            crocksdb_ffi::crocksdb_options_statistics_get_and_reset_ticker_count(
+                self.inner,
+                ticker_type,
+            )
         }
     }
 
-    pub fn get_statistics_histogram(&self,
-                                    hist_type: DBStatisticsHistogramType)
-                                    -> Option<HistogramData> {
+    pub fn get_statistics_histogram(
+        &self,
+        hist_type: DBStatisticsHistogramType,
+    ) -> Option<HistogramData> {
         unsafe {
             let mut data = HistogramData::default();
-            let ret = crocksdb_ffi::crocksdb_options_statistics_get_histogram(self.inner,
+            let ret = crocksdb_ffi::crocksdb_options_statistics_get_histogram(
+                self.inner,
                 hist_type,
                 &mut data.median,
                 &mut data.percentile95,
                 &mut data.percentile99,
                 &mut data.average,
-                                                &mut data.standard_deviation);
+                &mut data.standard_deviation,
+            );
             if !ret {
                 return None;
             }
@@ -552,12 +578,15 @@ impl DBOptions {
         }
     }
 
-    pub fn get_statistics_histogram_string(&self,
-                                           hist_type: DBStatisticsHistogramType)
-                                           -> Option<String> {
+    pub fn get_statistics_histogram_string(
+        &self,
+        hist_type: DBStatisticsHistogramType,
+    ) -> Option<String> {
         unsafe {
-            let value = crocksdb_ffi::crocksdb_options_statistics_get_histogram_string(self.inner,
-                                                                                       hist_type);
+            let value = crocksdb_ffi::crocksdb_options_statistics_get_histogram_string(
+                self.inner,
+                hist_type,
+            );
 
             if value.is_null() {
                 return None;
@@ -643,15 +672,19 @@ impl DBOptions {
 
     pub fn set_compaction_readahead_size(&mut self, size: u64) {
         unsafe {
-            crocksdb_ffi::crocksdb_options_set_compaction_readahead_size(self.inner,
-                                                                         size as size_t);
+            crocksdb_ffi::crocksdb_options_set_compaction_readahead_size(
+                self.inner,
+                size as size_t,
+            );
         }
     }
 
     pub fn set_ratelimiter(&mut self, rate_bytes_per_sec: i64) {
-        let rate_limiter = RateLimiter::new(rate_bytes_per_sec,
+        let rate_limiter = RateLimiter::new(
+            rate_bytes_per_sec,
             DEFAULT_REFILL_PERIOD_US,
-                                            DEFAULT_FAIRNESS);
+            DEFAULT_FAIRNESS,
+        );
         unsafe {
             crocksdb_ffi::crocksdb_options_set_ratelimiter(self.inner, rate_limiter.inner);
         }
@@ -663,8 +696,9 @@ impl DBOptions {
         let cpath = match CString::new(path.as_bytes()) {
             Ok(c) => c,
             Err(_) => {
-                return Err("Failed to convert path to CString when creating rocksdb info log"
-                    .to_owned())
+                return Err(
+                    "Failed to convert path to CString when creating rocksdb info log".to_owned(),
+                )
             }
         };
 
@@ -704,11 +738,13 @@ impl DBOptions {
         }
 
         unsafe {
-            crocksdb_ffi::crocksdb_options_set_db_paths(self.inner,
+            crocksdb_ffi::crocksdb_options_set_db_paths(
+                self.inner,
                 cpaths.as_ptr(),
                 cpath_lens.as_ptr(),
                 sizes.as_ptr(),
-                                                        num_paths as c_int);
+                num_paths as c_int,
+            );
         }
     }
 }
@@ -730,8 +766,10 @@ impl Default for ColumnFamilyOptions {
     fn default() -> ColumnFamilyOptions {
         unsafe {
             let opts = crocksdb_ffi::crocksdb_options_create();
-            assert!(!opts.is_null(),
-                    "Could not create rocksdb column family options");
+            assert!(
+                !opts.is_null(),
+                "Could not create rocksdb column family options"
+            );
             ColumnFamilyOptions {
                 inner: opts,
                 filter: None,
@@ -760,8 +798,10 @@ impl ColumnFamilyOptions {
     }
 
     pub unsafe fn from_raw(inner: *mut Options) -> ColumnFamilyOptions {
-        assert!(!inner.is_null(),
-                "could not new rocksdb options with null inner");
+        assert!(
+            !inner.is_null(),
+            "could not new rocksdb options with null inner"
+        );
         ColumnFamilyOptions {
             inner: inner,
             filter: None,
@@ -770,8 +810,10 @@ impl ColumnFamilyOptions {
 
     pub fn optimize_level_style_compaction(&mut self, memtable_memory_budget: i32) {
         unsafe {
-            crocksdb_ffi::crocksdb_options_optimize_level_style_compaction(self.inner,
-                                                                           memtable_memory_budget);
+            crocksdb_ffi::crocksdb_options_optimize_level_style_compaction(
+                self.inner,
+                memtable_memory_budget,
+            );
         }
     }
 
@@ -787,31 +829,36 @@ impl ColumnFamilyOptions {
     /// rocksdb's documentation.
     ///
     /// See also `CompactionFilter`.
-    pub fn set_compaction_filter<S>(&mut self,
+    pub fn set_compaction_filter<S>(
+        &mut self,
         name: S,
         ignore_snapshots: bool,
-                                    filter: Box<CompactionFilter>)
-                                    -> Result<(), String>
-        where S: Into<Vec<u8>>
+        filter: Box<CompactionFilter>,
+    ) -> Result<(), String>
+    where
+        S: Into<Vec<u8>>,
     {
         unsafe {
             let c_name = match CString::new(name) {
                 Ok(s) => s,
                 Err(e) => return Err(format!("failed to convert to cstring: {:?}", e)),
             };
-            self.filter = Some(try!(new_compaction_filter(c_name, ignore_snapshots, filter)));
-            crocksdb_ffi::crocksdb_options_set_compaction_filter(self.inner,
-                                                                 self.filter
-                                                                     .as_ref()
-                                                                     .unwrap()
-                                                                     .inner);
+            self.filter = Some(try!(
+                new_compaction_filter(c_name, ignore_snapshots, filter)
+            ));
+            crocksdb_ffi::crocksdb_options_set_compaction_filter(
+                self.inner,
+                self.filter.as_ref().unwrap().inner,
+            );
             Ok(())
         }
     }
 
-    pub fn add_table_properties_collector_factory(&mut self,
+    pub fn add_table_properties_collector_factory(
+        &mut self,
         fname: &str,
-                                                  factory: Box<TablePropertiesCollectorFactory>) {
+        factory: Box<TablePropertiesCollectorFactory>,
+    ) {
         unsafe {
             let f = new_table_properties_collector_factory(fname, factory);
             crocksdb_ffi::crocksdb_options_add_table_properties_collector_factory(self.inner, f);
@@ -831,9 +878,11 @@ impl ColumnFamilyOptions {
 
     pub fn compression_per_level(&mut self, level_types: &[DBCompressionType]) {
         unsafe {
-            crocksdb_ffi::crocksdb_options_set_compression_per_level(self.inner,
+            crocksdb_ffi::crocksdb_options_set_compression_per_level(
+                self.inner,
                 level_types.as_ptr(),
-                                                                     level_types.len() as size_t)
+                level_types.len() as size_t,
+            )
         }
     }
 
@@ -860,13 +909,14 @@ impl ColumnFamilyOptions {
         });
 
         unsafe {
-            let mo =
-                crocksdb_ffi::crocksdb_mergeoperator_create(mem::transmute(cb),
+            let mo = crocksdb_ffi::crocksdb_mergeoperator_create(
+                mem::transmute(cb),
                 merge_operator::destructor_callback,
                 full_merge_callback,
                 partial_merge_callback,
                 None,
-                                                            merge_operator::name_callback);
+                merge_operator::name_callback,
+            );
             crocksdb_ffi::crocksdb_options_set_merge_operator(self.inner, mo);
         }
     }
@@ -878,10 +928,12 @@ impl ColumnFamilyOptions {
         });
 
         unsafe {
-            let cmp = crocksdb_ffi::crocksdb_comparator_create(mem::transmute(cb),
+            let cmp = crocksdb_ffi::crocksdb_comparator_create(
+                mem::transmute(cb),
                 comparator::destructor_callback,
                 compare_callback,
-                                                               comparator::name_callback);
+                comparator::name_callback,
+            );
             crocksdb_ffi::crocksdb_options_set_comparator(self.inner, cmp);
         }
     }
@@ -937,15 +989,19 @@ impl ColumnFamilyOptions {
 
     pub fn set_soft_pending_compaction_bytes_limit(&mut self, size: u64) {
         unsafe {
-            crocksdb_ffi::crocksdb_options_set_soft_pending_compaction_bytes_limit(self.inner,
-                                                                                   size);
+            crocksdb_ffi::crocksdb_options_set_soft_pending_compaction_bytes_limit(
+                self.inner,
+                size,
+            );
         }
     }
 
     pub fn set_hard_pending_compaction_bytes_limit(&mut self, size: u64) {
         unsafe {
-            crocksdb_ffi::crocksdb_options_set_hard_pending_compaction_bytes_limit(self.inner,
-                                                                                   size);
+            crocksdb_ffi::crocksdb_options_set_hard_pending_compaction_bytes_limit(
+                self.inner,
+                size,
+            );
         }
     }
 
@@ -957,8 +1013,10 @@ impl ColumnFamilyOptions {
 
     pub fn set_min_write_buffer_number_to_merge(&mut self, to_merge: c_int) {
         unsafe {
-            crocksdb_ffi::crocksdb_options_set_min_write_buffer_number_to_merge(self.inner,
-                                                                                to_merge);
+            crocksdb_ffi::crocksdb_options_set_min_write_buffer_number_to_merge(
+                self.inner,
+                to_merge,
+            );
         }
     }
 
@@ -1024,11 +1082,13 @@ impl ColumnFamilyOptions {
         }
     }
 
-    pub fn set_prefix_extractor<S>(&mut self,
+    pub fn set_prefix_extractor<S>(
+        &mut self,
         name: S,
-                                   transform: Box<SliceTransform>)
-                                   -> Result<(), String>
-        where S: Into<Vec<u8>>
+        transform: Box<SliceTransform>,
+    ) -> Result<(), String>
+    where
+        S: Into<Vec<u8>>,
     {
         unsafe {
             let c_name = match CString::new(name) {
@@ -1047,11 +1107,13 @@ impl ColumnFamilyOptions {
         }
     }
 
-    pub fn set_memtable_insert_hint_prefix_extractor<S>(&mut self,
+    pub fn set_memtable_insert_hint_prefix_extractor<S>(
+        &mut self,
         name: S,
-                                                        transform: Box<SliceTransform>)
-                                                        -> Result<(), String>
-        where S: Into<Vec<u8>>
+        transform: Box<SliceTransform>,
+    ) -> Result<(), String>
+    where
+        S: Into<Vec<u8>>,
     {
         unsafe {
             let c_name = match CString::new(name) {
@@ -1060,7 +1122,9 @@ impl ColumnFamilyOptions {
             };
             let transform = try!(new_slice_transform(c_name, transform));
             crocksdb_ffi::crocksdb_options_set_memtable_insert_with_hint_prefix_extractor(
-                self.inner, transform);
+                self.inner,
+                transform,
+            );
             Ok(())
         }
     }
@@ -1082,7 +1146,11 @@ pub struct FlushOptions {
 
 impl FlushOptions {
     pub fn new() -> FlushOptions {
-        unsafe { FlushOptions { inner: crocksdb_ffi::crocksdb_flushoptions_create() } }
+        unsafe {
+            FlushOptions {
+                inner: crocksdb_ffi::crocksdb_flushoptions_create(),
+            }
+        }
     }
 
     pub fn set_wait(&mut self, wait: bool) {
@@ -1119,7 +1187,9 @@ impl IngestExternalFileOptions {
     pub fn snapshot_consistent(&mut self, whether_consistent: bool) {
         unsafe {
             crocksdb_ffi::crocksdb_ingestexternalfileoptions_set_snapshot_consistency(
-                self.inner, whether_consistent);
+                self.inner,
+                whether_consistent,
+            );
         }
     }
 
@@ -1127,8 +1197,10 @@ impl IngestExternalFileOptions {
     /// overlaps with existing keys or tombstones in the DB.
     pub fn allow_global_seqno(&mut self, whether_allow: bool) {
         unsafe {
-            crocksdb_ffi::crocksdb_ingestexternalfileoptions_set_allow_global_seqno(self.inner,
-                                                                                    whether_allow);
+            crocksdb_ffi::crocksdb_ingestexternalfileoptions_set_allow_global_seqno(
+                self.inner,
+                whether_allow,
+            );
         }
     }
 
@@ -1136,16 +1208,20 @@ impl IngestExternalFileOptions {
     /// (memtable flush required), DB::ingest_external_file will fail.
     pub fn allow_blocking_flush(&mut self, whether_allow: bool) {
         unsafe {
-            crocksdb_ffi::crocksdb_ingestexternalfileoptions_set_allow_blocking_flush(self.inner,
-                                                                                     whether_allow);
+            crocksdb_ffi::crocksdb_ingestexternalfileoptions_set_allow_blocking_flush(
+                self.inner,
+                whether_allow,
+            );
         }
     }
 
     /// Set to true to move the files instead of copying them.
     pub fn move_files(&mut self, whether_move: bool) {
         unsafe {
-            crocksdb_ffi::crocksdb_ingestexternalfileoptions_set_move_files(self.inner,
-                                                                            whether_move);
+            crocksdb_ffi::crocksdb_ingestexternalfileoptions_set_move_files(
+                self.inner,
+                whether_move,
+            );
         }
     }
 }
@@ -1165,7 +1241,11 @@ pub struct EnvOptions {
 
 impl EnvOptions {
     pub fn new() -> EnvOptions {
-        unsafe { EnvOptions { inner: crocksdb_ffi::crocksdb_envoptions_create() } }
+        unsafe {
+            EnvOptions {
+                inner: crocksdb_ffi::crocksdb_envoptions_create(),
+            }
+        }
     }
 }
 
@@ -1183,13 +1263,19 @@ pub struct RestoreOptions {
 
 impl RestoreOptions {
     pub fn new() -> RestoreOptions {
-        unsafe { RestoreOptions { inner: crocksdb_ffi::crocksdb_restore_options_create() } }
+        unsafe {
+            RestoreOptions {
+                inner: crocksdb_ffi::crocksdb_restore_options_create(),
+            }
+        }
     }
 
     pub fn set_keep_log_files(&mut self, flag: bool) {
         unsafe {
-            crocksdb_ffi::crocksdb_restore_options_set_keep_log_files(self.inner,
-                                                                      if flag { 1 } else { 0 })
+            crocksdb_ffi::crocksdb_restore_options_set_keep_log_files(
+                self.inner,
+                if flag { 1 } else { 0 },
+            )
         }
     }
 }

src/slice_transform.rs

@@ -13,7 +13,7 @@
 
 
 use crocksdb_ffi::{self, DBSliceTransform};
-use libc::{c_void, c_char, size_t};
+use libc::{c_char, c_void, size_t};
 use std::ffi::CString;
 use std::slice;
 
@@ -54,11 +54,12 @@ extern "C" fn destructor(transform: *mut c_void) {
     }
 }
 
-extern "C" fn transform(transform: *mut c_void,
+extern "C" fn transform(
+    transform: *mut c_void,
     key: *const u8,
     key_len: size_t,
-                        dest_len: *mut size_t)
-                        -> *const u8 {
+    dest_len: *mut size_t,
+) -> *const u8 {
     unsafe {
         let transform = &mut *(transform as *mut SliceTransformProxy);
         let key = slice::from_raw_parts(key, key_len);
@@ -85,18 +86,21 @@ extern "C" fn in_range(transform: *mut c_void, key: *const u8, key_len: size_t)
 }
 
 
-pub unsafe fn new_slice_transform(c_name: CString,
-                                  f: Box<SliceTransform>)
-                                  -> Result<*mut DBSliceTransform, String> {
+pub unsafe fn new_slice_transform(
+    c_name: CString,
+    f: Box<SliceTransform>,
+) -> Result<*mut DBSliceTransform, String> {
     let proxy = Box::into_raw(Box::new(SliceTransformProxy {
         name: c_name,
         transform: f,
     }));
-    let transform = crocksdb_ffi::crocksdb_slicetransform_create(proxy as *mut c_void,
+    let transform = crocksdb_ffi::crocksdb_slicetransform_create(
+        proxy as *mut c_void,
         destructor,
         transform,
         in_domain,
         in_range,
-                                                                 name);
+        name,
+    );
     Ok(transform)
 }

src/table_properties.rs

@@ -12,20 +12,21 @@
 // limitations under the License.
 
 
-use crocksdb_ffi::{self, DBTableProperties, DBTableProperty, DBUserCollectedPropertiesIterator,
-                   DBTablePropertiesCollection, DBTablePropertiesCollectionIterator,
-                   DBUserCollectedProperties};
+use crocksdb_ffi::{self, DBTableProperties, DBTablePropertiesCollection,
+                   DBTablePropertiesCollectionIterator, DBTableProperty,
+                   DBUserCollectedProperties, DBUserCollectedPropertiesIterator};
 use libc::size_t;
-use std::{slice, str, mem};
+use std::{mem, slice, str};
 use std::marker::PhantomData;
-use std::ops::{Index, Deref};
+use std::ops::{Deref, Index};
 
 
 pub struct TablePropertiesCollectionView(DBTablePropertiesCollection);
 
 impl TablePropertiesCollectionView {
-    pub unsafe fn from_ptr<'a>(collection: *const DBTablePropertiesCollection)
-                               -> &'a TablePropertiesCollectionView {
+    pub unsafe fn from_ptr<'a>(
+        collection: *const DBTablePropertiesCollection,
+    ) -> &'a TablePropertiesCollectionView {
         let c = &*collection;
         mem::transmute(c)
     }
@@ -86,8 +87,8 @@ impl<'a> Iterator for TablePropertiesCollectionIter<'a> {
             }
 
             let mut klen: size_t = 0;
-            let k = crocksdb_ffi::crocksdb_table_properties_collection_iter_key(self.inner,
-                                                                                &mut klen);
+            let k =
+                crocksdb_ffi::crocksdb_table_properties_collection_iter_key(self.inner, &mut klen);
             let bytes = slice::from_raw_parts(k, klen);
             let key = str::from_utf8(bytes).unwrap();
             let props = crocksdb_ffi::crocksdb_table_properties_collection_iter_value(self.inner);
@@ -237,10 +238,12 @@ impl UserCollectedProperties {
         let bytes = index.as_ref();
         let mut size = 0;
         unsafe {
-            let ptr = crocksdb_ffi::crocksdb_user_collected_properties_get(&self.inner,
+            let ptr = crocksdb_ffi::crocksdb_user_collected_properties_get(
+                &self.inner,
                 bytes.as_ptr(),
                 bytes.len(),
-                                                                           &mut size);
+                &mut size,
+            );
             if ptr.is_null() {
                 return None;
             }
@@ -262,7 +265,8 @@ impl<Q: AsRef<[u8]>> Index<Q> for UserCollectedProperties {
 
     fn index(&self, index: Q) -> &[u8] {
         let key = index.as_ref();
-        self.get(key).unwrap_or_else(|| panic!("no entry found for key {:?}", key))
+        self.get(key)
+            .unwrap_or_else(|| panic!("no entry found for key {:?}", key))
     }
 }
 
@@ -308,13 +312,13 @@ impl<'a> Iterator for UserCollectedPropertiesIter<'a> {
                 return None;
             }
             let mut klen: size_t = 0;
-            let k = crocksdb_ffi::crocksdb_user_collected_properties_iter_key(self.inner,
-                                                                              &mut klen);
+            let k =
+                crocksdb_ffi::crocksdb_user_collected_properties_iter_key(self.inner, &mut klen);
             let key = slice::from_raw_parts(k, klen);
 
             let mut vlen: size_t = 0;
-            let v = crocksdb_ffi::crocksdb_user_collected_properties_iter_value(self.inner,
-                                                                                &mut vlen);
+            let v =
+                crocksdb_ffi::crocksdb_user_collected_properties_iter_value(self.inner, &mut vlen);
             let val = slice::from_raw_parts(v, vlen);
 
             crocksdb_ffi::crocksdb_user_collected_properties_iter_next(self.inner);

src/table_properties_collector.rs

@@ -11,8 +11,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use crocksdb_ffi::{self, DBEntryType, DBUserCollectedProperties, DBTablePropertiesCollector};
-use libc::{c_void, c_char, c_int, uint8_t, uint64_t, size_t};
+use crocksdb_ffi::{self, DBEntryType, DBTablePropertiesCollector, DBUserCollectedProperties};
+use libc::{c_char, c_int, c_void, size_t, uint64_t, uint8_t};
 use std::collections::HashMap;
 use std::ffi::CString;
 use std::mem;
@@ -26,12 +26,7 @@ use std::slice;
 /// TablePropertiesCollector object per table and then call it sequentially
 pub trait TablePropertiesCollector {
     /// Will be called when a new key/value pair is inserted into the table.
-    fn add(&mut self,
-           key: &[u8],
-           value: &[u8],
-           entry_type: DBEntryType,
-           seq: u64,
-           file_size: u64);
+    fn add(&mut self, key: &[u8], value: &[u8], entry_type: DBEntryType, seq: u64, file_size: u64);
 
     /// Will be called when a table has already been built and is ready for
     /// writing the properties block.
@@ -65,19 +60,23 @@ extern "C" fn destruct(handle: *mut c_void) {
     }
 }
 
-pub extern "C" fn add(handle: *mut c_void,
+pub extern "C" fn add(
+    handle: *mut c_void,
     key: *const uint8_t,
     key_len: size_t,
     value: *const uint8_t,
     value_len: size_t,
     entry_type: c_int,
     seq: uint64_t,
-                      file_size: uint64_t) {
+    file_size: uint64_t,
+) {
     unsafe {
         let handle = &mut *(handle as *mut TablePropertiesCollectorHandle);
         let key = slice::from_raw_parts(key, key_len);
         let value = slice::from_raw_parts(value, value_len);
-        handle.rep.add(key, value, mem::transmute(entry_type), seq, file_size);
+        handle
+            .rep
+            .add(key, value, mem::transmute(entry_type), seq, file_size);
     }
 }
 
@@ -85,18 +84,21 @@ pub extern "C" fn finish(handle: *mut c_void, props: *mut DBUserCollectedPropert
     unsafe {
         let handle = &mut *(handle as *mut TablePropertiesCollectorHandle);
         for (key, value) in handle.rep.finish() {
-            crocksdb_ffi::crocksdb_user_collected_properties_add(props,
+            crocksdb_ffi::crocksdb_user_collected_properties_add(
+                props,
                 key.as_ptr(),
                 key.len(),
                 value.as_ptr(),
-                                                                 value.len());
+                value.len(),
+            );
         }
     }
 }
 
-pub unsafe fn new_table_properties_collector(cname: &str,
-                                             collector: Box<TablePropertiesCollector>)
-                                             -> *mut DBTablePropertiesCollector {
+pub unsafe fn new_table_properties_collector(
+    cname: &str,
+    collector: Box<TablePropertiesCollector>,
+) -> *mut DBTablePropertiesCollector {
     let handle = TablePropertiesCollectorHandle::new(cname, collector);
     crocksdb_ffi::crocksdb_table_properties_collector_create(
         Box::into_raw(Box::new(handle)) as *mut c_void,

src/table_properties_collector_factory.rs

@@ -12,9 +12,9 @@
 // limitations under the License.
 
 use crocksdb_ffi::{self, DBTablePropertiesCollector, DBTablePropertiesCollectorFactory};
-use libc::{c_void, c_char, uint32_t};
+use libc::{c_char, c_void, uint32_t};
 use std::ffi::CString;
-use table_properties_collector::{TablePropertiesCollector, new_table_properties_collector};
+use table_properties_collector::{new_table_properties_collector, TablePropertiesCollector};
 
 /// Constructs `TablePropertiesCollector`.
 /// Internals create a new `TablePropertiesCollector` for each new table.
@@ -29,9 +29,10 @@ struct TablePropertiesCollectorFactoryHandle {
 }
 
 impl TablePropertiesCollectorFactoryHandle {
-    fn new(name: &str,
-           rep: Box<TablePropertiesCollectorFactory>)
-           -> TablePropertiesCollectorFactoryHandle {
+    fn new(
+        name: &str,
+        rep: Box<TablePropertiesCollectorFactory>,
+    ) -> TablePropertiesCollectorFactoryHandle {
         TablePropertiesCollectorFactoryHandle {
             name: CString::new(name).unwrap(),
             rep: rep,
@@ -52,9 +53,10 @@ extern "C" fn destruct(handle: *mut c_void) {
     }
 }
 
-extern "C" fn create_table_properties_collector(handle: *mut c_void,
-                                                cf: uint32_t)
-                                                -> *mut DBTablePropertiesCollector {
+extern "C" fn create_table_properties_collector(
+    handle: *mut c_void,
+    cf: uint32_t,
+) -> *mut DBTablePropertiesCollector {
     unsafe {
         let handle = &mut *(handle as *mut TablePropertiesCollectorFactoryHandle);
         let collector = handle.rep.create_table_properties_collector(cf);
@@ -62,9 +64,10 @@ extern "C" fn create_table_properties_collector(handle: *mut c_void,
     }
 }
 
-pub unsafe fn new_table_properties_collector_factory
-    (fname: &str, factory: Box<TablePropertiesCollectorFactory>)
-     -> *mut DBTablePropertiesCollectorFactory {
+pub unsafe fn new_table_properties_collector_factory(
+    fname: &str,
+    factory: Box<TablePropertiesCollectorFactory>,
+) -> *mut DBTablePropertiesCollectorFactory {
     let handle = TablePropertiesCollectorFactoryHandle::new(fname, factory);
     crocksdb_ffi::crocksdb_table_properties_collector_factory_create(
         Box::into_raw(Box::new(handle)) as *mut c_void,

tests/test_column_family.rs

@@ -13,7 +13,7 @@
 // limitations under the License.
 //
 
-use rocksdb::{DB, MergeOperands, DBOptions, ColumnFamilyOptions, Writable};
+use rocksdb::{ColumnFamilyOptions, DBOptions, MergeOperands, Writable, DB};
 use tempdir::TempDir;
 
 #[test]
@@ -43,15 +43,15 @@ pub fn test_column_family() {
         let mut cf_opts = ColumnFamilyOptions::new();
         cf_opts.add_merge_operator("test operator", test_provided_merge);
         match DB::open_cf(DBOptions::new(), path_str, vec!["default"], vec![cf_opts]) {
-            Ok(_) => {
-                panic!("should not have opened DB successfully without \
+            Ok(_) => panic!(
+                "should not have opened DB successfully without \
                         specifying column
-            families")
-            }
-            Err(e) => {
-                assert!(e.starts_with("Invalid argument: You have to open \
-                                       all column families."))
-            }
+            families"
+            ),
+            Err(e) => assert!(e.starts_with(
+                "Invalid argument: You have to open \
+                 all column families."
+            )),
         }
     }
 
@@ -77,11 +77,7 @@ pub fn test_column_family() {
         };
         let cf1 = db.cf_handle("cf1").unwrap();
         assert!(db.put_cf(cf1, b"k1", b"v1").is_ok());
-        assert!(db.get_cf(cf1, b"k1")
-                    .unwrap()
-                    .unwrap()
-                    .to_utf8()
-                    .unwrap() == "v1");
+        assert!(db.get_cf(cf1, b"k1").unwrap().unwrap().to_utf8().unwrap() == "v1");
         let p = db.put_cf(cf1, b"k1", b"a");
         assert!(p.is_ok());
         /*
@@ -117,11 +113,12 @@ pub fn test_column_family() {
     {}
     // should be able to drop a cf
     {
-        let mut db = DB::open_cf(DBOptions::new(),
+        let mut db = DB::open_cf(
+            DBOptions::new(),
             path_str,
             vec!["cf1"],
-                                 vec![ColumnFamilyOptions::new()])
-            .unwrap();
+            vec![ColumnFamilyOptions::new()],
+        ).unwrap();
         match db.drop_cf("cf1") {
             Ok(_) => println!("cf1 successfully dropped."),
             Err(e) => panic!("failed to drop column family: {}", e),
@@ -129,18 +126,17 @@ pub fn test_column_family() {
     }
 }
 
-fn test_provided_merge(_: &[u8],
+fn test_provided_merge(
+    _: &[u8],
     existing_val: Option<&[u8]>,
-                       operands: &mut MergeOperands)
-                       -> Vec<u8> {
+    operands: &mut MergeOperands,
+) -> Vec<u8> {
     let nops = operands.size_hint().0;
     let mut result: Vec<u8> = Vec::with_capacity(nops);
     match existing_val {
-        Some(v) => {
-            for e in v {
+        Some(v) => for e in v {
             result.push(*e);
-            }
-        }
+        },
         None => (),
     }
     for op in operands {

tests/test_compact_range.rs

@@ -11,7 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use rocksdb::{DB, DBOptions, Range, Writable};
+use rocksdb::{DBOptions, Range, Writable, DB};
 use tempdir::TempDir;
 
 
@@ -21,11 +21,13 @@ fn test_compact_range() {
     let mut opts = DBOptions::new();
     opts.create_if_missing(true);
     let db = DB::open(opts, path.path().to_str().unwrap()).unwrap();
-    let samples = vec![(b"k1".to_vec(), b"value--------1".to_vec()),
+    let samples = vec![
+        (b"k1".to_vec(), b"value--------1".to_vec()),
         (b"k2".to_vec(), b"value--------2".to_vec()),
         (b"k3".to_vec(), b"value--------3".to_vec()),
         (b"k4".to_vec(), b"value--------4".to_vec()),
-                       (b"k5".to_vec(), b"value--------5".to_vec())];
+        (b"k5".to_vec(), b"value--------5".to_vec()),
+    ];
     for &(ref k, ref v) in &samples {
         db.put(k, v).unwrap();
         assert_eq!(v.as_slice(), &*db.get(k).unwrap().unwrap());

tests/test_compaction_filter.rs

@@ -11,7 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use rocksdb::{Writable, DB, CompactionFilter, DBOptions, ColumnFamilyOptions};
+use rocksdb::{ColumnFamilyOptions, CompactionFilter, DBOptions, Writable, DB};
 use std::sync::{Arc, RwLock};
 use std::sync::atomic::{AtomicBool, Ordering};
 use tempdir::TempDir;
@@ -44,22 +44,28 @@ fn test_compaction_filter() {
     let drop_called = Arc::new(AtomicBool::new(false));
     let filtered_kvs = Arc::new(RwLock::new(vec![]));
     // set ignore_snapshots to false
-    cf_opts.set_compaction_filter("test",
+    cf_opts
+        .set_compaction_filter(
+            "test",
             false,
             Box::new(Filter {
                 drop_called: drop_called.clone(),
                 filtered_kvs: filtered_kvs.clone(),
-                               }))
+            }),
+        )
         .unwrap();
     let mut opts = DBOptions::new();
     opts.create_if_missing(true);
-    let db = DB::open_cf(opts,
+    let db = DB::open_cf(
+        opts,
         path.path().to_str().unwrap(),
         vec!["default"],
-                         vec![cf_opts])
-        .unwrap();
-    let samples = vec![(b"key1".to_vec(), b"value1".to_vec()),
-                       (b"key2".to_vec(), b"value2".to_vec())];
+        vec![cf_opts],
+    ).unwrap();
+    let samples = vec![
+        (b"key1".to_vec(), b"value1".to_vec()),
+        (b"key2".to_vec(), b"value2".to_vec()),
+    ];
     for &(ref k, ref v) in &samples {
         db.put(k, v).unwrap();
         assert_eq!(v.as_slice(), &*db.get(k).unwrap().unwrap());
@@ -79,21 +85,25 @@ fn test_compaction_filter() {
     // reregister with ignore_snapshots set to true
     let mut cf_opts = ColumnFamilyOptions::new();
     let opts = DBOptions::new();
-    cf_opts.set_compaction_filter("test",
+    cf_opts
+        .set_compaction_filter(
+            "test",
             true,
             Box::new(Filter {
                 drop_called: drop_called.clone(),
                 filtered_kvs: filtered_kvs.clone(),
-                               }))
+            }),
+        )
         .unwrap();
     assert!(drop_called.load(Ordering::Relaxed));
     drop_called.store(false, Ordering::Relaxed);
     {
-        let db = DB::open_cf(opts,
+        let db = DB::open_cf(
+            opts,
             path.path().to_str().unwrap(),
             vec!["default"],
-                             vec![cf_opts])
-            .unwrap();
+            vec![cf_opts],
+        ).unwrap();
         let _snap = db.snapshot();
         // Because ignore_snapshots is true, so all the keys will be compacted.
         db.compact_range(Some(b"key1"), Some(b"key3"));

tests/test_delete_range.rs

@@ -84,10 +84,12 @@ fn test_delete_range_case_1() {
     let mut opts = DBOptions::new();
     opts.create_if_missing(true);
     let db = DB::open(opts, path_str).unwrap();
-    let samples_a = vec![(b"key1", b"value1"),
+    let samples_a = vec![
+        (b"key1", b"value1"),
         (b"key2", b"value2"),
         (b"key3", b"value3"),
-                         (b"key4", b"value4")];
+        (b"key4", b"value4"),
+    ];
     for (k, v) in samples_a {
         db.put(k, v).unwrap();
         assert_eq!(v, &*db.get(k).unwrap().unwrap());
@@ -100,24 +102,37 @@ fn test_delete_range_case_1() {
     let ingest_opt = IngestExternalFileOptions::new();
 
     let default_options = db.get_options();
-    gen_sst_from_db(default_options,
+    gen_sst_from_db(
+        default_options,
         db.cf_handle("default"),
         test_sstfile_str,
-                    &db);
+        &db,
+    );
 
     db.delete_range(b"key1", b"key5").unwrap();
-    check_kv(&db,
+    check_kv(
+        &db,
         db.cf_handle("default"),
-             &[(b"key1", None), (b"key2", None), (b"key3", None), (b"key4", None)]);
+        &[
+            (b"key1", None),
+            (b"key2", None),
+            (b"key3", None),
+            (b"key4", None),
+        ],
+    );
 
     db.ingest_external_file(&ingest_opt, &[test_sstfile_str])
         .unwrap();
-    check_kv(&db,
+    check_kv(
+        &db,
         db.cf_handle("default"),
-             &[(b"key1", Some(b"value1")),
+        &[
+            (b"key1", Some(b"value1")),
             (b"key2", Some(b"value2")),
             (b"key3", Some(b"value3")),
-               (b"key4", Some(b"value4"))]);
+            (b"key4", Some(b"value4")),
+        ],
+    );
 
     let after = gen_crc32_from_db(&db);
     assert_eq!(before, after);
@@ -130,10 +145,12 @@ fn test_delete_range_case_2() {
     let mut opts = DBOptions::new();
     opts.create_if_missing(true);
     let db = DB::open(opts, path_str).unwrap();
-    let samples_a = vec![(b"key1", b"value1"),
+    let samples_a = vec![
+        (b"key1", b"value1"),
         (b"key2", b"value2"),
         (b"key3", b"value3"),
-                         (b"key4", b"value4")];
+        (b"key4", b"value4"),
+    ];
     for (k, v) in samples_a {
         db.put(k, v).unwrap();
         assert_eq!(v, &*db.get(k).unwrap().unwrap());
@@ -146,15 +163,24 @@ fn test_delete_range_case_2() {
     let ingest_opt = IngestExternalFileOptions::new();
 
     let default_options = db.get_options();
-    gen_sst_from_db(default_options,
+    gen_sst_from_db(
+        default_options,
         db.cf_handle("default"),
         test_sstfile_str,
-                    &db);
+        &db,
+    );
 
     db.delete_range(b"key1", b"key5").unwrap();
-    check_kv(&db,
+    check_kv(
+        &db,
         db.cf_handle("default"),
-             &[(b"key1", None), (b"key2", None), (b"key3", None), (b"key4", None)]);
+        &[
+            (b"key1", None),
+            (b"key2", None),
+            (b"key3", None),
+            (b"key4", None),
+        ],
+    );
 
     let path = TempDir::new("_rust_rocksdb_test_delete_range_case_2_2").expect("");
     let path_str = path.path().to_str().unwrap();
@@ -164,12 +190,16 @@ fn test_delete_range_case_2() {
 
     db2.ingest_external_file(&ingest_opt, &[test_sstfile_str])
         .unwrap();
-    check_kv(&db2,
+    check_kv(
+        &db2,
         db2.cf_handle("default"),
-             &[(b"key1", Some(b"value1")),
+        &[
+            (b"key1", Some(b"value1")),
             (b"key2", Some(b"value2")),
             (b"key3", Some(b"value3")),
-               (b"key4", Some(b"value4"))]);
+            (b"key4", Some(b"value4")),
+        ],
+    );
 
     let after = gen_crc32_from_db(&db2);
     assert_eq!(before, after);
@@ -182,11 +212,13 @@ fn test_delete_range_case_3() {
     let mut opts = DBOptions::new();
     opts.create_if_missing(true);
     let db = DB::open(opts, path_str).unwrap();
-    let samples_a = vec![(b"key1", b"value1"),
+    let samples_a = vec![
+        (b"key1", b"value1"),
         (b"key2", b"value2"),
         (b"key3", b"value3"),
         (b"key4", b"value4"),
-                         (b"key5", b"value5")];
+        (b"key5", b"value5"),
+    ];
     for (k, v) in samples_a {
         db.put(k, v).unwrap();
         assert_eq!(v, &*db.get(k).unwrap().unwrap());
@@ -195,13 +227,17 @@ fn test_delete_range_case_3() {
 
     db.delete_range(b"key2", b"key4").unwrap();
 
-    check_kv(&db,
+    check_kv(
+        &db,
         db.cf_handle("default"),
-             &[(b"key1", Some(b"value1")),
+        &[
+            (b"key1", Some(b"value1")),
             (b"key2", None),
             (b"key3", None),
             (b"key4", Some(b"value4")),
-               (b"key5", Some(b"value5"))]);
+            (b"key5", Some(b"value5")),
+        ],
+    );
 
     let path2 = TempDir::new("_rust_rocksdb_test_delete_range_case_3_2").expect("");
     let path_str2 = path2.path().to_str().unwrap();
@@ -221,20 +257,26 @@ fn test_delete_range_case_3() {
     let ingest_opt = IngestExternalFileOptions::new();
 
     let default_options = db2.get_options();
-    gen_sst_from_db(default_options,
+    gen_sst_from_db(
+        default_options,
         db2.cf_handle("default"),
         test_sstfile_str,
-                    &db2);
+        &db2,
+    );
 
     db.ingest_external_file(&ingest_opt, &[test_sstfile_str])
         .unwrap();
-    check_kv(&db,
+    check_kv(
+        &db,
         db.cf_handle("default"),
-             &[(b"key1", Some(b"value1")),
+        &[
+            (b"key1", Some(b"value1")),
             (b"key2", Some(b"value2")),
             (b"key3", Some(b"value3")),
             (b"key4", Some(b"value4")),
-               (b"key5", Some(b"value5"))]);
+            (b"key5", Some(b"value5")),
+        ],
+    );
 
     let after = gen_crc32_from_db(&db);
     assert_eq!(before, after);
@@ -247,11 +289,13 @@ fn test_delete_range_case_4() {
     let mut opts = DBOptions::new();
     opts.create_if_missing(true);
     let db = DB::open(opts, path_str).unwrap();
-    let samples_a = vec![(b"key1", b"value1"),
+    let samples_a = vec![
+        (b"key1", b"value1"),
         (b"key2", b"value2"),
         (b"key3", b"value3"),
         (b"key4", b"value4"),
-                         (b"key5", b"value5")];
+        (b"key5", b"value5"),
+    ];
     for (k, v) in samples_a {
         db.put(k, v).unwrap();
         assert_eq!(v, &*db.get(k).unwrap().unwrap());
@@ -260,13 +304,17 @@ fn test_delete_range_case_4() {
 
     db.delete_range(b"key4", b"key6").unwrap();
 
-    check_kv(&db,
+    check_kv(
+        &db,
         db.cf_handle("default"),
-             &[(b"key1", Some(b"value1")),
+        &[
+            (b"key1", Some(b"value1")),
             (b"key2", Some(b"value2")),
             (b"key3", Some(b"value3")),
             (b"key4", None),
-               (b"key5", None)]);
+            (b"key5", None),
+        ],
+    );
 
     let path = TempDir::new("_rust_rocksdb_test_delete_range_case_4_2").expect("");
     let path_str = path.path().to_str().unwrap();
@@ -286,20 +334,26 @@ fn test_delete_range_case_4() {
     let ingest_opt = IngestExternalFileOptions::new();
 
     let default_options = db2.get_options();
-    gen_sst_from_db(default_options,
+    gen_sst_from_db(
+        default_options,
         db2.cf_handle("default"),
         test_sstfile_str,
-                    &db2);
+        &db2,
+    );
 
     db.ingest_external_file(&ingest_opt, &[test_sstfile_str])
         .unwrap();
-    check_kv(&db,
+    check_kv(
+        &db,
         db.cf_handle("default"),
-             &[(b"key1", Some(b"value1")),
+        &[
+            (b"key1", Some(b"value1")),
             (b"key2", Some(b"value2")),
             (b"key3", Some(b"value3")),
             (b"key4", Some(b"value4")),
-               (b"key5", Some(b"value5"))]);
+            (b"key5", Some(b"value5")),
+        ],
+    );
 
     let after = gen_crc32_from_db(&db);
     assert_eq!(before, after);
@@ -312,11 +366,13 @@ fn test_delete_range_case_5() {
     let mut opts = DBOptions::new();
     opts.create_if_missing(true);
     let db = DB::open(opts, path_str).unwrap();
-    let samples_a = vec![(b"key1", b"value1"),
+    let samples_a = vec![
+        (b"key1", b"value1"),
         (b"key2", b"value2"),
         (b"key3", b"value3"),
         (b"key4", b"value4"),
-                         (b"key5", b"value5")];
+        (b"key5", b"value5"),
+    ];
     for (k, v) in samples_a {
         db.put(k, v).unwrap();
         assert_eq!(v, &*db.get(k).unwrap().unwrap());
@@ -324,13 +380,17 @@ fn test_delete_range_case_5() {
 
     db.delete_range(b"key1", b"key6").unwrap();
 
-    check_kv(&db,
+    check_kv(
+        &db,
         db.cf_handle("default"),
-             &[(b"key1", None),
+        &[
+            (b"key1", None),
             (b"key2", None),
             (b"key3", None),
             (b"key4", None),
-               (b"key5", None)]);
+            (b"key5", None),
+        ],
+    );
 
     let path = TempDir::new("_rust_rocksdb_test_delete_range_case_5_2").expect("");
     let path_str = path.path().to_str().unwrap();
@@ -351,16 +411,20 @@ fn test_delete_range_case_5() {
     let ingest_opt = IngestExternalFileOptions::new();
 
     let default_options = db2.get_options();
-    gen_sst_from_db(default_options,
+    gen_sst_from_db(
+        default_options,
         db2.cf_handle("default"),
         test_sstfile_str,
-                    &db2);
+        &db2,
+    );
 
     db.ingest_external_file(&ingest_opt, &[test_sstfile_str])
         .unwrap();
-    check_kv(&db,
+    check_kv(
+        &db,
         db.cf_handle("default"),
-             &[(b"key4", Some(b"value4")), (b"key5", Some(b"value5"))]);
+        &[(b"key4", Some(b"value4")), (b"key5", Some(b"value5"))],
+    );
 
     let after = gen_crc32_from_db(&db);
     assert_eq!(before, after);
@@ -373,11 +437,13 @@ fn test_delete_range_case_6() {
     let mut opts = DBOptions::new();
     opts.create_if_missing(true);
     let db = DB::open(opts, path_str).unwrap();
-    let samples_a = vec![(b"key1", b"value1"),
+    let samples_a = vec![
+        (b"key1", b"value1"),
         (b"key2", b"value2"),
         (b"key3", b"value3"),
         (b"key4", b"value4"),
-                         (b"key5", b"value5")];
+        (b"key5", b"value5"),
+    ];
     for (k, v) in samples_a {
         db.put(k, v).unwrap();
         assert_eq!(v, &*db.get(k).unwrap().unwrap());
@@ -387,13 +453,17 @@ fn test_delete_range_case_6() {
 
     db.delete_range(b"key1", b"key4").unwrap();
 
-    check_kv(&db,
+    check_kv(
+        &db,
         db.cf_handle("default"),
-             &[(b"key1", None),
+        &[
+            (b"key1", None),
             (b"key2", None),
             (b"key3", None),
             (b"key4", Some(b"value4")),
-               (b"key5", Some(b"value5"))]);
+            (b"key5", Some(b"value5")),
+        ],
+    );
 
     let path = TempDir::new("_rust_rocksdb_test_delete_range_case_5_2").expect("");
     let path_str = path.path().to_str().unwrap();
@@ -401,7 +471,11 @@ fn test_delete_range_case_6() {
     opts.create_if_missing(true);
     let db2 = DB::open(opts, path_str).unwrap();
 
-    let samples_b = vec![(b"key1", b"value1"), (b"key2", b"value2"), (b"key3", b"value3")];
+    let samples_b = vec![
+        (b"key1", b"value1"),
+        (b"key2", b"value2"),
+        (b"key3", b"value3"),
+    ];
     for (k, v) in samples_b {
         db2.put(k, v).unwrap();
         assert_eq!(v, &*db2.get(k).unwrap().unwrap());
@@ -413,20 +487,26 @@ fn test_delete_range_case_6() {
     let ingest_opt = IngestExternalFileOptions::new();
 
     let default_options = db2.get_options();
-    gen_sst_from_db(default_options,
+    gen_sst_from_db(
+        default_options,
         db2.cf_handle("default"),
         test_sstfile_str,
-                    &db2);
+        &db2,
+    );
 
     db.ingest_external_file(&ingest_opt, &[test_sstfile_str])
         .unwrap();
-    check_kv(&db,
+    check_kv(
+        &db,
         db.cf_handle("default"),
-             &[(b"key1", Some(b"value1")),
+        &[
+            (b"key1", Some(b"value1")),
             (b"key2", Some(b"value2")),
             (b"key3", Some(b"value3")),
             (b"key4", Some(b"value4")),
-               (b"key5", Some(b"value5"))]);
+            (b"key5", Some(b"value5")),
+        ],
+    );
 
     let after = gen_crc32_from_db_in_range(&db, b"key4", b"key6");
     assert_eq!(before, after);
@@ -440,11 +520,13 @@ fn test_delete_range_compact() {
     let mut opts = DBOptions::new();
     opts.create_if_missing(true);
     let db = DB::open(opts, path_str).unwrap();
-    let samples_a = vec![(b"key1", b"value1"),
+    let samples_a = vec![
+        (b"key1", b"value1"),
         (b"key2", b"value2"),
         (b"key3", b"value3"),
         (b"key4", b"value4"),
-                         (b"key5", b"value5")];
+        (b"key5", b"value5"),
+    ];
     for (k, v) in samples_a {
         db.put(k, v).unwrap();
         assert_eq!(v, &*db.get(k).unwrap().unwrap());
@@ -454,13 +536,17 @@ fn test_delete_range_compact() {
 
     db.delete_range(b"key1", b"key4").unwrap();
 
-    check_kv(&db,
+    check_kv(
+        &db,
         db.cf_handle("default"),
-             &[(b"key1", None),
+        &[
+            (b"key1", None),
             (b"key2", None),
             (b"key3", None),
             (b"key4", Some(b"value4")),
-               (b"key5", Some(b"value5"))]);
+            (b"key5", Some(b"value5")),
+        ],
+    );
 
     let path = TempDir::new("_rust_rocksdb_test_delete_range_case_5_2").expect("");
     let path_str = path.path().to_str().unwrap();
@@ -468,7 +554,11 @@ fn test_delete_range_compact() {
     opts.create_if_missing(true);
     let db2 = DB::open(opts, path_str).unwrap();
 
-    let samples_b = vec![(b"key1", b"value1"), (b"key2", b"value2"), (b"key3", b"value3")];
+    let samples_b = vec![
+        (b"key1", b"value1"),
+        (b"key2", b"value2"),
+        (b"key3", b"value3"),
+    ];
     for (k, v) in samples_b {
         db2.put(k, v).unwrap();
         assert_eq!(v, &*db2.get(k).unwrap().unwrap());
@@ -480,20 +570,26 @@ fn test_delete_range_compact() {
     let ingest_opt = IngestExternalFileOptions::new();
 
     let default_options = db2.get_options();
-    gen_sst_from_db(default_options,
+    gen_sst_from_db(
+        default_options,
         db2.cf_handle("default"),
         test_sstfile_str,
-                    &db2);
+        &db2,
+    );
 
     db.ingest_external_file(&ingest_opt, &[test_sstfile_str])
         .unwrap();
-    check_kv(&db,
+    check_kv(
+        &db,
         db.cf_handle("default"),
-             &[(b"key1", Some(b"value1")),
+        &[
+            (b"key1", Some(b"value1")),
             (b"key2", Some(b"value2")),
             (b"key3", Some(b"value3")),
             (b"key4", Some(b"value4")),
-               (b"key5", Some(b"value5"))]);
+            (b"key5", Some(b"value5")),
+        ],
+    );
 
     db.compact_range(None, None);
     let after = gen_crc32_from_db_in_range(&db, b"key4", b"key6");
@@ -506,7 +602,9 @@ pub struct FixedSuffixSliceTransform {
 
 impl FixedSuffixSliceTransform {
     pub fn new(suffix_len: usize) -> FixedSuffixSliceTransform {
-        FixedSuffixSliceTransform { suffix_len: suffix_len }
+        FixedSuffixSliceTransform {
+            suffix_len: suffix_len,
+        }
     }
 }
 
@@ -539,18 +637,23 @@ fn test_delete_range_prefix_bloom_case_1() {
     opts.create_if_missing(true);
     let mut cf_opts = ColumnFamilyOptions::new();
     // Prefix extractor(trim the timestamp at tail) for write cf.
-    cf_opts.set_prefix_extractor("FixedSuffixSliceTransform",
-                              Box::new(FixedSuffixSliceTransform::new(3)))
+    cf_opts
+        .set_prefix_extractor(
+            "FixedSuffixSliceTransform",
+            Box::new(FixedSuffixSliceTransform::new(3)),
+        )
         .unwrap_or_else(|err| panic!(format!("{:?}", err)));
     // Create prefix bloom filter for memtable.
     cf_opts.set_memtable_prefix_bloom_size_ratio(0.1 as f64);
     let cf = "default";
     let db = DB::open_cf(opts, path_str, vec![cf], vec![cf_opts]).unwrap();
 
-    let samples_a = vec![(b"keya11111", b"value1"),
+    let samples_a = vec![
+        (b"keya11111", b"value1"),
         (b"keyb22222", b"value2"),
         (b"keyc33333", b"value3"),
-                         (b"keyd44444", b"value4")];
+        (b"keyd44444", b"value4"),
+    ];
     let handle = get_cf_handle(&db, cf).unwrap();
     for (k, v) in samples_a {
         db.put_cf(handle, k, v).unwrap();
@@ -564,27 +667,38 @@ fn test_delete_range_prefix_bloom_case_1() {
     let ingest_opt = IngestExternalFileOptions::new();
 
     let default_options = db.get_options();
-    gen_sst_from_db(default_options,
+    gen_sst_from_db(
+        default_options,
         db.cf_handle("default"),
         test_sstfile_str,
-                    &db);
+        &db,
+    );
 
-    db.delete_range_cf(handle, b"keya11111", b"keye55555").unwrap();
-    check_kv(&db,
+    db.delete_range_cf(handle, b"keya11111", b"keye55555")
+        .unwrap();
+    check_kv(
+        &db,
         db.cf_handle(cf),
-             &[(b"keya11111", None),
+        &[
+            (b"keya11111", None),
             (b"keyb22222", None),
             (b"keyc33333", None),
-               (b"keyd44444", None)]);
+            (b"keyd44444", None),
+        ],
+    );
 
     db.ingest_external_file_cf(handle, &ingest_opt, &[test_sstfile_str])
         .unwrap();
-    check_kv(&db,
+    check_kv(
+        &db,
         db.cf_handle(cf),
-             &[(b"keya11111", Some(b"value1")),
+        &[
+            (b"keya11111", Some(b"value1")),
             (b"keyb22222", Some(b"value2")),
             (b"keyc33333", Some(b"value3")),
-               (b"keyd44444", Some(b"value4"))]);
+            (b"keyd44444", Some(b"value4")),
+        ],
+    );
 
     let after = gen_crc32_from_db(&db);
     assert_eq!(before, after);
@@ -598,8 +712,11 @@ fn test_delete_range_prefix_bloom_case_2() {
     opts.create_if_missing(true);
     let mut cf_opts = ColumnFamilyOptions::new();
     // Prefix extractor(trim the timestamp at tail) for write cf.
-    cf_opts.set_prefix_extractor("FixedSuffixSliceTransform",
-                              Box::new(FixedSuffixSliceTransform::new(3)))
+    cf_opts
+        .set_prefix_extractor(
+            "FixedSuffixSliceTransform",
+            Box::new(FixedSuffixSliceTransform::new(3)),
+        )
         .unwrap_or_else(|err| panic!(format!("{:?}", err)));
     // Create prefix bloom filter for memtable.
     cf_opts.set_memtable_prefix_bloom_size_ratio(0.1 as f64);
@@ -607,10 +724,12 @@ fn test_delete_range_prefix_bloom_case_2() {
     let db = DB::open_cf(opts, path_str, vec![cf], vec![cf_opts]).unwrap();
     let handle = get_cf_handle(&db, cf).unwrap();
 
-    let samples_a = vec![(b"keya11111", b"value1"),
+    let samples_a = vec![
+        (b"keya11111", b"value1"),
         (b"keyb22222", b"value2"),
         (b"keyc33333", b"value3"),
-                         (b"keyd44444", b"value4")];
+        (b"keyd44444", b"value4"),
+    ];
     for (k, v) in samples_a {
         db.put_cf(handle, k, v).unwrap();
         assert_eq!(v, &*db.get(k).unwrap().unwrap());
@@ -623,18 +742,25 @@ fn test_delete_range_prefix_bloom_case_2() {
     let ingest_opt = IngestExternalFileOptions::new();
 
     let default_options = db.get_options();
-    gen_sst_from_db(default_options,
+    gen_sst_from_db(
+        default_options,
         db.cf_handle("default"),
         test_sstfile_str,
-                    &db);
+        &db,
+    );
 
-    db.delete_range_cf(handle, b"keya11111", b"keye55555").unwrap();
-    check_kv(&db,
+    db.delete_range_cf(handle, b"keya11111", b"keye55555")
+        .unwrap();
+    check_kv(
+        &db,
         db.cf_handle("default"),
-             &[(b"keya11111", None),
+        &[
+            (b"keya11111", None),
             (b"keyb22222", None),
             (b"keyc33333", None),
-               (b"keyd44444", None)]);
+            (b"keyd44444", None),
+        ],
+    );
 
     let path = TempDir::new("_rust_rocksdb_test_delete_range_prefix_bloom_case_2_2").expect("");
     let path_str = path.path().to_str().unwrap();
@@ -642,8 +768,11 @@ fn test_delete_range_prefix_bloom_case_2() {
     opts.create_if_missing(true);
     let mut cf_opts = ColumnFamilyOptions::new();
     // Prefix extractor(trim the timestamp at tail) for write cf.
-    cf_opts.set_prefix_extractor("FixedSuffixSliceTransform",
-                              Box::new(FixedSuffixSliceTransform::new(3)))
+    cf_opts
+        .set_prefix_extractor(
+            "FixedSuffixSliceTransform",
+            Box::new(FixedSuffixSliceTransform::new(3)),
+        )
         .unwrap_or_else(|err| panic!(format!("{:?}", err)));
     // Create prefix bloom filter for memtable.
     cf_opts.set_memtable_prefix_bloom_size_ratio(0.1 as f64);
@@ -653,12 +782,16 @@ fn test_delete_range_prefix_bloom_case_2() {
 
     db2.ingest_external_file_cf(handle2, &ingest_opt, &[test_sstfile_str])
         .unwrap();
-    check_kv(&db2,
+    check_kv(
+        &db2,
         db2.cf_handle(cf),
-             &[(b"keya11111", Some(b"value1")),
+        &[
+            (b"keya11111", Some(b"value1")),
             (b"keyb22222", Some(b"value2")),
             (b"keyc33333", Some(b"value3")),
-               (b"keyd44444", Some(b"value4"))]);
+            (b"keyd44444", Some(b"value4")),
+        ],
+    );
 
     let after = gen_crc32_from_db(&db2);
     assert_eq!(before, after);
@@ -672,34 +805,44 @@ fn test_delete_range_prefix_bloom_case_3() {
     opts.create_if_missing(true);
     let mut cf_opts = ColumnFamilyOptions::new();
     // Prefix extractor(trim the timestamp at tail) for write cf.
-    cf_opts.set_prefix_extractor("FixedSuffixSliceTransform",
-                              Box::new(FixedSuffixSliceTransform::new(3)))
+    cf_opts
+        .set_prefix_extractor(
+            "FixedSuffixSliceTransform",
+            Box::new(FixedSuffixSliceTransform::new(3)),
+        )
         .unwrap_or_else(|err| panic!(format!("{:?}", err)));
     // Create prefix bloom filter for memtable.
     cf_opts.set_memtable_prefix_bloom_size_ratio(0.1 as f64);
     let cf = "default";
     let db = DB::open_cf(opts, path_str, vec![cf], vec![cf_opts]).unwrap();
     let handle = get_cf_handle(&db, cf).unwrap();
-    let samples_a = vec![(b"keya11111", b"value1"),
+    let samples_a = vec![
+        (b"keya11111", b"value1"),
         (b"keyb22222", b"value2"),
         (b"keyc33333", b"value3"),
         (b"keyd44444", b"value4"),
-                         (b"keye55555", b"value5")];
+        (b"keye55555", b"value5"),
+    ];
     for (k, v) in samples_a {
         db.put_cf(handle, k, v).unwrap();
         assert_eq!(v, &*db.get(k).unwrap().unwrap());
     }
     let before = gen_crc32_from_db(&db);
 
-    db.delete_range_cf(handle, b"keyb22222", b"keyd44444").unwrap();
+    db.delete_range_cf(handle, b"keyb22222", b"keyd44444")
+        .unwrap();
 
-    check_kv(&db,
+    check_kv(
+        &db,
         db.cf_handle(cf),
-             &[(b"keya11111", Some(b"value1")),
+        &[
+            (b"keya11111", Some(b"value1")),
             (b"keyb22222", None),
             (b"keyc33333", None),
             (b"keyd44444", Some(b"value4")),
-               (b"keye55555", Some(b"value5"))]);
+            (b"keye55555", Some(b"value5")),
+        ],
+    );
 
     let path = TempDir::new("_rust_rocksdb_test_delete_range_prefix_bloom_case_3_2").expect("");
     let path_str = path.path().to_str().unwrap();
@@ -707,8 +850,11 @@ fn test_delete_range_prefix_bloom_case_3() {
     opts.create_if_missing(true);
     let mut cf_opts = ColumnFamilyOptions::new();
     // Prefix extractor(trim the timestamp at tail) for write cf.
-    cf_opts.set_prefix_extractor("FixedSuffixSliceTransform",
-                              Box::new(FixedSuffixSliceTransform::new(3)))
+    cf_opts
+        .set_prefix_extractor(
+            "FixedSuffixSliceTransform",
+            Box::new(FixedSuffixSliceTransform::new(3)),
+        )
         .unwrap_or_else(|err| panic!(format!("{:?}", err)));
     // Create prefix bloom filter for memtable.
     cf_opts.set_memtable_prefix_bloom_size_ratio(0.1 as f64);
@@ -731,13 +877,17 @@ fn test_delete_range_prefix_bloom_case_3() {
 
     db.ingest_external_file_cf(handle, &ingest_opt, &[test_sstfile_str])
         .unwrap();
-    check_kv(&db,
+    check_kv(
+        &db,
         db.cf_handle(cf),
-             &[(b"keya11111", Some(b"value1")),
+        &[
+            (b"keya11111", Some(b"value1")),
             (b"keyb22222", Some(b"value2")),
             (b"keyc33333", Some(b"value3")),
             (b"keyd44444", Some(b"value4")),
-               (b"keye55555", Some(b"value5"))]);
+            (b"keye55555", Some(b"value5")),
+        ],
+    );
 
     let after = gen_crc32_from_db(&db);
     assert_eq!(before, after);
@@ -751,34 +901,44 @@ fn test_delete_range_prefix_bloom_case_4() {
     opts.create_if_missing(true);
     let mut cf_opts = ColumnFamilyOptions::new();
     // Prefix extractor(trim the timestamp at tail) for write cf.
-    cf_opts.set_prefix_extractor("FixedSuffixSliceTransform",
-                              Box::new(FixedSuffixSliceTransform::new(3)))
+    cf_opts
+        .set_prefix_extractor(
+            "FixedSuffixSliceTransform",
+            Box::new(FixedSuffixSliceTransform::new(3)),
+        )
         .unwrap_or_else(|err| panic!(format!("{:?}", err)));
     // Create prefix bloom filter for memtable.
     cf_opts.set_memtable_prefix_bloom_size_ratio(0.1 as f64);
     let cf = "default";
     let db = DB::open_cf(opts, path_str, vec![cf], vec![cf_opts]).unwrap();
     let handle = get_cf_handle(&db, cf).unwrap();
-    let samples_a = vec![(b"keya11111", b"value1"),
+    let samples_a = vec![
+        (b"keya11111", b"value1"),
         (b"keyb22222", b"value2"),
         (b"keyc33333", b"value3"),
         (b"keyd44444", b"value4"),
-                         (b"keye55555", b"value5")];
+        (b"keye55555", b"value5"),
+    ];
     for (k, v) in samples_a {
         db.put_cf(handle, k, v).unwrap();
         assert_eq!(v, &*db.get(k).unwrap().unwrap());
     }
     let before = gen_crc32_from_db(&db);
 
-    db.delete_range_cf(handle, b"keyd44444", b"keyf66666").unwrap();
+    db.delete_range_cf(handle, b"keyd44444", b"keyf66666")
+        .unwrap();
 
-    check_kv(&db,
+    check_kv(
+        &db,
         db.cf_handle(cf),
-             &[(b"keya11111", Some(b"value1")),
+        &[
+            (b"keya11111", Some(b"value1")),
             (b"keyb22222", Some(b"value2")),
             (b"keyc33333", Some(b"value3")),
             (b"keyd44444", None),
-               (b"keye55555", None)]);
+            (b"keye55555", None),
+        ],
+    );
 
     let path = TempDir::new("_rust_rocksdb_test_delete_range_prefix_bloom_case_4_2").expect("");
     let path_str = path.path().to_str().unwrap();
@@ -786,8 +946,11 @@ fn test_delete_range_prefix_bloom_case_4() {
     opts.create_if_missing(true);
     let mut cf_opts = ColumnFamilyOptions::new();
     // Prefix extractor(trim the timestamp at tail) for write cf.
-    cf_opts.set_prefix_extractor("FixedSuffixSliceTransform",
-                              Box::new(FixedSuffixSliceTransform::new(3)))
+    cf_opts
+        .set_prefix_extractor(
+            "FixedSuffixSliceTransform",
+            Box::new(FixedSuffixSliceTransform::new(3)),
+        )
         .unwrap_or_else(|err| panic!(format!("{:?}", err)));
     // Create prefix bloom filter for memtable.
     cf_opts.set_memtable_prefix_bloom_size_ratio(0.1 as f64);
@@ -812,13 +975,17 @@ fn test_delete_range_prefix_bloom_case_4() {
 
     db.ingest_external_file_cf(handle, &ingest_opt, &[test_sstfile_str])
         .unwrap();
-    check_kv(&db,
+    check_kv(
+        &db,
         db.cf_handle(cf),
-             &[(b"keya11111", Some(b"value1")),
+        &[
+            (b"keya11111", Some(b"value1")),
             (b"keyb22222", Some(b"value2")),
             (b"keyc33333", Some(b"value3")),
             (b"keyd44444", Some(b"value4")),
-               (b"keye55555", Some(b"value5"))]);
+            (b"keye55555", Some(b"value5")),
+        ],
+    );
 
     let after = gen_crc32_from_db(&db);
     assert_eq!(before, after);
@@ -833,19 +1000,24 @@ fn test_delete_range_prefix_bloom_case_5() {
     opts.create_if_missing(true);
     let mut cf_opts = ColumnFamilyOptions::new();
     // Prefix extractor(trim the timestamp at tail) for write cf.
-    cf_opts.set_prefix_extractor("FixedSuffixSliceTransform",
-                              Box::new(FixedSuffixSliceTransform::new(3)))
+    cf_opts
+        .set_prefix_extractor(
+            "FixedSuffixSliceTransform",
+            Box::new(FixedSuffixSliceTransform::new(3)),
+        )
         .unwrap_or_else(|err| panic!(format!("{:?}", err)));
     // Create prefix bloom filter for memtable.
     cf_opts.set_memtable_prefix_bloom_size_ratio(0.1 as f64);
     let cf = "default";
     let db = DB::open_cf(opts, path_str, vec![cf], vec![cf_opts]).unwrap();
     let handle = get_cf_handle(&db, cf).unwrap();
-    let samples_a = vec![(b"keya11111", b"value1"),
+    let samples_a = vec![
+        (b"keya11111", b"value1"),
         (b"keyb22222", b"value2"),
         (b"keyc33333", b"value3"),
         (b"keyd44444", b"value4"),
-                         (b"keye55555", b"value5")];
+        (b"keye55555", b"value5"),
+    ];
     for (k, v) in samples_a {
         db.put_cf(handle, k, v).unwrap();
         assert_eq!(v, &*db.get(k).unwrap().unwrap());
@@ -853,13 +1025,17 @@ fn test_delete_range_prefix_bloom_case_5() {
 
     db.delete_range(b"keya11111", b"keyf66666").unwrap();
 
-    check_kv(&db,
+    check_kv(
+        &db,
         db.cf_handle(cf),
-             &[(b"keya11111", None),
+        &[
+            (b"keya11111", None),
             (b"keyb22222", None),
             (b"keyc33333", None),
             (b"keyd44444", None),
-               (b"keye55555", None)]);
+            (b"keye55555", None),
+        ],
+    );
 
     let path = TempDir::new("_rust_rocksdb_test_delete_range_prefix_bloom_case_5_2").expect("");
     let path_str = path.path().to_str().unwrap();
@@ -867,8 +1043,11 @@ fn test_delete_range_prefix_bloom_case_5() {
     opts.create_if_missing(true);
     let mut cf_opts = ColumnFamilyOptions::new();
     // Prefix extractor(trim the timestamp at tail) for write cf.
-    cf_opts.set_prefix_extractor("FixedSuffixSliceTransform",
-                              Box::new(FixedSuffixSliceTransform::new(3)))
+    cf_opts
+        .set_prefix_extractor(
+            "FixedSuffixSliceTransform",
+            Box::new(FixedSuffixSliceTransform::new(3)),
+        )
         .unwrap_or_else(|err| panic!(format!("{:?}", err)));
     // Create prefix bloom filter for memtable.
     cf_opts.set_memtable_prefix_bloom_size_ratio(0.1 as f64);
@@ -892,9 +1071,14 @@ fn test_delete_range_prefix_bloom_case_5() {
 
     db.ingest_external_file_cf(handle, &ingest_opt, &[test_sstfile_str])
         .unwrap();
-    check_kv(&db,
+    check_kv(
+        &db,
         db.cf_handle(cf),
-             &[(b"keyd44444", Some(b"value4")), (b"keye55555", Some(b"value5"))]);
+        &[
+            (b"keyd44444", Some(b"value4")),
+            (b"keye55555", Some(b"value5")),
+        ],
+    );
 
     let after = gen_crc32_from_db(&db);
     assert_eq!(before, after);
@@ -908,19 +1092,24 @@ fn test_delete_range_prefix_bloom_case_6() {
     opts.create_if_missing(true);
     let mut cf_opts = ColumnFamilyOptions::new();
     // Prefix extractor(trim the timestamp at tail) for write cf.
-    cf_opts.set_prefix_extractor("FixedSuffixSliceTransform",
-                              Box::new(FixedSuffixSliceTransform::new(3)))
+    cf_opts
+        .set_prefix_extractor(
+            "FixedSuffixSliceTransform",
+            Box::new(FixedSuffixSliceTransform::new(3)),
+        )
         .unwrap_or_else(|err| panic!(format!("{:?}", err)));
     // Create prefix bloom filter for memtable.
     cf_opts.set_memtable_prefix_bloom_size_ratio(0.1 as f64);
     let cf = "default";
     let db = DB::open_cf(opts, path_str, vec![cf], vec![cf_opts]).unwrap();
     let handle = get_cf_handle(&db, cf).unwrap();
-    let samples_a = vec![(b"keya11111", b"value1"),
+    let samples_a = vec![
+        (b"keya11111", b"value1"),
         (b"keyb22222", b"value2"),
         (b"keyc33333", b"value3"),
         (b"keyd44444", b"value4"),
-                         (b"keye55555", b"value5")];
+        (b"keye55555", b"value5"),
+    ];
     for (k, v) in samples_a {
         db.put_cf(handle, k, v).unwrap();
         assert_eq!(v, &*db.get(k).unwrap().unwrap());
@@ -930,13 +1119,17 @@ fn test_delete_range_prefix_bloom_case_6() {
 
     db.delete_range(b"keya11111", b"keyd44444").unwrap();
 
-    check_kv(&db,
+    check_kv(
+        &db,
         db.cf_handle("default"),
-             &[(b"keya11111", None),
+        &[
+            (b"keya11111", None),
             (b"keyb22222", None),
             (b"keyc33333", None),
             (b"keyd44444", Some(b"value4")),
-               (b"keye55555", Some(b"value5"))]);
+            (b"keye55555", Some(b"value5")),
+        ],
+    );
 
     let path = TempDir::new("_rust_rocksdb_test_delete_range_prefix_bloom_case_6_2").expect("");
     let path_str = path.path().to_str().unwrap();
@@ -944,16 +1137,22 @@ fn test_delete_range_prefix_bloom_case_6() {
     opts.create_if_missing(true);
     let mut cf_opts = ColumnFamilyOptions::new();
     // Prefix extractor(trim the timestamp at tail) for write cf.
-    cf_opts.set_prefix_extractor("FixedSuffixSliceTransform",
-                              Box::new(FixedSuffixSliceTransform::new(3)))
+    cf_opts
+        .set_prefix_extractor(
+            "FixedSuffixSliceTransform",
+            Box::new(FixedSuffixSliceTransform::new(3)),
+        )
         .unwrap_or_else(|err| panic!(format!("{:?}", err)));
     // Create prefix bloom filter for memtable.
     cf_opts.set_memtable_prefix_bloom_size_ratio(0.1 as f64);
     let db2 = DB::open_cf(opts, path_str, vec![cf], vec![cf_opts]).unwrap();
     let handle2 = get_cf_handle(&db2, cf).unwrap();
 
-    let samples_b =
-        vec![(b"keya11111", b"value1"), (b"keyb22222", b"value2"), (b"keyc33333", b"value3")];
+    let samples_b = vec![
+        (b"keya11111", b"value1"),
+        (b"keyb22222", b"value2"),
+        (b"keyc33333", b"value3"),
+    ];
     for (k, v) in samples_b {
         db2.put_cf(handle2, k, v).unwrap();
         assert_eq!(v, &*db2.get(k).unwrap().unwrap());
@@ -969,13 +1168,17 @@ fn test_delete_range_prefix_bloom_case_6() {
 
     db.ingest_external_file_cf(handle, &ingest_opt, &[test_sstfile_str])
         .unwrap();
-    check_kv(&db,
+    check_kv(
+        &db,
         db.cf_handle(cf),
-             &[(b"keya11111", Some(b"value1")),
+        &[
+            (b"keya11111", Some(b"value1")),
             (b"keyb22222", Some(b"value2")),
             (b"keyc33333", Some(b"value3")),
             (b"keyd44444", Some(b"value4")),
-               (b"keye55555", Some(b"value5"))]);
+            (b"keye55555", Some(b"value5")),
+        ],
+    );
 
     let after = gen_crc32_from_db_in_range(&db, b"key4", b"key6");
     assert_eq!(before, after);
@@ -1007,19 +1210,24 @@ fn test_delete_range_prefix_bloom_compact_case() {
     opts.create_if_missing(true);
     let mut cf_opts = ColumnFamilyOptions::new();
     // Prefix extractor(trim the timestamp at tail) for write cf.
-    cf_opts.set_prefix_extractor("FixedSuffixSliceTransform",
-                              Box::new(FixedSuffixSliceTransform::new(3)))
+    cf_opts
+        .set_prefix_extractor(
+            "FixedSuffixSliceTransform",
+            Box::new(FixedSuffixSliceTransform::new(3)),
+        )
         .unwrap_or_else(|err| panic!(format!("{:?}", err)));
     // Create prefix bloom filter for memtable.
     cf_opts.set_memtable_prefix_bloom_size_ratio(0.1 as f64);
     let cf = "default";
     let db = DB::open_cf(opts, path_str, vec![cf], vec![cf_opts]).unwrap();
     let handle = get_cf_handle(&db, cf).unwrap();
-    let samples_a = vec![(b"keya11111", b"value1"),
+    let samples_a = vec![
+        (b"keya11111", b"value1"),
         (b"keyb22222", b"value2"),
         (b"keyc33333", b"value3"),
         (b"keyd44444", b"value4"),
-                         (b"keye55555", b"value5")];
+        (b"keye55555", b"value5"),
+    ];
     for (k, v) in samples_a {
         db.put_cf(handle, k, v).unwrap();
         assert_eq!(v, &*db.get(k).unwrap().unwrap());
@@ -1029,13 +1237,17 @@ fn test_delete_range_prefix_bloom_compact_case() {
 
     db.delete_range(b"keya11111", b"keyd44444").unwrap();
 
-    check_kv(&db,
+    check_kv(
+        &db,
         db.cf_handle("default"),
-             &[(b"keya11111", None),
+        &[
+            (b"keya11111", None),
             (b"keyb22222", None),
             (b"keyc33333", None),
             (b"keyd44444", Some(b"value4")),
-               (b"keye55555", Some(b"value5"))]);
+            (b"keye55555", Some(b"value5")),
+        ],
+    );
 
     let path = TempDir::new("_rust_rocksdb_test_delete_range_prefix_bloom_case_6_2").expect("");
     let path_str = path.path().to_str().unwrap();
@@ -1043,16 +1255,22 @@ fn test_delete_range_prefix_bloom_compact_case() {
     opts.create_if_missing(true);
     let mut cf_opts = ColumnFamilyOptions::new();
     // Prefix extractor(trim the timestamp at tail) for write cf.
-    cf_opts.set_prefix_extractor("FixedSuffixSliceTransform",
-                              Box::new(FixedSuffixSliceTransform::new(3)))
+    cf_opts
+        .set_prefix_extractor(
+            "FixedSuffixSliceTransform",
+            Box::new(FixedSuffixSliceTransform::new(3)),
+        )
         .unwrap_or_else(|err| panic!(format!("{:?}", err)));
     // Create prefix bloom filter for memtable.
     cf_opts.set_memtable_prefix_bloom_size_ratio(0.1 as f64);
     let db2 = DB::open_cf(opts, path_str, vec![cf], vec![cf_opts]).unwrap();
     let handle2 = get_cf_handle(&db2, cf).unwrap();
 
-    let samples_b =
-        vec![(b"keya11111", b"value1"), (b"keyb22222", b"value2"), (b"keyc33333", b"value3")];
+    let samples_b = vec![
+        (b"keya11111", b"value1"),
+        (b"keyb22222", b"value2"),
+        (b"keyc33333", b"value3"),
+    ];
     for (k, v) in samples_b {
         db2.put_cf(handle2, k, v).unwrap();
         assert_eq!(v, &*db2.get(k).unwrap().unwrap());
@@ -1069,13 +1287,17 @@ fn test_delete_range_prefix_bloom_compact_case() {
     db.ingest_external_file_cf(handle, &ingest_opt, &[test_sstfile_str])
         .unwrap();
     db.compact_range_cf(handle, None, None);
-    check_kv(&db,
+    check_kv(
+        &db,
         db.cf_handle(cf),
-             &[(b"keya11111", Some(b"value1")),
+        &[
+            (b"keya11111", Some(b"value1")),
             (b"keyb22222", Some(b"value2")),
             (b"keyc33333", Some(b"value3")),
             (b"keyd44444", Some(b"value4")),
-               (b"keye55555", Some(b"value5"))]);
+            (b"keye55555", Some(b"value5")),
+        ],
+    );
 
     let after = gen_crc32_from_db_in_range(&db, b"keyd44444", b"keyf66666");
     assert_eq!(before, after);
@@ -1137,20 +1359,24 @@ fn test_delete_range() {
 fn test_delete_range_sst_files() {
     let path = TempDir::new("_rust_rocksdb_test_delete_range_sst_files").expect("");
     let db = DB::open_default(path.path().to_str().unwrap()).unwrap();
-    let samples_a = vec![(b"key1", b"value1"),
+    let samples_a = vec![
+        (b"key1", b"value1"),
         (b"key2", b"value2"),
         (b"key3", b"value3"),
-                         (b"key4", b"value4")];
+        (b"key4", b"value4"),
+    ];
     for (k, v) in samples_a {
         db.put(k, v).unwrap();
         assert_eq!(v, &*db.get(k).unwrap().unwrap());
     }
     db.flush(true).unwrap();
 
-    let samples_b = vec![(b"key3", b"value5"),
+    let samples_b = vec![
+        (b"key3", b"value5"),
         (b"key6", b"value6"),
         (b"key7", b"value7"),
-                         (b"key8", b"value8")];
+        (b"key8", b"value8"),
+    ];
     for (k, v) in samples_b {
         db.put(k, v).unwrap();
         assert_eq!(v, &*db.get(k).unwrap().unwrap());
@@ -1160,28 +1386,36 @@ fn test_delete_range_sst_files() {
 
     db.delete_range(b"key1", b"key1").unwrap();
     db.delete_range(b"key2", b"key7").unwrap();
-    check_kv(&db,
+    check_kv(
+        &db,
         None,
-             &[(b"key1", Some(b"value1")),
+        &[
+            (b"key1", Some(b"value1")),
             (b"key2", None),
             (b"key3", None),
             (b"key4", None),
             (b"key5", None),
             (b"key6", None),
             (b"key7", Some(b"value7")),
-               (b"key8", Some(b"value8"))]);
+            (b"key8", Some(b"value8")),
+        ],
+    );
 
     db.delete_range(b"key1", b"key8").unwrap();
-    check_kv(&db,
+    check_kv(
+        &db,
         None,
-             &[(b"key1", None),
+        &[
+            (b"key1", None),
             (b"key2", None),
             (b"key3", None),
             (b"key4", None),
             (b"key5", None),
             (b"key6", None),
             (b"key7", None),
-               (b"key8", Some(b"value8"))]);
+            (b"key8", Some(b"value8")),
+        ],
+    );
 }
 
 
@@ -1203,17 +1437,28 @@ fn test_delete_range_ingest_file() {
     db.ingest_external_file(&ingest_opt, &[test_sstfile_str])
         .unwrap();
     assert!(test_sstfile.exists());
-    check_kv(&db,
+    check_kv(
+        &db,
         db.cf_handle("default"),
-             &[(b"key1", Some(b"value1")),
+        &[
+            (b"key1", Some(b"value1")),
             (b"key2", Some(b"value2")),
             (b"key3", Some(b"value3")),
-               (b"key4", Some(b"value4"))]);
+            (b"key4", Some(b"value4")),
+        ],
+    );
 
     db.delete_range(b"key1", b"key4").unwrap();
-    check_kv(&db,
+    check_kv(
+        &db,
         db.cf_handle("default"),
-             &[(b"key1", None), (b"key2", None), (b"key3", None), (b"key4", Some(b"value4"))]);
+        &[
+            (b"key1", None),
+            (b"key2", None),
+            (b"key3", None),
+            (b"key4", Some(b"value4")),
+        ],
+    );
 
     let cf_opts = ColumnFamilyOptions::new();
     db.create_cf("cf1", cf_opts).unwrap();
@@ -1223,22 +1468,30 @@ fn test_delete_range_ingest_file() {
     db.ingest_external_file_cf(handle, &ingest_opt, &[test_sstfile_str])
         .unwrap();
     assert!(test_sstfile.exists());
-    check_kv(&db,
+    check_kv(
+        &db,
         Some(handle),
-             &[(b"key1", Some(b"value1")),
+        &[
+            (b"key1", Some(b"value1")),
             (b"key2", Some(b"value2")),
             (b"key3", Some(b"value3")),
-               (b"key4", Some(b"value4"))]);
+            (b"key4", Some(b"value4")),
+        ],
+    );
 
     let snap = db.snapshot();
 
     db.delete_range_cf(handle, b"key1", b"key3").unwrap();
-    check_kv(&db,
+    check_kv(
+        &db,
         Some(handle),
-             &[(b"key1", None),
+        &[
+            (b"key1", None),
             (b"key2", None),
             (b"key3", Some(b"value3")),
-               (b"key4", Some(b"value4"))]);
+            (b"key4", Some(b"value4")),
+        ],
+    );
     assert_eq!(snap.get_cf(handle, b"key1").unwrap().unwrap(), b"value1");
     assert_eq!(snap.get_cf(handle, b"key4").unwrap().unwrap(), b"value4");
 }

tests/test_event_listener.rs

@@ -86,17 +86,19 @@ fn test_event_listener_basic() {
     opts.create_if_missing(true);
     let db = DB::open(opts, path_str).unwrap();
     for i in 1..8000 {
-        db.put(format!("{:04}", i).as_bytes(),
-                 format!("{:04}", i).as_bytes())
-            .unwrap();
+        db.put(
+            format!("{:04}", i).as_bytes(),
+            format!("{:04}", i).as_bytes(),
+        ).unwrap();
     }
     db.flush(true).unwrap();
     assert_ne!(counter.flush.load(Ordering::SeqCst), 0);
 
     for i in 1..8000 {
-        db.put(format!("{:04}", i).as_bytes(),
-                 format!("{:04}", i).as_bytes())
-            .unwrap();
+        db.put(
+            format!("{:04}", i).as_bytes(),
+            format!("{:04}", i).as_bytes(),
+        ).unwrap();
     }
     db.flush(true).unwrap();
     let flush_cnt = counter.flush.load(Ordering::SeqCst);
@@ -125,10 +127,12 @@ fn test_event_listener_ingestion() {
     let test_sstfile_str = test_sstfile.to_str().unwrap();
 
     let default_options = db.get_options();
-    gen_sst(default_options,
+    gen_sst(
+        default_options,
         Some(db.cf_handle("default").unwrap()),
         test_sstfile_str,
-            &[(b"k1", b"v1"), (b"k2", b"v2")]);
+        &[(b"k1", b"v1"), (b"k2", b"v2")],
+    );
 
     let ingest_opt = IngestExternalFileOptions::new();
     db.ingest_external_file(&ingest_opt, &[test_sstfile_str])

tests/test_ingest_external_file.rs

@@ -16,10 +16,12 @@ use rocksdb::*;
 use std::fs;
 use tempdir::TempDir;
 
-pub fn gen_sst(opt: ColumnFamilyOptions,
+pub fn gen_sst(
+    opt: ColumnFamilyOptions,
     cf: Option<&CFHandle>,
     path: &str,
-               data: &[(&[u8], &[u8])]) {
+    data: &[(&[u8], &[u8])],
+) {
     let _ = fs::remove_file(path);
     let env_opt = EnvOptions::new();
     let mut writer = if cf.is_some() {
@@ -79,11 +81,9 @@ fn gen_sst_delete(opt: ColumnFamilyOptions, cf: Option<&CFHandle>, path: &str) {
 fn concat_merge(_: &[u8], existing_val: Option<&[u8]>, operands: &mut MergeOperands) -> Vec<u8> {
     let mut result: Vec<u8> = Vec::with_capacity(operands.size_hint().0);
     match existing_val {
-        Some(v) => {
-            for e in v {
+        Some(v) => for e in v {
             result.push(*e)
-            }
-        }
+        },
         None => (),
     }
     for op in operands {
@@ -106,10 +106,12 @@ fn test_ingest_external_file() {
     let test_sstfile_str = test_sstfile.to_str().unwrap();
     let default_options = db.get_options();
 
-    gen_sst(default_options,
+    gen_sst(
+        default_options,
         Some(db.cf_handle("default").unwrap()),
         test_sstfile_str,
-            &[(b"k1", b"v1"), (b"k2", b"v2")]);
+        &[(b"k1", b"v1"), (b"k2", b"v2")],
+    );
     let mut ingest_opt = IngestExternalFileOptions::new();
     db.ingest_external_file(&ingest_opt, &[test_sstfile_str])
         .unwrap();
@@ -117,20 +119,24 @@ fn test_ingest_external_file() {
     assert_eq!(db.get(b"k1").unwrap().unwrap(), b"v1");
     assert_eq!(db.get(b"k2").unwrap().unwrap(), b"v2");
 
-    gen_sst(ColumnFamilyOptions::new(),
+    gen_sst(
+        ColumnFamilyOptions::new(),
         None,
         test_sstfile_str,
-            &[(b"k1", b"v3"), (b"k2", b"v4")]);
+        &[(b"k1", b"v3"), (b"k2", b"v4")],
+    );
     db.ingest_external_file_cf(handle, &ingest_opt, &[test_sstfile_str])
         .unwrap();
     assert_eq!(db.get_cf(handle, b"k1").unwrap().unwrap(), b"v3");
     assert_eq!(db.get_cf(handle, b"k2").unwrap().unwrap(), b"v4");
     let snap = db.snapshot();
 
-    gen_sst(ColumnFamilyOptions::new(),
+    gen_sst(
+        ColumnFamilyOptions::new(),
         None,
         test_sstfile_str,
-            &[(b"k2", b"v5"), (b"k3", b"v6")]);
+        &[(b"k2", b"v5"), (b"k3", b"v6")],
+    );
     ingest_opt.move_files(true);
     db.ingest_external_file_cf(handle, &ingest_opt, &[test_sstfile_str])
         .unwrap();
@@ -157,9 +163,11 @@ fn test_ingest_external_file_new() {
     let test_sstfile_str = test_sstfile.to_str().unwrap();
     let default_options = db.get_options();
 
-    gen_sst_put(default_options,
+    gen_sst_put(
+        default_options,
         Some(db.cf_handle("default").unwrap()),
-                test_sstfile_str);
+        test_sstfile_str,
+    );
     let mut ingest_opt = IngestExternalFileOptions::new();
     db.ingest_external_file(&ingest_opt, &[test_sstfile_str])
         .unwrap();
@@ -171,9 +179,11 @@ fn test_ingest_external_file_new() {
 
     let snap = db.snapshot();
     let default_options = db.get_options();
-    gen_sst_merge(default_options,
+    gen_sst_merge(
+        default_options,
         Some(db.cf_handle("default").unwrap()),
-                  test_sstfile_str);
+        test_sstfile_str,
+    );
     db.ingest_external_file(&ingest_opt, &[test_sstfile_str])
         .unwrap();
 
@@ -182,9 +192,11 @@ fn test_ingest_external_file_new() {
     assert_eq!(db.get(b"k3").unwrap().unwrap(), b"cd");
 
     let default_options = db.get_options();
-    gen_sst_delete(default_options,
+    gen_sst_delete(
+        default_options,
         Some(db.cf_handle("default").unwrap()),
-                   test_sstfile_str);
+        test_sstfile_str,
+    );
     ingest_opt.move_files(true);
     db.ingest_external_file(&ingest_opt, &[test_sstfile_str])
         .unwrap();
@@ -300,10 +312,12 @@ fn test_ingest_simulate_real_world() {
     for cf in &ALL_CFS {
         let handle = db.cf_handle(cf).unwrap();
         let cf_opts = ColumnFamilyOptions::new();
-        put_delete_and_generate_sst_cf(cf_opts,
+        put_delete_and_generate_sst_cf(
+            cf_opts,
             &db,
             &handle,
-                                       gen_path.path().join(cf).to_str().unwrap());
+            gen_path.path().join(cf).to_str().unwrap(),
+        );
     }
 
     let path2 = TempDir::new("_rust_rocksdb_ingest_real_world_2").expect("");
@@ -318,29 +332,47 @@ fn test_ingest_simulate_real_world() {
         let handle = db2.cf_handle(cf).unwrap();
         let mut ingest_opt = IngestExternalFileOptions::new();
         ingest_opt.move_files(true);
-        db2.ingest_external_file_cf(handle,
+        db2.ingest_external_file_cf(
+            handle,
             &ingest_opt,
-                                     &[gen_path.path().join(cf).to_str().unwrap()])
-            .unwrap();
-        check_kv(&db,
+            &[gen_path.path().join(cf).to_str().unwrap()],
+        ).unwrap();
+        check_kv(
+            &db,
             db.cf_handle(cf),
-                 &[(b"k1", None), (b"k2", Some(b"v2")), (b"k3", None), (b"k4", Some(b"v4"))]);
+            &[
+                (b"k1", None),
+                (b"k2", Some(b"v2")),
+                (b"k3", None),
+                (b"k4", Some(b"v4")),
+            ],
+        );
         let cf_opts = ColumnFamilyOptions::new();
-        gen_sst_from_cf(cf_opts,
+        gen_sst_from_cf(
+            cf_opts,
             &db2,
             &handle,
-                        gen_path.path().join(cf).to_str().unwrap());
+            gen_path.path().join(cf).to_str().unwrap(),
+        );
     }
 
     for cf in &ALL_CFS {
         let handle = db.cf_handle(cf).unwrap();
         let ingest_opt = IngestExternalFileOptions::new();
-        db.ingest_external_file_cf(handle,
+        db.ingest_external_file_cf(
+            handle,
             &ingest_opt,
-                                     &[gen_path.path().join(cf).to_str().unwrap()])
-            .unwrap();
-        check_kv(&db,
+            &[gen_path.path().join(cf).to_str().unwrap()],
+        ).unwrap();
+        check_kv(
+            &db,
             db.cf_handle(cf),
-                 &[(b"k1", None), (b"k2", Some(b"v2")), (b"k3", None), (b"k4", Some(b"v4"))]);
+            &[
+                (b"k1", None),
+                (b"k2", Some(b"v2")),
+                (b"k3", None),
+                (b"k4", Some(b"v4")),
+            ],
+        );
     }
 }

tests/test_iterator.rs

@@ -79,8 +79,11 @@ pub fn test_iterator() {
     assert!(p.is_ok());
     let p = db.put(k3, v3);
     assert!(p.is_ok());
-    let expected =
-        vec![(k1.to_vec(), v1.to_vec()), (k2.to_vec(), v2.to_vec()), (k3.to_vec(), v3.to_vec())];
+    let expected = vec![
+        (k1.to_vec(), v1.to_vec()),
+        (k2.to_vec(), v2.to_vec()),
+        (k3.to_vec(), v3.to_vec()),
+    ];
 
     let mut iter = db.iter();
 
@@ -113,10 +116,12 @@ pub fn test_iterator() {
     old_iterator.seek(SeekKey::Start);
     let p = db.put(&*k4, &*v4);
     assert!(p.is_ok());
-    let expected2 = vec![(k1.to_vec(), v1.to_vec()),
+    let expected2 = vec![
+        (k1.to_vec(), v1.to_vec()),
         (k2.to_vec(), v2.to_vec()),
         (k3.to_vec(), v3.to_vec()),
-                         (k4.to_vec(), v4.to_vec())];
+        (k4.to_vec(), v4.to_vec()),
+    ];
     assert_eq!(old_iterator.collect::<Vec<_>>(), expected);
 
     iter = db.iter();
@@ -124,8 +129,11 @@ pub fn test_iterator() {
     assert_eq!(iter.collect::<Vec<_>>(), expected2);
 
     iter.seek(SeekKey::Key(k2));
-    let expected =
-        vec![(k2.to_vec(), v2.to_vec()), (k3.to_vec(), v3.to_vec()), (k4.to_vec(), v4.to_vec())];
+    let expected = vec![
+        (k2.to_vec(), v2.to_vec()),
+        (k3.to_vec(), v3.to_vec()),
+        (k4.to_vec(), v4.to_vec()),
+    ];
     assert_eq!(iter.collect::<Vec<_>>(), expected);
 
     iter.seek(SeekKey::Key(k2));
@@ -241,19 +249,32 @@ fn test_total_order_seek() {
     let mut opts = DBOptions::new();
     opts.create_if_missing(true);
     cf_opts.set_block_based_table_factory(&bbto);
-    cf_opts.set_prefix_extractor("FixedPrefixTransform",
-                              Box::new(FixedPrefixTransform { prefix_len: 2 }))
+    cf_opts
+        .set_prefix_extractor(
+            "FixedPrefixTransform",
+            Box::new(FixedPrefixTransform { prefix_len: 2 }),
+        )
         .unwrap();
     // also create prefix bloom for memtable
     cf_opts.set_memtable_prefix_bloom_size_ratio(0.1 as f64);
 
-    let keys = vec![b"k1-1", b"k1-2", b"k1-3", b"k2-1", b"k2-2", b"k2-3", b"k3-1", b"k3-2",
-                    b"k3-3"];
-    let db = DB::open_cf(opts,
+    let keys = vec![
+        b"k1-1",
+        b"k1-2",
+        b"k1-3",
+        b"k2-1",
+        b"k2-2",
+        b"k2-3",
+        b"k3-1",
+        b"k3-2",
+        b"k3-3",
+    ];
+    let db = DB::open_cf(
+        opts,
         path.path().to_str().unwrap(),
         vec!["default"],
-                         vec![cf_opts])
-        .unwrap();
+        vec![cf_opts],
+    ).unwrap();
     let wopts = WriteOptions::new();
 
     // sst1
@@ -324,15 +345,19 @@ fn test_fixed_suffix_seek() {
     let mut cf_opts = ColumnFamilyOptions::new();
     opts.create_if_missing(true);
     cf_opts.set_block_based_table_factory(&bbto);
-    cf_opts.set_prefix_extractor("FixedSuffixTransform",
-                              Box::new(FixedSuffixTransform { suffix_len: 2 }))
+    cf_opts
+        .set_prefix_extractor(
+            "FixedSuffixTransform",
+            Box::new(FixedSuffixTransform { suffix_len: 2 }),
+        )
         .unwrap();
 
-    let db = DB::open_cf(opts,
+    let db = DB::open_cf(
+        opts,
         path.path().to_str().unwrap(),
         vec!["default"],
-                         vec![cf_opts])
-        .unwrap();
+        vec![cf_opts],
+    ).unwrap();
     db.put(b"k-eghe-5", b"a").unwrap();
     db.put(b"k-24yfae-6", b"a").unwrap();
     db.put(b"k-h1fwd-7", b"a").unwrap();

tests/test_multithreaded.rs

@@ -11,7 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use rocksdb::{DB, Writable};
+use rocksdb::{Writable, DB};
 use std::sync::Arc;
 use std::thread;
 use tempdir::TempDir;
@@ -40,11 +40,9 @@ pub fn test_multithreaded() {
     let db3 = db.clone();
     let j3 = thread::spawn(move || for _ in 1..N {
         match db3.get(b"key") {
-            Ok(Some(v)) => {
-                if &v[..] != b"value1" && &v[..] != b"value2" {
+            Ok(Some(v)) => if &v[..] != b"value1" && &v[..] != b"value2" {
                 assert!(false);
-                }
-            }
+            },
             _ => {
                 assert!(false);
             }

tests/test_prefix_extractor.rs

@@ -31,8 +31,17 @@ impl SliceTransform for FixedPrefixTransform {
 #[test]
 fn test_prefix_extractor_compatibility() {
     let path = TempDir::new("_rust_rocksdb_prefix_extractor_compatibility").expect("");
-    let keys = vec![b"k1-0", b"k1-1", b"k1-2", b"k1-3", b"k1-4", b"k1-5", b"k1-6", b"k1-7",
-                    b"k1-8"];
+    let keys = vec![
+        b"k1-0",
+        b"k1-1",
+        b"k1-2",
+        b"k1-3",
+        b"k1-4",
+        b"k1-5",
+        b"k1-6",
+        b"k1-7",
+        b"k1-8",
+    ];
 
     // create db with no prefix extractor, and insert data
     {
@@ -57,16 +66,20 @@ fn test_prefix_extractor_compatibility() {
         let mut cf_opts = ColumnFamilyOptions::new();
         opts.create_if_missing(false);
         cf_opts.set_block_based_table_factory(&bbto);
-        cf_opts.set_prefix_extractor("FixedPrefixTransform",
-                                  Box::new(FixedPrefixTransform { prefix_len: 2 }))
+        cf_opts
+            .set_prefix_extractor(
+                "FixedPrefixTransform",
+                Box::new(FixedPrefixTransform { prefix_len: 2 }),
+            )
             .unwrap();
         // also create prefix bloom for memtable
         cf_opts.set_memtable_prefix_bloom_size_ratio(0.1 as f64);
-        let db = DB::open_cf(opts,
+        let db = DB::open_cf(
+            opts,
             path.path().to_str().unwrap(),
             vec!["default"],
-                             vec![cf_opts])
-            .unwrap();
+            vec![cf_opts],
+        ).unwrap();
         let wopts = WriteOptions::new();
 
         // sst2 with prefix bloom.

tests/test_rocksdb_options.rs

@@ -11,11 +11,11 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use rocksdb::{DB, ColumnFamilyOptions, DBOptions, BlockBasedOptions, WriteOptions, ReadOptions,
-              SliceTransform, Writable, CompactOptions, SeekKey};
-use rocksdb::crocksdb_ffi::{DBStatisticsHistogramType as HistogramType,
-                            DBStatisticsTickerType as TickerType, DBInfoLogLevel as InfoLogLevel,
-                            CompactionPriority, DBCompressionType};
+use rocksdb::{BlockBasedOptions, ColumnFamilyOptions, CompactOptions, DBOptions, ReadOptions,
+              SeekKey, SliceTransform, Writable, WriteOptions, DB};
+use rocksdb::crocksdb_ffi::{CompactionPriority, DBCompressionType, DBInfoLogLevel as InfoLogLevel,
+                            DBStatisticsHistogramType as HistogramType,
+                            DBStatisticsTickerType as TickerType};
 use std::path::Path;
 use std::thread;
 use std::time::Duration;
@@ -29,11 +29,12 @@ fn test_set_num_levels() {
     let mut cf_opts = ColumnFamilyOptions::new();
     opts.create_if_missing(true);
     cf_opts.set_num_levels(2);
-    let db = DB::open_cf(opts,
+    let db = DB::open_cf(
+        opts,
         path.path().to_str().unwrap(),
         vec!["default"],
-                         vec![cf_opts])
-        .unwrap();
+        vec![cf_opts],
+    ).unwrap();
     drop(db);
 }
 
@@ -71,14 +72,22 @@ fn test_enable_statistics() {
     opts.enable_statistics();
     opts.set_stats_dump_period_sec(60);
     assert!(opts.get_statistics().is_some());
-    assert!(opts.get_statistics_histogram_string(HistogramType::SeekMicros)
-        .is_some());
-    assert_eq!(opts.get_statistics_ticker_count(TickerType::BlockCacheMiss),
-               0);
-    assert_eq!(opts.get_and_reset_statistics_ticker_count(TickerType::BlockCacheMiss),
-               0);
-    assert_eq!(opts.get_statistics_ticker_count(TickerType::BlockCacheMiss),
-               0);
+    assert!(
+        opts.get_statistics_histogram_string(HistogramType::SeekMicros)
+            .is_some()
+    );
+    assert_eq!(
+        opts.get_statistics_ticker_count(TickerType::BlockCacheMiss),
+        0
+    );
+    assert_eq!(
+        opts.get_and_reset_statistics_ticker_count(TickerType::BlockCacheMiss),
+        0
+    );
+    assert_eq!(
+        opts.get_statistics_ticker_count(TickerType::BlockCacheMiss),
+        0
+    );
 
     let opts = DBOptions::new();
     assert!(opts.get_statistics().is_none());
@@ -104,16 +113,18 @@ fn test_memtable_insert_hint_prefix_extractor() {
     let mut opts = DBOptions::new();
     let mut cf_opts = ColumnFamilyOptions::new();
     opts.create_if_missing(true);
-    cf_opts.set_memtable_insert_hint_prefix_extractor("FixedPrefixTransform",
-                                                   Box::new(FixedPrefixTransform {
-                                                       prefix_len: 2,
-                                                   }))
+    cf_opts
+        .set_memtable_insert_hint_prefix_extractor(
+            "FixedPrefixTransform",
+            Box::new(FixedPrefixTransform { prefix_len: 2 }),
+        )
         .unwrap();
-    let db = DB::open_cf(opts,
+    let db = DB::open_cf(
+        opts,
         path.path().to_str().unwrap(),
         vec!["default"],
-                         vec![cf_opts])
-        .unwrap();
+        vec![cf_opts],
+    ).unwrap();
     let wopts = WriteOptions::new();
 
     db.put_opt(b"k0-1", b"a", &wopts).unwrap();
@@ -229,11 +240,12 @@ fn test_set_pin_l0_filter_and_index_blocks_in_cache() {
     let mut block_opts = BlockBasedOptions::new();
     block_opts.set_pin_l0_filter_and_index_blocks_in_cache(true);
     cf_opts.set_block_based_table_factory(&block_opts);
-    DB::open_cf(opts,
+    DB::open_cf(
+        opts,
         path.path().to_str().unwrap(),
         vec!["default"],
-                vec![cf_opts])
-        .unwrap();
+        vec![cf_opts],
+    ).unwrap();
 }
 #[test]
 fn test_pending_compaction_bytes_limit() {
@@ -243,11 +255,12 @@ fn test_pending_compaction_bytes_limit() {
     opts.create_if_missing(true);
     cf_opts.set_soft_pending_compaction_bytes_limit(64 * 1024 * 1024 * 1024);
     cf_opts.set_hard_pending_compaction_bytes_limit(256 * 1024 * 1024 * 1024);
-    DB::open_cf(opts,
+    DB::open_cf(
+        opts,
         path.path().to_str().unwrap(),
         vec!["default"],
-                vec![cf_opts])
-        .unwrap();
+        vec![cf_opts],
+    ).unwrap();
 }
 
 #[test]
@@ -276,11 +289,12 @@ fn test_set_optimize_filters_for_hits() {
     let mut cf_opts = ColumnFamilyOptions::new();
     opts.create_if_missing(true);
     cf_opts.set_optimize_filters_for_hits(true);
-    DB::open_cf(opts,
+    DB::open_cf(
+        opts,
         path.path().to_str().unwrap(),
         vec!["default"],
-                vec![cf_opts])
-        .unwrap();
+        vec![cf_opts],
+    ).unwrap();
 }
 
 #[test]
@@ -295,11 +309,12 @@ fn test_get_block_cache_usage() {
     let mut block_opts = BlockBasedOptions::new();
     block_opts.set_lru_cache(16 * 1024 * 1024);
     cf_opts.set_block_based_table_factory(&block_opts);
-    let db = DB::open_cf(opts,
+    let db = DB::open_cf(
+        opts,
         path.path().to_str().unwrap(),
         vec!["default"],
-                         vec![cf_opts])
-        .unwrap();
+        vec![cf_opts],
+    ).unwrap();
 
     for i in 0..200 {
         db.put(format!("k_{}", i).as_bytes(), b"v").unwrap();
@@ -319,11 +334,12 @@ fn test_set_level_compaction_dynamic_level_bytes() {
     let mut cf_opts = ColumnFamilyOptions::new();
     opts.create_if_missing(true);
     cf_opts.set_level_compaction_dynamic_level_bytes(true);
-    DB::open_cf(opts,
+    DB::open_cf(
+        opts,
         path.path().to_str().unwrap(),
         vec!["default"],
-                vec![cf_opts])
-        .unwrap();
+        vec![cf_opts],
+    ).unwrap();
 }
 
 #[test]
@@ -375,11 +391,12 @@ fn test_set_compaction_pri() {
     let mut cf_opts = ColumnFamilyOptions::new();
     opts.create_if_missing(true);
     cf_opts.compaction_priority(CompactionPriority::MinOverlappingRatio);
-    DB::open_cf(opts,
+    DB::open_cf(
+        opts,
         path.path().to_str().unwrap(),
         vec!["default"],
-                vec![cf_opts])
-        .unwrap();
+        vec![cf_opts],
+    ).unwrap();
 }
 
 #[test]
@@ -438,11 +455,12 @@ fn test_bottommost_compression() {
     let cf_opts = ColumnFamilyOptions::new();
     opts.create_if_missing(true);
     cf_opts.bottommost_compression(DBCompressionType::No);
-    DB::open_cf(opts,
+    DB::open_cf(
+        opts,
         path.path().to_str().unwrap(),
         vec!["default"],
-                vec![cf_opts])
-        .unwrap();
+        vec![cf_opts],
+    ).unwrap();
 }
 
 #[test]

tests/test_slice_transform.rs

@@ -11,8 +11,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use rocksdb::{Writable, DB, SliceTransform, ColumnFamilyOptions, DBOptions, SeekKey,
-              BlockBasedOptions};
+use rocksdb::{BlockBasedOptions, ColumnFamilyOptions, DBOptions, SeekKey, SliceTransform,
+              Writable, DB};
 use tempdir::TempDir;
 
 struct FixedPostfixTransform {
@@ -43,19 +43,23 @@ fn test_slice_transform() {
     cf_opts.set_block_based_table_factory(&block_opts);
     cf_opts.set_memtable_prefix_bloom_size_ratio(0.25);
 
-    cf_opts.set_prefix_extractor("test", Box::new(FixedPostfixTransform { postfix_len: 2 }))
+    cf_opts
+        .set_prefix_extractor("test", Box::new(FixedPostfixTransform { postfix_len: 2 }))
         .unwrap();
     opts.create_if_missing(true);
 
-    let db = DB::open_cf(opts,
+    let db = DB::open_cf(
+        opts,
         path.path().to_str().unwrap(),
         vec!["default"],
-                         vec![cf_opts])
-        .unwrap();
-    let samples = vec![(b"key_01".to_vec(), b"1".to_vec()),
+        vec![cf_opts],
+    ).unwrap();
+    let samples = vec![
+        (b"key_01".to_vec(), b"1".to_vec()),
         (b"key_02".to_vec(), b"2".to_vec()),
         (b"key_0303".to_vec(), b"3".to_vec()),
-                       (b"key_0404".to_vec(), b"4".to_vec())];
+        (b"key_0404".to_vec(), b"4".to_vec()),
+    ];
 
     for &(ref k, ref v) in &samples {
         db.put(k, v).unwrap();
@@ -64,17 +68,23 @@ fn test_slice_transform() {
 
     let mut it = db.iter();
 
-    let invalid_seeks =
-        vec![b"key_".to_vec(), b"key_0".to_vec(), b"key_030".to_vec(), b"key_03000".to_vec()];
+    let invalid_seeks = vec![
+        b"key_".to_vec(),
+        b"key_0".to_vec(),
+        b"key_030".to_vec(),
+        b"key_03000".to_vec(),
+    ];
 
     for key in invalid_seeks {
         it.seek(SeekKey::Key(&key));
         assert!(!it.valid());
     }
 
-    let valid_seeks = vec![(b"key_00".to_vec(), b"key_01".to_vec()),
+    let valid_seeks = vec![
+        (b"key_00".to_vec(), b"key_01".to_vec()),
         (b"key_03".to_vec(), b"key_0303".to_vec()),
-                           (b"key_0301".to_vec(), b"key_0303".to_vec())];
+        (b"key_0301".to_vec(), b"key_0303".to_vec()),
+    ];
 
     for (key, expect_key) in valid_seeks {
         it.seek(SeekKey::Key(&key));

tests/test_statistics.rs

@@ -12,7 +12,7 @@
 // limitations under the License.
 
 use rocksdb::*;
-use rocksdb::{DBStatisticsTickerType as TickerType, DBStatisticsHistogramType as HistogramType};
+use rocksdb::{DBStatisticsHistogramType as HistogramType, DBStatisticsTickerType as TickerType};
 use tempdir::TempDir;
 
 #[test]
@@ -35,8 +35,12 @@ fn test_db_statistics() {
     assert!(db.get_statistics_ticker_count(TickerType::BlockCacheHit) > 0);
     assert!(db.get_and_reset_statistics_ticker_count(TickerType::BlockCacheHit) > 0);
     assert_eq!(db.get_statistics_ticker_count(TickerType::BlockCacheHit), 0);
-    assert!(db.get_statistics_histogram_string(HistogramType::GetMicros)
-        .is_some());
-    assert!(db.get_statistics_histogram(HistogramType::GetMicros)
-        .is_some());
+    assert!(
+        db.get_statistics_histogram_string(HistogramType::GetMicros)
+            .is_some()
+    );
+    assert!(
+        db.get_statistics_histogram(HistogramType::GetMicros)
+            .is_some()
+    );
 }

tests/test_table_properties.rs

@@ -12,9 +12,9 @@
 // limitations under the License.
 
 use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt};
-use rocksdb::{DB, Range, ColumnFamilyOptions, DBOptions, Writable, DBEntryType,
-              TablePropertiesCollection, TablePropertiesCollector,
-              TablePropertiesCollectorFactory, UserCollectedProperties};
+use rocksdb::{ColumnFamilyOptions, DBEntryType, DBOptions, Range, TablePropertiesCollection,
+              TablePropertiesCollector, TablePropertiesCollectorFactory, UserCollectedProperties,
+              Writable, DB};
 use std::collections::HashMap;
 use std::fmt;
 use tempdir::TempDir;
@@ -82,7 +82,11 @@ impl ExampleCollector {
         for (k, v) in props {
             assert_eq!(v, props.get(k).unwrap());
         }
-        assert!(props.get(&[Props::NumKeys as u8, Props::NumPuts as u8]).is_none());
+        assert!(
+            props
+                .get(&[Props::NumKeys as u8, Props::NumPuts as u8])
+                .is_none()
+        );
         assert!(props.len() >= 4);
 
         c
@@ -91,12 +95,14 @@ impl ExampleCollector {
 
 impl fmt::Display for ExampleCollector {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f,
+        write!(
+            f,
             "keys={}, puts={}, merges={}, deletes={}",
             self.num_keys,
             self.num_puts,
             self.num_merges,
-               self.num_deletes)
+            self.num_deletes
+        )
     }
 }
 
@@ -110,8 +116,7 @@ impl TablePropertiesCollector for ExampleCollector {
         match entry_type {
             DBEntryType::Put => self.num_puts += 1,
             DBEntryType::Merge => self.num_merges += 1,
-            DBEntryType::Delete |
-            DBEntryType::SingleDelete => self.num_deletes += 1,
+            DBEntryType::Delete | DBEntryType::SingleDelete => self.num_deletes += 1,
             DBEntryType::Other => {}
         }
     }
@@ -135,12 +140,14 @@ impl TablePropertiesCollectorFactory for ExampleFactory {
     }
 }
 
-fn check_collection(collection: &TablePropertiesCollection,
+fn check_collection(
+    collection: &TablePropertiesCollection,
     num_files: usize,
     num_keys: u32,
     num_puts: u32,
     num_merges: u32,
-                    num_deletes: u32) {
+    num_deletes: u32,
+) {
     let mut res = ExampleCollector::new();
     assert!(!collection.is_empty());
     let props: HashMap<_, _> = collection.iter().collect();
@@ -166,16 +173,19 @@ fn test_table_properties_collector_factory() {
     cf_opts.add_table_properties_collector_factory("example-collector", Box::new(f));
 
     let path = TempDir::new("_rust_rocksdb_collectortest").expect("");
-    let db = DB::open_cf(opts,
+    let db = DB::open_cf(
+        opts,
         path.path().to_str().unwrap(),
         vec!["default"],
-                         vec![cf_opts])
-        .unwrap();
+        vec![cf_opts],
+    ).unwrap();
 
-    let samples = vec![(b"key1".to_vec(), b"value1".to_vec()),
+    let samples = vec![
+        (b"key1".to_vec(), b"value1".to_vec()),
         (b"key2".to_vec(), b"value2".to_vec()),
         (b"key3".to_vec(), b"value3".to_vec()),
-                       (b"key4".to_vec(), b"value4".to_vec())];
+        (b"key4".to_vec(), b"value4".to_vec()),
+    ];
 
     // Put 4 keys.
     for &(ref k, ref v) in &samples {

travis-build/Makefile

 prepare-rustfmt:
-	curl -L https://github.com/tennix/rustfmt/releases/download/v0.6/rustfmt-${RUSTFMT_VERSION}-linux-amd64.tar.gz -o rustfmt-${RUSTFMT_VERSION}-linux-amd64.tar.gz && \
-	mkdir -p ${HOME}/.cargo/bin && tar xzf rustfmt-${RUSTFMT_VERSION}-linux-amd64.tar.gz -C ${HOME}/.cargo/bin --strip-components=1
+	@[[ "`cargo fmt -- --version`" = "0.2.1-nightly ( )" ]] || cargo install --vers 0.2.1 --force rustfmt-nightly || exit 0
\ No newline at end of file