From cc3a2bec59c9cbe8a2fa4d145d70b59c8b58eadd Mon Sep 17 00:00:00 2001 From: Oleksandr Anyshchenko Date: Fri, 6 Aug 2021 16:58:05 +0300 Subject: [PATCH] Fixes suggested by clippy (#547) --- src/backup.rs | 6 ++-- src/checkpoint.rs | 4 ++- src/db.rs | 10 +++--- src/db_options.rs | 82 ++++++++++++++++++++++++++++++------------ src/lib.rs | 1 - src/sst_file_writer.rs | 4 ++- src/write_batch.rs | 4 ++- 7 files changed, 77 insertions(+), 34 deletions(-) diff --git a/src/backup.rs b/src/backup.rs index f6fb733..d566eeb 100644 --- a/src/backup.rs +++ b/src/backup.rs @@ -61,7 +61,9 @@ impl BackupEngine { }; let be: *mut ffi::rocksdb_backup_engine_t; - unsafe { be = ffi_try!(ffi::rocksdb_backup_engine_open(opts.inner, cpath.as_ptr())) } + unsafe { + be = ffi_try!(ffi::rocksdb_backup_engine_open(opts.inner, cpath.as_ptr())); + } if be.is_null() { return Err(Error::new("Could not initialize backup engine.".to_owned())); @@ -204,7 +206,7 @@ impl BackupEngine { backup_id: ffi::rocksdb_backup_engine_info_backup_id(i, index), size: ffi::rocksdb_backup_engine_info_size(i, index), num_files: ffi::rocksdb_backup_engine_info_number_files(i, index), - }) + }); } // destroy backup info object diff --git a/src/checkpoint.rs b/src/checkpoint.rs index ff2a640..49bbaef 100644 --- a/src/checkpoint.rs +++ b/src/checkpoint.rs @@ -40,7 +40,9 @@ impl<'db> Checkpoint<'db> { pub fn new(db: &'db DB) -> Result { let checkpoint: *mut ffi::rocksdb_checkpoint_t; - unsafe { checkpoint = ffi_try!(ffi::rocksdb_checkpoint_object_create(db.inner)) }; + unsafe { + checkpoint = ffi_try!(ffi::rocksdb_checkpoint_object_create(db.inner)); + } if checkpoint.is_null() { return Err(Error::new("Could not create checkpoint object.".to_owned())); diff --git a/src/db.rs b/src/db.rs index f923a16..8b2c7bb 100644 --- a/src/db.rs +++ b/src/db.rs @@ -431,7 +431,7 @@ impl DBWithThreadMode { &cfnames, &cfopts, &mut cfhandles, - &access_type, + access_type, )?; for handle in &cfhandles { if handle.is_null() { @@ -586,7 +586,7 @@ impl DBWithThreadMode { } pub fn path(&self) -> &Path { - &self.path.as_path() + self.path.as_path() } /// Flushes the WAL buffer. If `sync` is set to `true`, also syncs @@ -1587,7 +1587,7 @@ impl DBWithThreadMode { let cpaths: Vec<_> = paths_v.iter().map(|path| path.as_ptr()).collect(); - self.ingest_external_file_raw(&opts, &paths_v, &cpaths) + self.ingest_external_file_raw(opts, &paths_v, &cpaths) } /// Loads a list of external SST files created with SstFileWriter into the DB for given Column Family @@ -1615,7 +1615,7 @@ impl DBWithThreadMode { let cpaths: Vec<_> = paths_v.iter().map(|path| path.as_ptr()).collect(); - self.ingest_external_file_raw_cf(cf, &opts, &paths_v, &cpaths) + self.ingest_external_file_raw_cf(cf, opts, &paths_v, &cpaths) } fn ingest_external_file_raw( @@ -1688,7 +1688,7 @@ impl DBWithThreadMode { end_key: largest_key, num_entries: ffi::rocksdb_livefiles_entries(files, i), num_deletions: ffi::rocksdb_livefiles_deletions(files, i), - }) + }); } // destroy livefiles metadata(s) diff --git a/src/db_options.rs b/src/db_options.rs index c51d40e..2886497 100644 --- a/src/db_options.rs +++ b/src/db_options.rs @@ -451,13 +451,17 @@ impl Drop for WriteOptions { impl Drop for ReadOptions { fn drop(&mut self) { - unsafe { ffi::rocksdb_readoptions_destroy(self.inner) } + unsafe { + ffi::rocksdb_readoptions_destroy(self.inner); + } } } impl Drop for IngestExternalFileOptions { fn drop(&mut self) { - unsafe { ffi::rocksdb_ingestexternalfileoptions_destroy(self.inner) } + unsafe { + ffi::rocksdb_ingestexternalfileoptions_destroy(self.inner); + } } } @@ -684,7 +688,9 @@ impl BlockBasedOptions { /// ``` pub fn set_data_block_index_type(&mut self, index_type: DataBlockIndexType) { let index_t = index_type as i32; - unsafe { ffi::rocksdb_block_based_options_set_data_block_index_type(self.inner, index_t) } + unsafe { + ffi::rocksdb_block_based_options_set_data_block_index_type(self.inner, index_t); + } } /// Set the data block hash index utilization ratio. @@ -695,7 +701,9 @@ impl BlockBasedOptions { /// /// Default: 0.75 pub fn set_data_block_hash_ratio(&mut self, ratio: f64) { - unsafe { ffi::rocksdb_block_based_options_set_data_block_hash_ratio(self.inner, ratio) } + unsafe { + ffi::rocksdb_block_based_options_set_data_block_hash_ratio(self.inner, ratio); + } } } @@ -717,7 +725,9 @@ impl CuckooTableOptions { /// result in larger hash tables with fewer collisions. /// Default: 0.9 pub fn set_hash_ratio(&mut self, ratio: f64) { - unsafe { ffi::rocksdb_cuckoo_options_set_hash_ratio(self.inner, ratio) } + unsafe { + ffi::rocksdb_cuckoo_options_set_hash_ratio(self.inner, ratio); + } } /// A property used by builder to determine the depth to go to @@ -727,7 +737,9 @@ impl CuckooTableOptions { /// lookups but take more time to build. /// Default: 100 pub fn set_max_search_depth(&mut self, depth: u32) { - unsafe { ffi::rocksdb_cuckoo_options_set_max_search_depth(self.inner, depth) } + unsafe { + ffi::rocksdb_cuckoo_options_set_max_search_depth(self.inner, depth); + } } /// In case of collision while inserting, the builder @@ -737,7 +749,9 @@ impl CuckooTableOptions { /// of collisions. /// Default: 5 pub fn set_cuckoo_block_size(&mut self, size: u32) { - unsafe { ffi::rocksdb_cuckoo_options_set_cuckoo_block_size(self.inner, size) } + unsafe { + ffi::rocksdb_cuckoo_options_set_cuckoo_block_size(self.inner, size); + } } /// If this option is enabled, user key is treated as uint64_t and its value @@ -747,7 +761,9 @@ impl CuckooTableOptions { /// Default: false pub fn set_identity_as_first_hash(&mut self, flag: bool) { let v = flag as u8; - unsafe { ffi::rocksdb_cuckoo_options_set_identity_as_first_hash(self.inner, v) } + unsafe { + ffi::rocksdb_cuckoo_options_set_identity_as_first_hash(self.inner, v); + } } /// If this option is set to true, module is used during hash calculation. @@ -757,7 +773,9 @@ impl CuckooTableOptions { /// Default: true pub fn set_use_module_hash(&mut self, flag: bool) { let v = flag as u8; - unsafe { ffi::rocksdb_cuckoo_options_set_use_module_hash(self.inner, v) } + unsafe { + ffi::rocksdb_cuckoo_options_set_use_module_hash(self.inner, v); + } } } @@ -1006,7 +1024,7 @@ impl Options { self.inner, level_types.as_mut_ptr(), level_types.len() as size_t, - ) + ); } } @@ -1231,7 +1249,9 @@ impl Options { } pub fn set_prefix_extractor(&mut self, prefix_extractor: SliceTransform) { - unsafe { ffi::rocksdb_options_set_prefix_extractor(self.inner, prefix_extractor.inner) } + unsafe { + ffi::rocksdb_options_set_prefix_extractor(self.inner, prefix_extractor.inner); + } } #[deprecated( @@ -1340,7 +1360,9 @@ impl Options { /// opts.set_use_fsync(true); /// ``` pub fn set_use_fsync(&mut self, useit: bool) { - unsafe { ffi::rocksdb_options_set_use_fsync(self.inner, useit as c_int) } + unsafe { + ffi::rocksdb_options_set_use_fsync(self.inner, useit as c_int); + } } /// Specifies the absolute info LOG dir. @@ -1432,7 +1454,7 @@ impl Options { /// ``` pub fn set_allow_concurrent_memtable_write(&mut self, allow: bool) { unsafe { - ffi::rocksdb_options_set_allow_concurrent_memtable_write(self.inner, allow as c_uchar) + ffi::rocksdb_options_set_allow_concurrent_memtable_write(self.inner, allow as c_uchar); } } @@ -1595,7 +1617,7 @@ impl Options { /// Dynamically changeable through SetOptions() API pub fn set_target_file_size_multiplier(&mut self, multiplier: i32) { unsafe { - ffi::rocksdb_options_set_target_file_size_multiplier(self.inner, multiplier as c_int) + ffi::rocksdb_options_set_target_file_size_multiplier(self.inner, multiplier as c_int); } } @@ -2045,7 +2067,9 @@ impl Options { /// opts.set_disable_auto_compactions(true); /// ``` pub fn set_disable_auto_compactions(&mut self, disable: bool) { - unsafe { ffi::rocksdb_options_set_disable_auto_compactions(self.inner, disable as c_int) } + unsafe { + ffi::rocksdb_options_set_disable_auto_compactions(self.inner, disable as c_int); + } } /// SetMemtableHugePageSize sets the page size for huge page for @@ -2060,7 +2084,9 @@ impl Options { /// /// Dynamically changeable through SetOptions() API pub fn set_memtable_huge_page_size(&mut self, size: size_t) { - unsafe { ffi::rocksdb_options_set_memtable_huge_page_size(self.inner, size) } + unsafe { + ffi::rocksdb_options_set_memtable_huge_page_size(self.inner, size); + } } /// Sets the maximum number of successive merge operations on a key in the memtable. @@ -2132,7 +2158,7 @@ impl Options { self.inner, level_values.as_ptr() as *mut c_int, count, - ) + ); } } @@ -2149,7 +2175,7 @@ impl Options { ffi::rocksdb_options_set_skip_checking_sst_file_sizes_on_db_open( self.inner, value as c_uchar, - ) + ); } } @@ -2184,7 +2210,9 @@ impl Options { /// be set to the value of 'max_write_buffer_number * write_buffer_size' /// if it is not explicitly set by the user. Otherwise, the default is 0. pub fn set_max_write_buffer_size_to_maintain(&mut self, size: i64) { - unsafe { ffi::rocksdb_options_set_max_write_buffer_size_to_maintain(self.inner, size) } + unsafe { + ffi::rocksdb_options_set_max_write_buffer_size_to_maintain(self.inner, size); + } } /// By default, a single write thread queue is maintained. The thread gets @@ -2201,7 +2229,9 @@ impl Options { /// /// Default: false pub fn set_enable_pipelined_write(&mut self, value: bool) { - unsafe { ffi::rocksdb_options_set_enable_pipelined_write(self.inner, value as c_uchar) } + unsafe { + ffi::rocksdb_options_set_enable_pipelined_write(self.inner, value as c_uchar); + } } /// Defines the underlying memtable implementation. @@ -2439,7 +2469,9 @@ impl Options { /// /// Default: `true` pub fn set_advise_random_on_open(&mut self, advise: bool) { - unsafe { ffi::rocksdb_options_set_advise_random_on_open(self.inner, advise as c_uchar) } + unsafe { + ffi::rocksdb_options_set_advise_random_on_open(self.inner, advise as c_uchar); + } } /// Specifies the file access pattern once a compaction is started. @@ -3110,7 +3142,9 @@ impl ReadOptions { /// /// Default: false pub fn set_prefix_same_as_start(&mut self, v: bool) { - unsafe { ffi::rocksdb_readoptions_set_prefix_same_as_start(self.inner, v as c_uchar) } + unsafe { + ffi::rocksdb_readoptions_set_prefix_same_as_start(self.inner, v as c_uchar); + } } /// Enable a total order seek regardless of index format (e.g. hash index) @@ -3121,7 +3155,9 @@ impl ReadOptions { /// block based table. It provides a way to read existing data after /// changing implementation of prefix extractor. pub fn set_total_order_seek(&mut self, v: bool) { - unsafe { ffi::rocksdb_readoptions_set_total_order_seek(self.inner, v as c_uchar) } + unsafe { + ffi::rocksdb_readoptions_set_total_order_seek(self.inner, v as c_uchar); + } } /// Sets a threshold for the number of keys that can be skipped diff --git a/src/lib.rs b/src/lib.rs index be9d02a..71fee88 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -60,7 +60,6 @@ clippy::cast_possible_wrap, clippy::cast_possible_truncation, clippy::cast_sign_loss, // Next lints produce too much noise/false positives. clippy::module_name_repetitions, clippy::similar_names, clippy::must_use_candidate, - clippy::pub_enum_variant_names, // '... may panic' lints. clippy::indexing_slicing, // Too much work to fix. diff --git a/src/sst_file_writer.rs b/src/sst_file_writer.rs index 2aa84b5..81a2f09 100644 --- a/src/sst_file_writer.rs +++ b/src/sst_file_writer.rs @@ -94,7 +94,9 @@ impl<'a> SstFileWriter<'a> { /// returns the current file size pub fn file_size(&self) -> u64 { let mut file_size: u64 = 0; - unsafe { ffi::rocksdb_sstfilewriter_file_size(self.inner, &mut file_size) }; + unsafe { + ffi::rocksdb_sstfilewriter_file_size(self.inner, &mut file_size); + } file_size } diff --git a/src/write_batch.rs b/src/write_batch.rs index 16a9ff7..54d4cc7 100644 --- a/src/write_batch.rs +++ b/src/write_batch.rs @@ -276,7 +276,9 @@ impl Default for WriteBatch { impl Drop for WriteBatch { fn drop(&mut self) { - unsafe { ffi::rocksdb_writebatch_destroy(self.inner) } + unsafe { + ffi::rocksdb_writebatch_destroy(self.inner); + } } }